1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004 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) #X,
63 const char *const 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 (tree
);
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
, 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
, rtx
, enum machine_mode
, int);
116 static rtx
expand_builtin_memmove (tree
, rtx
, enum machine_mode
);
117 static rtx
expand_builtin_bcopy (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
, rtx
, enum machine_mode
);
128 static rtx
expand_builtin_strpbrk (tree
, rtx
, enum machine_mode
);
129 static rtx
expand_builtin_strchr (tree
, rtx
, enum machine_mode
);
130 static rtx
expand_builtin_strrchr (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_sin (tree
);
156 static tree
fold_builtin_cos (tree
, tree
, tree
);
157 static tree
fold_builtin_tan (tree
);
158 static tree
fold_builtin_atan (tree
, tree
);
159 static tree
fold_builtin_trunc (tree
);
160 static tree
fold_builtin_floor (tree
);
161 static tree
fold_builtin_ceil (tree
);
162 static tree
fold_builtin_round (tree
);
163 static tree
fold_builtin_bitop (tree
);
164 static tree
fold_builtin_memcpy (tree
);
165 static tree
fold_builtin_mempcpy (tree
);
166 static tree
fold_builtin_memmove (tree
);
167 static tree
fold_builtin_strchr (tree
, bool);
168 static tree
fold_builtin_memcmp (tree
);
169 static tree
fold_builtin_strcmp (tree
);
170 static tree
fold_builtin_strncmp (tree
);
171 static tree
fold_builtin_signbit (tree
);
172 static tree
fold_builtin_copysign (tree
, tree
);
173 static tree
fold_builtin_isascii (tree
);
174 static tree
fold_builtin_toascii (tree
);
175 static tree
fold_builtin_isdigit (tree
);
176 static tree
fold_builtin_fabs (tree
, tree
);
177 static tree
fold_builtin_abs (tree
, tree
);
178 static tree
fold_builtin_unordered_cmp (tree
, enum tree_code
, enum tree_code
);
179 static tree
fold_builtin_1 (tree
, bool);
181 static tree
simplify_builtin_strpbrk (tree
);
182 static tree
simplify_builtin_strstr (tree
);
183 static tree
simplify_builtin_strchr (tree
);
184 static tree
simplify_builtin_strrchr (tree
);
185 static tree
simplify_builtin_strcat (tree
);
186 static tree
simplify_builtin_strncat (tree
);
187 static tree
simplify_builtin_strspn (tree
);
188 static tree
simplify_builtin_strcspn (tree
);
189 static void simplify_builtin_next_arg (tree
);
190 static void simplify_builtin_va_start (tree
);
191 static tree
simplify_builtin_sprintf (tree
, int);
194 /* Return the alignment in bits of EXP, a pointer valued expression.
195 But don't return more than MAX_ALIGN no matter what.
196 The alignment returned is, by default, the alignment of the thing that
197 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
199 Otherwise, look at the expression to see if we can do better, i.e., if the
200 expression is actually pointing at an object whose alignment is tighter. */
203 get_pointer_alignment (tree exp
, unsigned int max_align
)
205 unsigned int align
, inner
;
207 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
210 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
211 align
= MIN (align
, max_align
);
215 switch (TREE_CODE (exp
))
219 case NON_LVALUE_EXPR
:
220 exp
= TREE_OPERAND (exp
, 0);
221 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
224 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
225 align
= MIN (inner
, max_align
);
229 /* If sum of pointer + int, restrict our maximum alignment to that
230 imposed by the integer. If not, we can't do any better than
232 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
235 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
236 & (max_align
/ BITS_PER_UNIT
- 1))
240 exp
= TREE_OPERAND (exp
, 0);
244 /* See what we are pointing at and look at its alignment. */
245 exp
= TREE_OPERAND (exp
, 0);
246 if (TREE_CODE (exp
) == FUNCTION_DECL
)
247 align
= FUNCTION_BOUNDARY
;
248 else if (DECL_P (exp
))
249 align
= DECL_ALIGN (exp
);
250 #ifdef CONSTANT_ALIGNMENT
251 else if (CONSTANT_CLASS_P (exp
))
252 align
= CONSTANT_ALIGNMENT (exp
, align
);
254 return MIN (align
, max_align
);
262 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
263 way, because it could contain a zero byte in the middle.
264 TREE_STRING_LENGTH is the size of the character array, not the string.
266 ONLY_VALUE should be nonzero if the result is not going to be emitted
267 into the instruction stream and zero if it is going to be expanded.
268 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
269 is returned, otherwise NULL, since
270 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
271 evaluate the side-effects.
273 The value returned is of type `ssizetype'.
275 Unfortunately, string_constant can't access the values of const char
276 arrays with initializers, so neither can we do so here. */
279 c_strlen (tree src
, int only_value
)
282 HOST_WIDE_INT offset
;
287 if (TREE_CODE (src
) == COND_EXPR
288 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
292 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
293 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
294 if (tree_int_cst_equal (len1
, len2
))
298 if (TREE_CODE (src
) == COMPOUND_EXPR
299 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
300 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
302 src
= string_constant (src
, &offset_node
);
306 max
= TREE_STRING_LENGTH (src
) - 1;
307 ptr
= TREE_STRING_POINTER (src
);
309 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
311 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
312 compute the offset to the following null if we don't know where to
313 start searching for it. */
316 for (i
= 0; i
< max
; i
++)
320 /* We don't know the starting offset, but we do know that the string
321 has no internal zero bytes. We can assume that the offset falls
322 within the bounds of the string; otherwise, the programmer deserves
323 what he gets. Subtract the offset from the length of the string,
324 and return that. This would perhaps not be valid if we were dealing
325 with named arrays in addition to literal string constants. */
327 return size_diffop (size_int (max
), offset_node
);
330 /* We have a known offset into the string. Start searching there for
331 a null character if we can represent it as a single HOST_WIDE_INT. */
332 if (offset_node
== 0)
334 else if (! host_integerp (offset_node
, 0))
337 offset
= tree_low_cst (offset_node
, 0);
339 /* If the offset is known to be out of bounds, warn, and call strlen at
341 if (offset
< 0 || offset
> max
)
343 warning ("offset outside bounds of constant string");
347 /* Use strlen to search for the first zero byte. Since any strings
348 constructed with build_string will have nulls appended, we win even
349 if we get handed something like (char[4])"abcd".
351 Since OFFSET is our starting index into the string, no further
352 calculation is needed. */
353 return ssize_int (strlen (ptr
+ offset
));
356 /* Return a char pointer for a C string if it is a string constant
357 or sum of string constant and integer constant. */
364 src
= string_constant (src
, &offset_node
);
368 if (offset_node
== 0)
369 return TREE_STRING_POINTER (src
);
370 else if (!host_integerp (offset_node
, 1)
371 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
374 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
377 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
378 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
381 c_readstr (const char *str
, enum machine_mode mode
)
387 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
392 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
395 if (WORDS_BIG_ENDIAN
)
396 j
= GET_MODE_SIZE (mode
) - i
- 1;
397 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
398 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
399 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
401 gcc_assert (j
<= 2 * HOST_BITS_PER_WIDE_INT
);
404 ch
= (unsigned char) str
[i
];
405 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
407 return immed_double_const (c
[0], c
[1], mode
);
410 /* Cast a target constant CST to target CHAR and if that value fits into
411 host char type, return zero and put that value into variable pointed by
415 target_char_cast (tree cst
, char *p
)
417 unsigned HOST_WIDE_INT val
, hostval
;
419 if (!host_integerp (cst
, 1)
420 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
423 val
= tree_low_cst (cst
, 1);
424 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
425 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
428 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
429 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
438 /* Similar to save_expr, but assumes that arbitrary code is not executed
439 in between the multiple evaluations. In particular, we assume that a
440 non-addressable local variable will not be modified. */
443 builtin_save_expr (tree exp
)
445 if (TREE_ADDRESSABLE (exp
) == 0
446 && (TREE_CODE (exp
) == PARM_DECL
447 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
450 return save_expr (exp
);
453 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
454 times to get the address of either a higher stack frame, or a return
455 address located within it (depending on FNDECL_CODE). */
458 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
,
463 /* Some machines need special handling before we can access
464 arbitrary frames. For example, on the sparc, we must first flush
465 all register windows to the stack. */
466 #ifdef SETUP_FRAME_ADDRESSES
468 SETUP_FRAME_ADDRESSES ();
471 /* On the sparc, the return address is not in the frame, it is in a
472 register. There is no way to access it off of the current frame
473 pointer, but it can be accessed off the previous frame pointer by
474 reading the value from the register window save area. */
475 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
476 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
480 /* Scan back COUNT frames to the specified frame. */
481 for (i
= 0; i
< count
; i
++)
483 /* Assume the dynamic chain pointer is in the word that the
484 frame address points to, unless otherwise specified. */
485 #ifdef DYNAMIC_CHAIN_ADDRESS
486 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
488 tem
= memory_address (Pmode
, tem
);
489 tem
= gen_rtx_MEM (Pmode
, tem
);
490 set_mem_alias_set (tem
, get_frame_alias_set ());
491 tem
= copy_to_reg (tem
);
494 /* For __builtin_frame_address, return what we've got. */
495 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
498 /* For __builtin_return_address, Get the return address from that
500 #ifdef RETURN_ADDR_RTX
501 tem
= RETURN_ADDR_RTX (count
, tem
);
503 tem
= memory_address (Pmode
,
504 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
505 tem
= gen_rtx_MEM (Pmode
, tem
);
506 set_mem_alias_set (tem
, get_frame_alias_set ());
511 /* Alias set used for setjmp buffer. */
512 static HOST_WIDE_INT setjmp_alias_set
= -1;
514 /* Construct the leading half of a __builtin_setjmp call. Control will
515 return to RECEIVER_LABEL. This is used directly by sjlj exception
519 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
521 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
525 if (setjmp_alias_set
== -1)
526 setjmp_alias_set
= new_alias_set ();
528 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
530 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
532 /* We store the frame pointer and the address of receiver_label in
533 the buffer and use the rest of it for the stack save area, which
534 is machine-dependent. */
536 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
537 set_mem_alias_set (mem
, setjmp_alias_set
);
538 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
540 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
541 set_mem_alias_set (mem
, setjmp_alias_set
);
543 emit_move_insn (validize_mem (mem
),
544 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
546 stack_save
= gen_rtx_MEM (sa_mode
,
547 plus_constant (buf_addr
,
548 2 * GET_MODE_SIZE (Pmode
)));
549 set_mem_alias_set (stack_save
, setjmp_alias_set
);
550 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
552 /* If there is further processing to do, do it. */
553 #ifdef HAVE_builtin_setjmp_setup
554 if (HAVE_builtin_setjmp_setup
)
555 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
558 /* Tell optimize_save_area_alloca that extra work is going to
559 need to go on during alloca. */
560 current_function_calls_setjmp
= 1;
562 /* Set this so all the registers get saved in our frame; we need to be
563 able to copy the saved values for any registers from frames we unwind. */
564 current_function_has_nonlocal_label
= 1;
567 /* Construct the trailing part of a __builtin_setjmp call.
568 This is used directly by sjlj exception handling code. */
571 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
573 /* Clobber the FP when we get here, so we have to make sure it's
574 marked as used by this function. */
575 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
577 /* Mark the static chain as clobbered here so life information
578 doesn't get messed up for it. */
579 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
581 /* Now put in the code to restore the frame pointer, and argument
582 pointer, if needed. */
583 #ifdef HAVE_nonlocal_goto
584 if (! HAVE_nonlocal_goto
)
586 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
588 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
589 if (fixed_regs
[ARG_POINTER_REGNUM
])
591 #ifdef ELIMINABLE_REGS
593 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
595 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
596 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
597 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
600 if (i
== ARRAY_SIZE (elim_regs
))
603 /* Now restore our arg pointer from the address at which it
604 was saved in our stack frame. */
605 emit_move_insn (virtual_incoming_args_rtx
,
606 copy_to_reg (get_arg_pointer_save_area (cfun
)));
611 #ifdef HAVE_builtin_setjmp_receiver
612 if (HAVE_builtin_setjmp_receiver
)
613 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
616 #ifdef HAVE_nonlocal_goto_receiver
617 if (HAVE_nonlocal_goto_receiver
)
618 emit_insn (gen_nonlocal_goto_receiver ());
623 /* @@@ This is a kludge. Not all machine descriptions define a blockage
624 insn, but we must not allow the code we just generated to be reordered
625 by scheduling. Specifically, the update of the frame pointer must
626 happen immediately, not later. So emit an ASM_INPUT to act as blockage
628 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
631 /* __builtin_setjmp is passed a pointer to an array of five words (not
632 all will be used on all machines). It operates similarly to the C
633 library function of the same name, but is more efficient. Much of
634 the code below (and for longjmp) is copied from the handling of
637 NOTE: This is intended for use by GNAT and the exception handling
638 scheme in the compiler and will only work in the method used by
642 expand_builtin_setjmp (tree arglist
, rtx target
)
644 rtx buf_addr
, next_lab
, cont_lab
;
646 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
649 if (target
== 0 || !REG_P (target
)
650 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
651 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
653 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
655 next_lab
= gen_label_rtx ();
656 cont_lab
= gen_label_rtx ();
658 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
660 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
661 ensure that pending stack adjustments are flushed. */
662 emit_move_insn (target
, const0_rtx
);
663 emit_jump (cont_lab
);
665 emit_label (next_lab
);
667 expand_builtin_setjmp_receiver (next_lab
);
669 /* Set TARGET to one. */
670 emit_move_insn (target
, const1_rtx
);
671 emit_label (cont_lab
);
673 /* Tell flow about the strange goings on. Putting `next_lab' on
674 `nonlocal_goto_handler_labels' to indicates that function
675 calls may traverse the arc back to this label. */
677 current_function_has_nonlocal_label
= 1;
678 nonlocal_goto_handler_labels
679 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
684 /* __builtin_longjmp is passed a pointer to an array of five words (not
685 all will be used on all machines). It operates similarly to the C
686 library function of the same name, but is more efficient. Much of
687 the code below is copied from the handling of non-local gotos.
689 NOTE: This is intended for use by GNAT and the exception handling
690 scheme in the compiler and will only work in the method used by
694 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
696 rtx fp
, lab
, stack
, insn
, last
;
697 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
699 if (setjmp_alias_set
== -1)
700 setjmp_alias_set
= new_alias_set ();
702 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
704 buf_addr
= force_reg (Pmode
, buf_addr
);
706 /* We used to store value in static_chain_rtx, but that fails if pointers
707 are smaller than integers. We instead require that the user must pass
708 a second argument of 1, because that is what builtin_setjmp will
709 return. This also makes EH slightly more efficient, since we are no
710 longer copying around a value that we don't care about. */
711 gcc_assert (value
== const1_rtx
);
713 current_function_calls_longjmp
= 1;
715 last
= get_last_insn ();
716 #ifdef HAVE_builtin_longjmp
717 if (HAVE_builtin_longjmp
)
718 emit_insn (gen_builtin_longjmp (buf_addr
));
722 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
723 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
724 GET_MODE_SIZE (Pmode
)));
726 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
727 2 * GET_MODE_SIZE (Pmode
)));
728 set_mem_alias_set (fp
, setjmp_alias_set
);
729 set_mem_alias_set (lab
, setjmp_alias_set
);
730 set_mem_alias_set (stack
, setjmp_alias_set
);
732 /* Pick up FP, label, and SP from the block and jump. This code is
733 from expand_goto in stmt.c; see there for detailed comments. */
734 #if HAVE_nonlocal_goto
735 if (HAVE_nonlocal_goto
)
736 /* We have to pass a value to the nonlocal_goto pattern that will
737 get copied into the static_chain pointer, but it does not matter
738 what that value is, because builtin_setjmp does not use it. */
739 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
743 lab
= copy_to_reg (lab
);
745 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
746 gen_rtx_MEM (BLKmode
,
747 gen_rtx_SCRATCH (VOIDmode
))));
748 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
749 gen_rtx_MEM (BLKmode
,
750 hard_frame_pointer_rtx
)));
752 emit_move_insn (hard_frame_pointer_rtx
, fp
);
753 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
755 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
756 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
757 emit_indirect_jump (lab
);
761 /* Search backwards and mark the jump insn as a non-local goto.
762 Note that this precludes the use of __builtin_longjmp to a
763 __builtin_setjmp target in the same function. However, we've
764 already cautioned the user that these functions are for
765 internal exception handling use only. */
766 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
768 gcc_assert (insn
!= last
);
772 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
776 else if (CALL_P (insn
))
781 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
782 and the address of the save area. */
785 expand_builtin_nonlocal_goto (tree arglist
)
787 tree t_label
, t_save_area
;
788 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
790 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
793 t_label
= TREE_VALUE (arglist
);
794 arglist
= TREE_CHAIN (arglist
);
795 t_save_area
= TREE_VALUE (arglist
);
797 r_label
= expand_expr (t_label
, NULL_RTX
, VOIDmode
, 0);
798 r_label
= convert_memory_address (Pmode
, r_label
);
799 r_save_area
= expand_expr (t_save_area
, NULL_RTX
, VOIDmode
, 0);
800 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
801 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
802 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
803 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
805 current_function_has_nonlocal_goto
= 1;
807 #if HAVE_nonlocal_goto
808 /* ??? We no longer need to pass the static chain value, afaik. */
809 if (HAVE_nonlocal_goto
)
810 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
814 r_label
= copy_to_reg (r_label
);
816 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
817 gen_rtx_MEM (BLKmode
,
818 gen_rtx_SCRATCH (VOIDmode
))));
820 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
821 gen_rtx_MEM (BLKmode
,
822 hard_frame_pointer_rtx
)));
824 /* Restore frame pointer for containing function.
825 This sets the actual hard register used for the frame pointer
826 to the location of the function's incoming static chain info.
827 The non-local goto handler will then adjust it to contain the
828 proper value and reload the argument pointer, if needed. */
829 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
830 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
832 /* USE of hard_frame_pointer_rtx added for consistency;
833 not clear if really needed. */
834 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
835 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
836 emit_indirect_jump (r_label
);
839 /* Search backwards to the jump insn and mark it as a
841 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
845 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
,
846 const0_rtx
, REG_NOTES (insn
));
849 else if (CALL_P (insn
))
856 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
857 (not all will be used on all machines) that was passed to __builtin_setjmp.
858 It updates the stack pointer in that block to correspond to the current
862 expand_builtin_update_setjmp_buf (rtx buf_addr
)
864 enum machine_mode sa_mode
= Pmode
;
868 #ifdef HAVE_save_stack_nonlocal
869 if (HAVE_save_stack_nonlocal
)
870 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
872 #ifdef STACK_SAVEAREA_MODE
873 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
877 = gen_rtx_MEM (sa_mode
,
880 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
884 emit_insn (gen_setjmp ());
887 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
890 /* Expand a call to __builtin_prefetch. For a target that does not support
891 data prefetch, evaluate the memory address argument in case it has side
895 expand_builtin_prefetch (tree arglist
)
897 tree arg0
, arg1
, arg2
;
900 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
903 arg0
= TREE_VALUE (arglist
);
904 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
905 zero (read) and argument 2 (locality) defaults to 3 (high degree of
907 if (TREE_CHAIN (arglist
))
909 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
910 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
911 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
913 arg2
= build_int_cst (NULL_TREE
, 3);
917 arg1
= integer_zero_node
;
918 arg2
= build_int_cst (NULL_TREE
, 3);
921 /* Argument 0 is an address. */
922 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
924 /* Argument 1 (read/write flag) must be a compile-time constant int. */
925 if (TREE_CODE (arg1
) != INTEGER_CST
)
927 error ("second arg to %<__builtin_prefetch%> must be a constant");
928 arg1
= integer_zero_node
;
930 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
931 /* Argument 1 must be either zero or one. */
932 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
934 warning ("invalid second arg to __builtin_prefetch; using zero");
938 /* Argument 2 (locality) must be a compile-time constant int. */
939 if (TREE_CODE (arg2
) != INTEGER_CST
)
941 error ("third arg to %<__builtin_prefetch%> must be a constant");
942 arg2
= integer_zero_node
;
944 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
945 /* Argument 2 must be 0, 1, 2, or 3. */
946 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
948 warning ("invalid third arg to __builtin_prefetch; using zero");
955 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
957 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
958 || (GET_MODE (op0
) != Pmode
))
960 op0
= convert_memory_address (Pmode
, op0
);
961 op0
= force_reg (Pmode
, op0
);
963 emit_insn (gen_prefetch (op0
, op1
, op2
));
967 /* Don't do anything with direct references to volatile memory, but
968 generate code to handle other side effects. */
969 if (!MEM_P (op0
) && side_effects_p (op0
))
973 /* Get a MEM rtx for expression EXP which is the address of an operand
974 to be used to be used in a string instruction (cmpstrsi, movmemsi, ..). */
977 get_memory_rtx (tree exp
)
979 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
982 addr
= convert_memory_address (Pmode
, addr
);
984 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
986 /* Get an expression we can use to find the attributes to assign to MEM.
987 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
988 we can. First remove any nops. */
989 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
990 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
991 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
992 exp
= TREE_OPERAND (exp
, 0);
994 if (TREE_CODE (exp
) == ADDR_EXPR
)
996 exp
= TREE_OPERAND (exp
, 0);
997 set_mem_attributes (mem
, exp
, 0);
999 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
1001 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
1002 /* memcpy, memset and other builtin stringops can alias with anything. */
1003 set_mem_alias_set (mem
, 0);
1009 /* Built-in functions to perform an untyped call and return. */
1011 /* For each register that may be used for calling a function, this
1012 gives a mode used to copy the register's value. VOIDmode indicates
1013 the register is not used for calling a function. If the machine
1014 has register windows, this gives only the outbound registers.
1015 INCOMING_REGNO gives the corresponding inbound register. */
1016 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
1018 /* For each register that may be used for returning values, this gives
1019 a mode used to copy the register's value. VOIDmode indicates the
1020 register is not used for returning values. If the machine has
1021 register windows, this gives only the outbound registers.
1022 INCOMING_REGNO gives the corresponding inbound register. */
1023 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
1025 /* For each register that may be used for calling a function, this
1026 gives the offset of that register into the block returned by
1027 __builtin_apply_args. 0 indicates that the register is not
1028 used for calling a function. */
1029 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
1031 /* Return the size required for the block returned by __builtin_apply_args,
1032 and initialize apply_args_mode. */
1035 apply_args_size (void)
1037 static int size
= -1;
1040 enum machine_mode mode
;
1042 /* The values computed by this function never change. */
1045 /* The first value is the incoming arg-pointer. */
1046 size
= GET_MODE_SIZE (Pmode
);
1048 /* The second value is the structure value address unless this is
1049 passed as an "invisible" first argument. */
1050 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1051 size
+= GET_MODE_SIZE (Pmode
);
1053 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1054 if (FUNCTION_ARG_REGNO_P (regno
))
1056 mode
= reg_raw_mode
[regno
];
1058 gcc_assert (mode
!= VOIDmode
);
1060 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1061 if (size
% align
!= 0)
1062 size
= CEIL (size
, align
) * align
;
1063 apply_args_reg_offset
[regno
] = size
;
1064 size
+= GET_MODE_SIZE (mode
);
1065 apply_args_mode
[regno
] = mode
;
1069 apply_args_mode
[regno
] = VOIDmode
;
1070 apply_args_reg_offset
[regno
] = 0;
1076 /* Return the size required for the block returned by __builtin_apply,
1077 and initialize apply_result_mode. */
1080 apply_result_size (void)
1082 static int size
= -1;
1084 enum machine_mode mode
;
1086 /* The values computed by this function never change. */
1091 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1092 if (FUNCTION_VALUE_REGNO_P (regno
))
1094 mode
= reg_raw_mode
[regno
];
1096 gcc_assert (mode
!= VOIDmode
);
1098 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1099 if (size
% align
!= 0)
1100 size
= CEIL (size
, align
) * align
;
1101 size
+= GET_MODE_SIZE (mode
);
1102 apply_result_mode
[regno
] = mode
;
1105 apply_result_mode
[regno
] = VOIDmode
;
1107 /* Allow targets that use untyped_call and untyped_return to override
1108 the size so that machine-specific information can be stored here. */
1109 #ifdef APPLY_RESULT_SIZE
1110 size
= APPLY_RESULT_SIZE
;
1116 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1117 /* Create a vector describing the result block RESULT. If SAVEP is true,
1118 the result block is used to save the values; otherwise it is used to
1119 restore the values. */
1122 result_vector (int savep
, rtx result
)
1124 int regno
, size
, align
, nelts
;
1125 enum machine_mode mode
;
1127 rtx
*savevec
= alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1130 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1131 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1133 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1134 if (size
% align
!= 0)
1135 size
= CEIL (size
, align
) * align
;
1136 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1137 mem
= adjust_address (result
, mode
, size
);
1138 savevec
[nelts
++] = (savep
1139 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1140 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1141 size
+= GET_MODE_SIZE (mode
);
1143 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1145 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1147 /* Save the state required to perform an untyped call with the same
1148 arguments as were passed to the current function. */
1151 expand_builtin_apply_args_1 (void)
1154 int size
, align
, regno
;
1155 enum machine_mode mode
;
1156 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1158 /* Create a block where the arg-pointer, structure value address,
1159 and argument registers can be saved. */
1160 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1162 /* Walk past the arg-pointer and structure value address. */
1163 size
= GET_MODE_SIZE (Pmode
);
1164 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1165 size
+= GET_MODE_SIZE (Pmode
);
1167 /* Save each register used in calling a function to the block. */
1168 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1169 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1171 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1172 if (size
% align
!= 0)
1173 size
= CEIL (size
, align
) * align
;
1175 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1177 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1178 size
+= GET_MODE_SIZE (mode
);
1181 /* Save the arg pointer to the block. */
1182 tem
= copy_to_reg (virtual_incoming_args_rtx
);
1183 #ifdef STACK_GROWS_DOWNWARD
1184 /* We need the pointer as the caller actually passed them to us, not
1185 as we might have pretended they were passed. Make sure it's a valid
1186 operand, as emit_move_insn isn't expected to handle a PLUS. */
1188 = force_operand (plus_constant (tem
, current_function_pretend_args_size
),
1191 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1193 size
= GET_MODE_SIZE (Pmode
);
1195 /* Save the structure value address unless this is passed as an
1196 "invisible" first argument. */
1197 if (struct_incoming_value
)
1199 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1200 copy_to_reg (struct_incoming_value
));
1201 size
+= GET_MODE_SIZE (Pmode
);
1204 /* Return the address of the block. */
1205 return copy_addr_to_reg (XEXP (registers
, 0));
1208 /* __builtin_apply_args returns block of memory allocated on
1209 the stack into which is stored the arg pointer, structure
1210 value address, static chain, and all the registers that might
1211 possibly be used in performing a function call. The code is
1212 moved to the start of the function so the incoming values are
1216 expand_builtin_apply_args (void)
1218 /* Don't do __builtin_apply_args more than once in a function.
1219 Save the result of the first call and reuse it. */
1220 if (apply_args_value
!= 0)
1221 return apply_args_value
;
1223 /* When this function is called, it means that registers must be
1224 saved on entry to this function. So we migrate the
1225 call to the first insn of this function. */
1230 temp
= expand_builtin_apply_args_1 ();
1234 apply_args_value
= temp
;
1236 /* Put the insns after the NOTE that starts the function.
1237 If this is inside a start_sequence, make the outer-level insn
1238 chain current, so the code is placed at the start of the
1240 push_topmost_sequence ();
1241 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1242 pop_topmost_sequence ();
1247 /* Perform an untyped call and save the state required to perform an
1248 untyped return of whatever value was returned by the given function. */
1251 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1253 int size
, align
, regno
;
1254 enum machine_mode mode
;
1255 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1256 rtx old_stack_level
= 0;
1257 rtx call_fusage
= 0;
1258 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1260 arguments
= convert_memory_address (Pmode
, arguments
);
1262 /* Create a block where the return registers can be saved. */
1263 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1265 /* Fetch the arg pointer from the ARGUMENTS block. */
1266 incoming_args
= gen_reg_rtx (Pmode
);
1267 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1268 #ifndef STACK_GROWS_DOWNWARD
1269 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1270 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1273 /* Push a new argument block and copy the arguments. Do not allow
1274 the (potential) memcpy call below to interfere with our stack
1276 do_pending_stack_adjust ();
1279 /* Save the stack with nonlocal if available. */
1280 #ifdef HAVE_save_stack_nonlocal
1281 if (HAVE_save_stack_nonlocal
)
1282 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1285 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1287 /* Allocate a block of memory onto the stack and copy the memory
1288 arguments to the outgoing arguments address. */
1289 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1290 dest
= virtual_outgoing_args_rtx
;
1291 #ifndef STACK_GROWS_DOWNWARD
1292 if (GET_CODE (argsize
) == CONST_INT
)
1293 dest
= plus_constant (dest
, -INTVAL (argsize
));
1295 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1297 dest
= gen_rtx_MEM (BLKmode
, dest
);
1298 set_mem_align (dest
, PARM_BOUNDARY
);
1299 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1300 set_mem_align (src
, PARM_BOUNDARY
);
1301 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1303 /* Refer to the argument block. */
1305 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1306 set_mem_align (arguments
, PARM_BOUNDARY
);
1308 /* Walk past the arg-pointer and structure value address. */
1309 size
= GET_MODE_SIZE (Pmode
);
1311 size
+= GET_MODE_SIZE (Pmode
);
1313 /* Restore each of the registers previously saved. Make USE insns
1314 for each of these registers for use in making the call. */
1315 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1316 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1318 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1319 if (size
% align
!= 0)
1320 size
= CEIL (size
, align
) * align
;
1321 reg
= gen_rtx_REG (mode
, regno
);
1322 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1323 use_reg (&call_fusage
, reg
);
1324 size
+= GET_MODE_SIZE (mode
);
1327 /* Restore the structure value address unless this is passed as an
1328 "invisible" first argument. */
1329 size
= GET_MODE_SIZE (Pmode
);
1332 rtx value
= gen_reg_rtx (Pmode
);
1333 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1334 emit_move_insn (struct_value
, value
);
1335 if (REG_P (struct_value
))
1336 use_reg (&call_fusage
, struct_value
);
1337 size
+= GET_MODE_SIZE (Pmode
);
1340 /* All arguments and registers used for the call are set up by now! */
1341 function
= prepare_call_address (function
, NULL
, &call_fusage
, 0, 0);
1343 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1344 and we don't want to load it into a register as an optimization,
1345 because prepare_call_address already did it if it should be done. */
1346 if (GET_CODE (function
) != SYMBOL_REF
)
1347 function
= memory_address (FUNCTION_MODE
, function
);
1349 /* Generate the actual call instruction and save the return value. */
1350 #ifdef HAVE_untyped_call
1351 if (HAVE_untyped_call
)
1352 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1353 result
, result_vector (1, result
)));
1356 #ifdef HAVE_call_value
1357 if (HAVE_call_value
)
1361 /* Locate the unique return register. It is not possible to
1362 express a call that sets more than one return register using
1363 call_value; use untyped_call for that. In fact, untyped_call
1364 only needs to save the return registers in the given block. */
1365 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1366 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1368 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1370 valreg
= gen_rtx_REG (mode
, regno
);
1373 emit_call_insn (GEN_CALL_VALUE (valreg
,
1374 gen_rtx_MEM (FUNCTION_MODE
, function
),
1375 const0_rtx
, NULL_RTX
, const0_rtx
));
1377 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1383 /* Find the CALL insn we just emitted, and attach the register usage
1385 call_insn
= last_call_insn ();
1386 add_function_usage_to (call_insn
, call_fusage
);
1388 /* Restore the stack. */
1389 #ifdef HAVE_save_stack_nonlocal
1390 if (HAVE_save_stack_nonlocal
)
1391 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1394 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1398 /* Return the address of the result block. */
1399 result
= copy_addr_to_reg (XEXP (result
, 0));
1400 return convert_memory_address (ptr_mode
, result
);
1403 /* Perform an untyped return. */
1406 expand_builtin_return (rtx result
)
1408 int size
, align
, regno
;
1409 enum machine_mode mode
;
1411 rtx call_fusage
= 0;
1413 result
= convert_memory_address (Pmode
, result
);
1415 apply_result_size ();
1416 result
= gen_rtx_MEM (BLKmode
, result
);
1418 #ifdef HAVE_untyped_return
1419 if (HAVE_untyped_return
)
1421 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1427 /* Restore the return value and note that each value is used. */
1429 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1430 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1432 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1433 if (size
% align
!= 0)
1434 size
= CEIL (size
, align
) * align
;
1435 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1436 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1438 push_to_sequence (call_fusage
);
1439 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1440 call_fusage
= get_insns ();
1442 size
+= GET_MODE_SIZE (mode
);
1445 /* Put the USE insns before the return. */
1446 emit_insn (call_fusage
);
1448 /* Return whatever values was restored by jumping directly to the end
1450 expand_naked_return ();
1453 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1455 static enum type_class
1456 type_to_class (tree type
)
1458 switch (TREE_CODE (type
))
1460 case VOID_TYPE
: return void_type_class
;
1461 case INTEGER_TYPE
: return integer_type_class
;
1462 case CHAR_TYPE
: return char_type_class
;
1463 case ENUMERAL_TYPE
: return enumeral_type_class
;
1464 case BOOLEAN_TYPE
: return boolean_type_class
;
1465 case POINTER_TYPE
: return pointer_type_class
;
1466 case REFERENCE_TYPE
: return reference_type_class
;
1467 case OFFSET_TYPE
: return offset_type_class
;
1468 case REAL_TYPE
: return real_type_class
;
1469 case COMPLEX_TYPE
: return complex_type_class
;
1470 case FUNCTION_TYPE
: return function_type_class
;
1471 case METHOD_TYPE
: return method_type_class
;
1472 case RECORD_TYPE
: return record_type_class
;
1474 case QUAL_UNION_TYPE
: return union_type_class
;
1475 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1476 ? string_type_class
: array_type_class
);
1477 case SET_TYPE
: return set_type_class
;
1478 case FILE_TYPE
: return file_type_class
;
1479 case LANG_TYPE
: return lang_type_class
;
1480 default: return no_type_class
;
1484 /* Expand a call to __builtin_classify_type with arguments found in
1488 expand_builtin_classify_type (tree arglist
)
1491 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1492 return GEN_INT (no_type_class
);
1495 /* This helper macro, meant to be used in mathfn_built_in below,
1496 determines which among a set of three builtin math functions is
1497 appropriate for a given type mode. The `F' and `L' cases are
1498 automatically generated from the `double' case. */
1499 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1500 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1501 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1502 fcodel = BUILT_IN_MATHFN##L ; break;
1504 /* Return mathematic function equivalent to FN but operating directly
1505 on TYPE, if available. If we can't do the conversion, return zero. */
1507 mathfn_built_in (tree type
, enum built_in_function fn
)
1509 enum built_in_function fcode
, fcodef
, fcodel
;
1513 CASE_MATHFN (BUILT_IN_ACOS
)
1514 CASE_MATHFN (BUILT_IN_ACOSH
)
1515 CASE_MATHFN (BUILT_IN_ASIN
)
1516 CASE_MATHFN (BUILT_IN_ASINH
)
1517 CASE_MATHFN (BUILT_IN_ATAN
)
1518 CASE_MATHFN (BUILT_IN_ATAN2
)
1519 CASE_MATHFN (BUILT_IN_ATANH
)
1520 CASE_MATHFN (BUILT_IN_CBRT
)
1521 CASE_MATHFN (BUILT_IN_CEIL
)
1522 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1523 CASE_MATHFN (BUILT_IN_COS
)
1524 CASE_MATHFN (BUILT_IN_COSH
)
1525 CASE_MATHFN (BUILT_IN_DREM
)
1526 CASE_MATHFN (BUILT_IN_ERF
)
1527 CASE_MATHFN (BUILT_IN_ERFC
)
1528 CASE_MATHFN (BUILT_IN_EXP
)
1529 CASE_MATHFN (BUILT_IN_EXP10
)
1530 CASE_MATHFN (BUILT_IN_EXP2
)
1531 CASE_MATHFN (BUILT_IN_EXPM1
)
1532 CASE_MATHFN (BUILT_IN_FABS
)
1533 CASE_MATHFN (BUILT_IN_FDIM
)
1534 CASE_MATHFN (BUILT_IN_FLOOR
)
1535 CASE_MATHFN (BUILT_IN_FMA
)
1536 CASE_MATHFN (BUILT_IN_FMAX
)
1537 CASE_MATHFN (BUILT_IN_FMIN
)
1538 CASE_MATHFN (BUILT_IN_FMOD
)
1539 CASE_MATHFN (BUILT_IN_FREXP
)
1540 CASE_MATHFN (BUILT_IN_GAMMA
)
1541 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1542 CASE_MATHFN (BUILT_IN_HYPOT
)
1543 CASE_MATHFN (BUILT_IN_ILOGB
)
1544 CASE_MATHFN (BUILT_IN_INF
)
1545 CASE_MATHFN (BUILT_IN_J0
)
1546 CASE_MATHFN (BUILT_IN_J1
)
1547 CASE_MATHFN (BUILT_IN_JN
)
1548 CASE_MATHFN (BUILT_IN_LDEXP
)
1549 CASE_MATHFN (BUILT_IN_LGAMMA
)
1550 CASE_MATHFN (BUILT_IN_LLRINT
)
1551 CASE_MATHFN (BUILT_IN_LLROUND
)
1552 CASE_MATHFN (BUILT_IN_LOG
)
1553 CASE_MATHFN (BUILT_IN_LOG10
)
1554 CASE_MATHFN (BUILT_IN_LOG1P
)
1555 CASE_MATHFN (BUILT_IN_LOG2
)
1556 CASE_MATHFN (BUILT_IN_LOGB
)
1557 CASE_MATHFN (BUILT_IN_LRINT
)
1558 CASE_MATHFN (BUILT_IN_LROUND
)
1559 CASE_MATHFN (BUILT_IN_MODF
)
1560 CASE_MATHFN (BUILT_IN_NAN
)
1561 CASE_MATHFN (BUILT_IN_NANS
)
1562 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1563 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1564 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1565 CASE_MATHFN (BUILT_IN_POW
)
1566 CASE_MATHFN (BUILT_IN_POW10
)
1567 CASE_MATHFN (BUILT_IN_REMAINDER
)
1568 CASE_MATHFN (BUILT_IN_REMQUO
)
1569 CASE_MATHFN (BUILT_IN_RINT
)
1570 CASE_MATHFN (BUILT_IN_ROUND
)
1571 CASE_MATHFN (BUILT_IN_SCALB
)
1572 CASE_MATHFN (BUILT_IN_SCALBLN
)
1573 CASE_MATHFN (BUILT_IN_SCALBN
)
1574 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1575 CASE_MATHFN (BUILT_IN_SIN
)
1576 CASE_MATHFN (BUILT_IN_SINCOS
)
1577 CASE_MATHFN (BUILT_IN_SINH
)
1578 CASE_MATHFN (BUILT_IN_SQRT
)
1579 CASE_MATHFN (BUILT_IN_TAN
)
1580 CASE_MATHFN (BUILT_IN_TANH
)
1581 CASE_MATHFN (BUILT_IN_TGAMMA
)
1582 CASE_MATHFN (BUILT_IN_TRUNC
)
1583 CASE_MATHFN (BUILT_IN_Y0
)
1584 CASE_MATHFN (BUILT_IN_Y1
)
1585 CASE_MATHFN (BUILT_IN_YN
)
1591 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1592 return implicit_built_in_decls
[fcode
];
1593 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1594 return implicit_built_in_decls
[fcodef
];
1595 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1596 return implicit_built_in_decls
[fcodel
];
1601 /* If errno must be maintained, expand the RTL to check if the result,
1602 TARGET, of a built-in function call, EXP, is NaN, and if so set
1606 expand_errno_check (tree exp
, rtx target
)
1608 rtx lab
= gen_label_rtx ();
1610 /* Test the result; if it is NaN, set errno=EDOM because
1611 the argument was not in the domain. */
1612 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1616 /* If this built-in doesn't throw an exception, set errno directly. */
1617 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
1619 #ifdef GEN_ERRNO_RTX
1620 rtx errno_rtx
= GEN_ERRNO_RTX
;
1623 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1625 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1631 /* We can't set errno=EDOM directly; let the library call do it.
1632 Pop the arguments right away in case the call gets deleted. */
1634 expand_call (exp
, target
, 0);
1640 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1641 Return 0 if a normal call should be emitted rather than expanding the
1642 function in-line. EXP is the expression that is a call to the builtin
1643 function; if convenient, the result should be placed in TARGET.
1644 SUBTARGET may be used as the target for computing one of EXP's operands. */
1647 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1649 optab builtin_optab
;
1650 rtx op0
, insns
, before_call
;
1651 tree fndecl
= get_callee_fndecl (exp
);
1652 tree arglist
= TREE_OPERAND (exp
, 1);
1653 enum machine_mode mode
;
1654 bool errno_set
= false;
1657 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1660 arg
= TREE_VALUE (arglist
);
1662 switch (DECL_FUNCTION_CODE (fndecl
))
1665 case BUILT_IN_SQRTF
:
1666 case BUILT_IN_SQRTL
:
1667 errno_set
= ! tree_expr_nonnegative_p (arg
);
1668 builtin_optab
= sqrt_optab
;
1673 errno_set
= true; builtin_optab
= exp_optab
; break;
1674 case BUILT_IN_EXP10
:
1675 case BUILT_IN_EXP10F
:
1676 case BUILT_IN_EXP10L
:
1677 case BUILT_IN_POW10
:
1678 case BUILT_IN_POW10F
:
1679 case BUILT_IN_POW10L
:
1680 errno_set
= true; builtin_optab
= exp10_optab
; break;
1682 case BUILT_IN_EXP2F
:
1683 case BUILT_IN_EXP2L
:
1684 errno_set
= true; builtin_optab
= exp2_optab
; break;
1685 case BUILT_IN_EXPM1
:
1686 case BUILT_IN_EXPM1F
:
1687 case BUILT_IN_EXPM1L
:
1688 errno_set
= true; builtin_optab
= expm1_optab
; break;
1690 case BUILT_IN_LOGBF
:
1691 case BUILT_IN_LOGBL
:
1692 errno_set
= true; builtin_optab
= logb_optab
; break;
1693 case BUILT_IN_ILOGB
:
1694 case BUILT_IN_ILOGBF
:
1695 case BUILT_IN_ILOGBL
:
1696 errno_set
= true; builtin_optab
= ilogb_optab
; break;
1700 errno_set
= true; builtin_optab
= log_optab
; break;
1701 case BUILT_IN_LOG10
:
1702 case BUILT_IN_LOG10F
:
1703 case BUILT_IN_LOG10L
:
1704 errno_set
= true; builtin_optab
= log10_optab
; break;
1706 case BUILT_IN_LOG2F
:
1707 case BUILT_IN_LOG2L
:
1708 errno_set
= true; builtin_optab
= log2_optab
; break;
1709 case BUILT_IN_LOG1P
:
1710 case BUILT_IN_LOG1PF
:
1711 case BUILT_IN_LOG1PL
:
1712 errno_set
= true; builtin_optab
= log1p_optab
; break;
1714 case BUILT_IN_ASINF
:
1715 case BUILT_IN_ASINL
:
1716 builtin_optab
= asin_optab
; break;
1718 case BUILT_IN_ACOSF
:
1719 case BUILT_IN_ACOSL
:
1720 builtin_optab
= acos_optab
; break;
1724 builtin_optab
= tan_optab
; break;
1726 case BUILT_IN_ATANF
:
1727 case BUILT_IN_ATANL
:
1728 builtin_optab
= atan_optab
; break;
1729 case BUILT_IN_FLOOR
:
1730 case BUILT_IN_FLOORF
:
1731 case BUILT_IN_FLOORL
:
1732 builtin_optab
= floor_optab
; break;
1734 case BUILT_IN_CEILF
:
1735 case BUILT_IN_CEILL
:
1736 builtin_optab
= ceil_optab
; break;
1737 case BUILT_IN_TRUNC
:
1738 case BUILT_IN_TRUNCF
:
1739 case BUILT_IN_TRUNCL
:
1740 builtin_optab
= btrunc_optab
; break;
1741 case BUILT_IN_ROUND
:
1742 case BUILT_IN_ROUNDF
:
1743 case BUILT_IN_ROUNDL
:
1744 builtin_optab
= round_optab
; break;
1745 case BUILT_IN_NEARBYINT
:
1746 case BUILT_IN_NEARBYINTF
:
1747 case BUILT_IN_NEARBYINTL
:
1748 builtin_optab
= nearbyint_optab
; break;
1750 case BUILT_IN_RINTF
:
1751 case BUILT_IN_RINTL
:
1752 builtin_optab
= rint_optab
; break;
1757 /* Make a suitable register to place result in. */
1758 mode
= TYPE_MODE (TREE_TYPE (exp
));
1760 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1763 /* Before working hard, check whether the instruction is available. */
1764 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1766 target
= gen_reg_rtx (mode
);
1768 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1769 need to expand the argument again. This way, we will not perform
1770 side-effects more the once. */
1771 narg
= builtin_save_expr (arg
);
1774 arglist
= build_tree_list (NULL_TREE
, arg
);
1775 exp
= build_function_call_expr (fndecl
, arglist
);
1778 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
1782 /* Compute into TARGET.
1783 Set TARGET to wherever the result comes back. */
1784 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
1789 expand_errno_check (exp
, target
);
1791 /* Output the entire sequence. */
1792 insns
= get_insns ();
1798 /* If we were unable to expand via the builtin, stop the sequence
1799 (without outputting the insns) and call to the library function
1800 with the stabilized argument list. */
1804 before_call
= get_last_insn ();
1806 target
= expand_call (exp
, target
, target
== const0_rtx
);
1808 /* If this is a sqrt operation and we don't care about errno, try to
1809 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1810 This allows the semantics of the libcall to be visible to the RTL
1812 if (builtin_optab
== sqrt_optab
&& !errno_set
)
1814 /* Search backwards through the insns emitted by expand_call looking
1815 for the instruction with the REG_RETVAL note. */
1816 rtx last
= get_last_insn ();
1817 while (last
!= before_call
)
1819 if (find_reg_note (last
, REG_RETVAL
, NULL
))
1821 rtx note
= find_reg_note (last
, REG_EQUAL
, NULL
);
1822 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1823 two elements, i.e. symbol_ref(sqrt) and the operand. */
1825 && GET_CODE (note
) == EXPR_LIST
1826 && GET_CODE (XEXP (note
, 0)) == EXPR_LIST
1827 && XEXP (XEXP (note
, 0), 1) != NULL_RTX
1828 && XEXP (XEXP (XEXP (note
, 0), 1), 1) == NULL_RTX
)
1830 rtx operand
= XEXP (XEXP (XEXP (note
, 0), 1), 0);
1831 /* Check operand is a register with expected mode. */
1834 && GET_MODE (operand
) == mode
)
1836 /* Replace the REG_EQUAL note with a SQRT rtx. */
1837 rtx equiv
= gen_rtx_SQRT (mode
, operand
);
1838 set_unique_reg_note (last
, REG_EQUAL
, equiv
);
1843 last
= PREV_INSN (last
);
1850 /* Expand a call to the builtin binary math functions (pow and atan2).
1851 Return 0 if a normal call should be emitted rather than expanding the
1852 function in-line. EXP is the expression that is a call to the builtin
1853 function; if convenient, the result should be placed in TARGET.
1854 SUBTARGET may be used as the target for computing one of EXP's
1858 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
1860 optab builtin_optab
;
1861 rtx op0
, op1
, insns
;
1862 tree fndecl
= get_callee_fndecl (exp
);
1863 tree arglist
= TREE_OPERAND (exp
, 1);
1864 tree arg0
, arg1
, temp
, narg
;
1865 enum machine_mode mode
;
1866 bool errno_set
= true;
1869 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
1872 arg0
= TREE_VALUE (arglist
);
1873 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
1875 switch (DECL_FUNCTION_CODE (fndecl
))
1880 builtin_optab
= pow_optab
; break;
1881 case BUILT_IN_ATAN2
:
1882 case BUILT_IN_ATAN2F
:
1883 case BUILT_IN_ATAN2L
:
1884 builtin_optab
= atan2_optab
; break;
1886 case BUILT_IN_FMODF
:
1887 case BUILT_IN_FMODL
:
1888 builtin_optab
= fmod_optab
; break;
1890 case BUILT_IN_DREMF
:
1891 case BUILT_IN_DREML
:
1892 builtin_optab
= drem_optab
; break;
1897 /* Make a suitable register to place result in. */
1898 mode
= TYPE_MODE (TREE_TYPE (exp
));
1900 /* Before working hard, check whether the instruction is available. */
1901 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
1904 target
= gen_reg_rtx (mode
);
1906 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1909 /* Always stabilize the argument list. */
1910 narg
= builtin_save_expr (arg1
);
1913 temp
= build_tree_list (NULL_TREE
, narg
);
1917 temp
= TREE_CHAIN (arglist
);
1919 narg
= builtin_save_expr (arg0
);
1922 arglist
= tree_cons (NULL_TREE
, narg
, temp
);
1926 arglist
= tree_cons (NULL_TREE
, arg0
, temp
);
1929 exp
= build_function_call_expr (fndecl
, arglist
);
1931 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
1932 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
1936 /* Compute into TARGET.
1937 Set TARGET to wherever the result comes back. */
1938 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
1939 target
, 0, OPTAB_DIRECT
);
1941 /* If we were unable to expand via the builtin, stop the sequence
1942 (without outputting the insns) and call to the library function
1943 with the stabilized argument list. */
1947 return expand_call (exp
, target
, target
== const0_rtx
);
1951 expand_errno_check (exp
, target
);
1953 /* Output the entire sequence. */
1954 insns
= get_insns ();
1961 /* Expand a call to the builtin sin and cos math functions.
1962 Return 0 if a normal call should be emitted rather than expanding the
1963 function in-line. EXP is the expression that is a call to the builtin
1964 function; if convenient, the result should be placed in TARGET.
1965 SUBTARGET may be used as the target for computing one of EXP's
1969 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
1971 optab builtin_optab
;
1972 rtx op0
, insns
, before_call
;
1973 tree fndecl
= get_callee_fndecl (exp
);
1974 tree arglist
= TREE_OPERAND (exp
, 1);
1975 enum machine_mode mode
;
1976 bool errno_set
= false;
1979 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1982 arg
= TREE_VALUE (arglist
);
1984 switch (DECL_FUNCTION_CODE (fndecl
))
1992 builtin_optab
= sincos_optab
; break;
1997 /* Make a suitable register to place result in. */
1998 mode
= TYPE_MODE (TREE_TYPE (exp
));
2000 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2003 /* Check if sincos insn is available, otherwise fallback
2004 to sin or cos insn. */
2005 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
) {
2006 switch (DECL_FUNCTION_CODE (fndecl
))
2011 builtin_optab
= sin_optab
; break;
2015 builtin_optab
= cos_optab
; break;
2021 /* Before working hard, check whether the instruction is available. */
2022 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2024 target
= gen_reg_rtx (mode
);
2026 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2027 need to expand the argument again. This way, we will not perform
2028 side-effects more the once. */
2029 narg
= save_expr (arg
);
2032 arglist
= build_tree_list (NULL_TREE
, arg
);
2033 exp
= build_function_call_expr (fndecl
, arglist
);
2036 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2040 /* Compute into TARGET.
2041 Set TARGET to wherever the result comes back. */
2042 if (builtin_optab
== sincos_optab
)
2046 switch (DECL_FUNCTION_CODE (fndecl
))
2051 result
= expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0);
2056 result
= expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0);
2061 gcc_assert (result
);
2065 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2071 expand_errno_check (exp
, target
);
2073 /* Output the entire sequence. */
2074 insns
= get_insns ();
2080 /* If we were unable to expand via the builtin, stop the sequence
2081 (without outputting the insns) and call to the library function
2082 with the stabilized argument list. */
2086 before_call
= get_last_insn ();
2088 target
= expand_call (exp
, target
, target
== const0_rtx
);
2093 /* To evaluate powi(x,n), the floating point value x raised to the
2094 constant integer exponent n, we use a hybrid algorithm that
2095 combines the "window method" with look-up tables. For an
2096 introduction to exponentiation algorithms and "addition chains",
2097 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2098 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2099 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2100 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2102 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2103 multiplications to inline before calling the system library's pow
2104 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2105 so this default never requires calling pow, powf or powl. */
2107 #ifndef POWI_MAX_MULTS
2108 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2111 /* The size of the "optimal power tree" lookup table. All
2112 exponents less than this value are simply looked up in the
2113 powi_table below. This threshold is also used to size the
2114 cache of pseudo registers that hold intermediate results. */
2115 #define POWI_TABLE_SIZE 256
2117 /* The size, in bits of the window, used in the "window method"
2118 exponentiation algorithm. This is equivalent to a radix of
2119 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2120 #define POWI_WINDOW_SIZE 3
2122 /* The following table is an efficient representation of an
2123 "optimal power tree". For each value, i, the corresponding
2124 value, j, in the table states than an optimal evaluation
2125 sequence for calculating pow(x,i) can be found by evaluating
2126 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2127 100 integers is given in Knuth's "Seminumerical algorithms". */
2129 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2131 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2132 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2133 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2134 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2135 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2136 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2137 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2138 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2139 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2140 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2141 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2142 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2143 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2144 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2145 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2146 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2147 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2148 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2149 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2150 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2151 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2152 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2153 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2154 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2155 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2156 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2157 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2158 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2159 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2160 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2161 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2162 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2166 /* Return the number of multiplications required to calculate
2167 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2168 subroutine of powi_cost. CACHE is an array indicating
2169 which exponents have already been calculated. */
2172 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2174 /* If we've already calculated this exponent, then this evaluation
2175 doesn't require any additional multiplications. */
2180 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2181 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2184 /* Return the number of multiplications required to calculate
2185 powi(x,n) for an arbitrary x, given the exponent N. This
2186 function needs to be kept in sync with expand_powi below. */
2189 powi_cost (HOST_WIDE_INT n
)
2191 bool cache
[POWI_TABLE_SIZE
];
2192 unsigned HOST_WIDE_INT digit
;
2193 unsigned HOST_WIDE_INT val
;
2199 /* Ignore the reciprocal when calculating the cost. */
2200 val
= (n
< 0) ? -n
: n
;
2202 /* Initialize the exponent cache. */
2203 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2208 while (val
>= POWI_TABLE_SIZE
)
2212 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2213 result
+= powi_lookup_cost (digit
, cache
)
2214 + POWI_WINDOW_SIZE
+ 1;
2215 val
>>= POWI_WINDOW_SIZE
;
2224 return result
+ powi_lookup_cost (val
, cache
);
2227 /* Recursive subroutine of expand_powi. This function takes the array,
2228 CACHE, of already calculated exponents and an exponent N and returns
2229 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2232 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2234 unsigned HOST_WIDE_INT digit
;
2238 if (n
< POWI_TABLE_SIZE
)
2243 target
= gen_reg_rtx (mode
);
2246 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2247 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2251 target
= gen_reg_rtx (mode
);
2252 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2253 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2254 op1
= expand_powi_1 (mode
, digit
, cache
);
2258 target
= gen_reg_rtx (mode
);
2259 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2263 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2264 if (result
!= target
)
2265 emit_move_insn (target
, result
);
2269 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2270 floating point operand in mode MODE, and N is the exponent. This
2271 function needs to be kept in sync with powi_cost above. */
2274 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2276 unsigned HOST_WIDE_INT val
;
2277 rtx cache
[POWI_TABLE_SIZE
];
2281 return CONST1_RTX (mode
);
2283 val
= (n
< 0) ? -n
: n
;
2285 memset (cache
, 0, sizeof (cache
));
2288 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2290 /* If the original exponent was negative, reciprocate the result. */
2292 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2293 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2298 /* Expand a call to the pow built-in mathematical function. Return 0 if
2299 a normal call should be emitted rather than expanding the function
2300 in-line. EXP is the expression that is a call to the builtin
2301 function; if convenient, the result should be placed in TARGET. */
2304 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
2306 tree arglist
= TREE_OPERAND (exp
, 1);
2309 if (! validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2312 arg0
= TREE_VALUE (arglist
);
2313 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2315 if (TREE_CODE (arg1
) == REAL_CST
2316 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2318 REAL_VALUE_TYPE cint
;
2322 c
= TREE_REAL_CST (arg1
);
2323 n
= real_to_integer (&c
);
2324 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
2325 if (real_identical (&c
, &cint
))
2327 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2328 Otherwise, check the number of multiplications required.
2329 Note that pow never sets errno for an integer exponent. */
2330 if ((n
>= -1 && n
<= 2)
2331 || (flag_unsafe_math_optimizations
2333 && powi_cost (n
) <= POWI_MAX_MULTS
))
2335 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2336 rtx op
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2337 op
= force_reg (mode
, op
);
2338 return expand_powi (op
, mode
, n
);
2343 if (! flag_unsafe_math_optimizations
)
2345 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
2348 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2349 if we failed the caller should emit a normal call, otherwise
2350 try to get the result in TARGET, if convenient. */
2353 expand_builtin_strlen (tree arglist
, rtx target
,
2354 enum machine_mode target_mode
)
2356 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
2361 tree len
, src
= TREE_VALUE (arglist
);
2362 rtx result
, src_reg
, char_rtx
, before_strlen
;
2363 enum machine_mode insn_mode
= target_mode
, char_mode
;
2364 enum insn_code icode
= CODE_FOR_nothing
;
2367 /* If the length can be computed at compile-time, return it. */
2368 len
= c_strlen (src
, 0);
2370 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2372 /* If the length can be computed at compile-time and is constant
2373 integer, but there are side-effects in src, evaluate
2374 src for side-effects, then return len.
2375 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2376 can be optimized into: i++; x = 3; */
2377 len
= c_strlen (src
, 1);
2378 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
2380 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2381 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2384 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2386 /* If SRC is not a pointer type, don't do this operation inline. */
2390 /* Bail out if we can't compute strlen in the right mode. */
2391 while (insn_mode
!= VOIDmode
)
2393 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
2394 if (icode
!= CODE_FOR_nothing
)
2397 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
2399 if (insn_mode
== VOIDmode
)
2402 /* Make a place to write the result of the instruction. */
2406 && GET_MODE (result
) == insn_mode
2407 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2408 result
= gen_reg_rtx (insn_mode
);
2410 /* Make a place to hold the source address. We will not expand
2411 the actual source until we are sure that the expansion will
2412 not fail -- there are trees that cannot be expanded twice. */
2413 src_reg
= gen_reg_rtx (Pmode
);
2415 /* Mark the beginning of the strlen sequence so we can emit the
2416 source operand later. */
2417 before_strlen
= get_last_insn ();
2419 char_rtx
= const0_rtx
;
2420 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
2421 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
2423 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
2425 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
2426 char_rtx
, GEN_INT (align
));
2431 /* Now that we are assured of success, expand the source. */
2433 pat
= memory_address (BLKmode
,
2434 expand_expr (src
, src_reg
, ptr_mode
, EXPAND_SUM
));
2436 emit_move_insn (src_reg
, pat
);
2441 emit_insn_after (pat
, before_strlen
);
2443 emit_insn_before (pat
, get_insns ());
2445 /* Return the value in the proper mode for this function. */
2446 if (GET_MODE (result
) == target_mode
)
2448 else if (target
!= 0)
2449 convert_move (target
, result
, 0);
2451 target
= convert_to_mode (target_mode
, result
, 0);
2457 /* Expand a call to the strstr builtin. Return 0 if we failed the
2458 caller should emit a normal call, otherwise try to get the result
2459 in TARGET, if convenient (and in mode MODE if that's convenient). */
2462 expand_builtin_strstr (tree arglist
, rtx target
, enum machine_mode mode
)
2464 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2468 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2470 const char *p1
, *p2
;
2479 const char *r
= strstr (p1
, p2
);
2484 /* Return an offset into the constant string argument. */
2485 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2486 fold_convert (TREE_TYPE (s1
),
2487 ssize_int (r
- p1
))));
2488 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2492 return expand_expr (s1
, target
, mode
, EXPAND_NORMAL
);
2497 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2501 /* New argument list transforming strstr(s1, s2) to
2502 strchr(s1, s2[0]). */
2503 arglist
= build_tree_list (NULL_TREE
,
2504 build_int_cst (NULL_TREE
, p2
[0]));
2505 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
2506 return expand_expr (build_function_call_expr (fn
, arglist
),
2507 target
, mode
, EXPAND_NORMAL
);
2511 /* Expand a call to the strchr builtin. Return 0 if we failed the
2512 caller should emit a normal call, otherwise try to get the result
2513 in TARGET, if convenient (and in mode MODE if that's convenient). */
2516 expand_builtin_strchr (tree arglist
, rtx target
, enum machine_mode mode
)
2518 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2522 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2525 if (TREE_CODE (s2
) != INTEGER_CST
)
2535 if (target_char_cast (s2
, &c
))
2543 /* Return an offset into the constant string argument. */
2544 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2545 fold_convert (TREE_TYPE (s1
),
2546 ssize_int (r
- p1
))));
2547 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2550 /* FIXME: Should use here strchrM optab so that ports can optimize
2556 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2557 caller should emit a normal call, otherwise try to get the result
2558 in TARGET, if convenient (and in mode MODE if that's convenient). */
2561 expand_builtin_strrchr (tree arglist
, rtx target
, enum machine_mode mode
)
2563 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2567 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2571 if (TREE_CODE (s2
) != INTEGER_CST
)
2580 if (target_char_cast (s2
, &c
))
2583 r
= strrchr (p1
, c
);
2588 /* Return an offset into the constant string argument. */
2589 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2590 fold_convert (TREE_TYPE (s1
),
2591 ssize_int (r
- p1
))));
2592 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2595 if (! integer_zerop (s2
))
2598 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2602 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
2603 return expand_expr (build_function_call_expr (fn
, arglist
),
2604 target
, mode
, EXPAND_NORMAL
);
2608 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2609 caller should emit a normal call, otherwise try to get the result
2610 in TARGET, if convenient (and in mode MODE if that's convenient). */
2613 expand_builtin_strpbrk (tree arglist
, rtx target
, enum machine_mode mode
)
2615 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2619 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2621 const char *p1
, *p2
;
2630 const char *r
= strpbrk (p1
, p2
);
2635 /* Return an offset into the constant string argument. */
2636 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2637 fold_convert (TREE_TYPE (s1
),
2638 ssize_int (r
- p1
))));
2639 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2644 /* strpbrk(x, "") == NULL.
2645 Evaluate and ignore the arguments in case they had
2647 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2652 return 0; /* Really call strpbrk. */
2654 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2658 /* New argument list transforming strpbrk(s1, s2) to
2659 strchr(s1, s2[0]). */
2660 arglist
= build_tree_list (NULL_TREE
,
2661 build_int_cst (NULL_TREE
, p2
[0]));
2662 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
2663 return expand_expr (build_function_call_expr (fn
, arglist
),
2664 target
, mode
, EXPAND_NORMAL
);
2668 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2669 bytes from constant string DATA + OFFSET and return it as target
2673 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
2674 enum machine_mode mode
)
2676 const char *str
= (const char *) data
;
2678 gcc_assert (offset
>= 0
2679 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
2680 <= strlen (str
) + 1));
2682 return c_readstr (str
+ offset
, mode
);
2685 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2686 Return 0 if we failed, the caller should emit a normal call,
2687 otherwise try to get the result in TARGET, if convenient (and in
2688 mode MODE if that's convenient). */
2690 expand_builtin_memcpy (tree arglist
, rtx target
, enum machine_mode mode
)
2692 if (!validate_arglist (arglist
,
2693 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2697 tree dest
= TREE_VALUE (arglist
);
2698 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2699 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2700 const char *src_str
;
2701 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2702 unsigned int dest_align
2703 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2704 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
2706 /* If DEST is not a pointer type, call the normal function. */
2707 if (dest_align
== 0)
2710 /* If the LEN parameter is zero, return DEST. */
2711 if (integer_zerop (len
))
2713 /* Evaluate and ignore SRC in case it has side-effects. */
2714 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2715 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2718 /* If SRC and DEST are the same (and not volatile), return DEST. */
2719 if (operand_equal_p (src
, dest
, 0))
2721 /* Evaluate and ignore LEN in case it has side-effects. */
2722 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2723 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2726 /* If either SRC is not a pointer type, don't do this
2727 operation in-line. */
2731 dest_mem
= get_memory_rtx (dest
);
2732 set_mem_align (dest_mem
, dest_align
);
2733 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2734 src_str
= c_getstr (src
);
2736 /* If SRC is a string constant and block move would be done
2737 by pieces, we can avoid loading the string from memory
2738 and only stored the computed constants. */
2740 && GET_CODE (len_rtx
) == CONST_INT
2741 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2742 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2743 (void *) src_str
, dest_align
))
2745 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2746 builtin_memcpy_read_str
,
2747 (void *) src_str
, dest_align
, 0);
2748 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2749 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2753 src_mem
= get_memory_rtx (src
);
2754 set_mem_align (src_mem
, src_align
);
2756 /* Copy word part most expediently. */
2757 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
,
2762 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2763 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
2769 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2770 Return 0 if we failed the caller should emit a normal call,
2771 otherwise try to get the result in TARGET, if convenient (and in
2772 mode MODE if that's convenient). If ENDP is 0 return the
2773 destination pointer, if ENDP is 1 return the end pointer ala
2774 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2778 expand_builtin_mempcpy (tree arglist
, rtx target
, enum machine_mode mode
,
2781 if (!validate_arglist (arglist
,
2782 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2784 /* If return value is ignored, transform mempcpy into memcpy. */
2785 else if (target
== const0_rtx
)
2787 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2792 return expand_expr (build_function_call_expr (fn
, arglist
),
2793 target
, mode
, EXPAND_NORMAL
);
2797 tree dest
= TREE_VALUE (arglist
);
2798 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2799 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2800 const char *src_str
;
2801 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2802 unsigned int dest_align
2803 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2804 rtx dest_mem
, src_mem
, len_rtx
;
2806 /* If DEST is not a pointer type, call the normal function. */
2807 if (dest_align
== 0)
2810 /* If SRC and DEST are the same (and not volatile), do nothing. */
2811 if (operand_equal_p (src
, dest
, 0))
2817 /* Evaluate and ignore LEN in case it has side-effects. */
2818 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2819 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2823 len
= fold (build2 (MINUS_EXPR
, TREE_TYPE (len
), len
,
2825 len
= fold_convert (TREE_TYPE (dest
), len
);
2826 expr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
));
2827 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
2830 /* If LEN is not constant, call the normal function. */
2831 if (! host_integerp (len
, 1))
2834 /* If the LEN parameter is zero, return DEST. */
2835 if (tree_low_cst (len
, 1) == 0)
2837 /* Evaluate and ignore SRC in case it has side-effects. */
2838 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2839 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2842 /* If either SRC is not a pointer type, don't do this
2843 operation in-line. */
2847 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2848 src_str
= c_getstr (src
);
2850 /* If SRC is a string constant and block move would be done
2851 by pieces, we can avoid loading the string from memory
2852 and only stored the computed constants. */
2854 && GET_CODE (len_rtx
) == CONST_INT
2855 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2856 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2857 (void *) src_str
, dest_align
))
2859 dest_mem
= get_memory_rtx (dest
);
2860 set_mem_align (dest_mem
, dest_align
);
2861 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2862 builtin_memcpy_read_str
,
2863 (void *) src_str
, dest_align
, endp
);
2864 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2865 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2869 if (GET_CODE (len_rtx
) == CONST_INT
2870 && can_move_by_pieces (INTVAL (len_rtx
),
2871 MIN (dest_align
, src_align
)))
2873 dest_mem
= get_memory_rtx (dest
);
2874 set_mem_align (dest_mem
, dest_align
);
2875 src_mem
= get_memory_rtx (src
);
2876 set_mem_align (src_mem
, src_align
);
2877 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
2878 MIN (dest_align
, src_align
), endp
);
2879 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2880 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2888 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2889 if we failed the caller should emit a normal call. */
2892 expand_builtin_memmove (tree arglist
, rtx target
, enum machine_mode mode
)
2894 if (!validate_arglist (arglist
,
2895 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2899 tree dest
= TREE_VALUE (arglist
);
2900 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2901 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2903 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2904 unsigned int dest_align
2905 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2907 /* If DEST is not a pointer type, call the normal function. */
2908 if (dest_align
== 0)
2911 /* If the LEN parameter is zero, return DEST. */
2912 if (integer_zerop (len
))
2914 /* Evaluate and ignore SRC in case it has side-effects. */
2915 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2916 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2919 /* If SRC and DEST are the same (and not volatile), return DEST. */
2920 if (operand_equal_p (src
, dest
, 0))
2922 /* Evaluate and ignore LEN in case it has side-effects. */
2923 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2924 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2927 /* If either SRC is not a pointer type, don't do this
2928 operation in-line. */
2932 /* If src is categorized for a readonly section we can use
2934 if (readonly_data_expr (src
))
2936 tree
const fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2939 return expand_expr (build_function_call_expr (fn
, arglist
),
2940 target
, mode
, EXPAND_NORMAL
);
2943 /* If length is 1 and we can expand memcpy call inline,
2944 it is ok to use memcpy as well. */
2945 if (integer_onep (len
))
2947 rtx ret
= expand_builtin_mempcpy (arglist
, target
, mode
,
2953 /* Otherwise, call the normal function. */
2958 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
2959 if we failed the caller should emit a normal call. */
2962 expand_builtin_bcopy (tree arglist
)
2964 tree src
, dest
, size
, newarglist
;
2966 if (!validate_arglist (arglist
,
2967 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2970 src
= TREE_VALUE (arglist
);
2971 dest
= TREE_VALUE (TREE_CHAIN (arglist
));
2972 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2974 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
2975 memmove(ptr y, ptr x, size_t z). This is done this way
2976 so that if it isn't expanded inline, we fallback to
2977 calling bcopy instead of memmove. */
2979 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
2980 newarglist
= tree_cons (NULL_TREE
, src
, newarglist
);
2981 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
2983 return expand_builtin_memmove (newarglist
, const0_rtx
, VOIDmode
);
2987 # define HAVE_movstr 0
2988 # define CODE_FOR_movstr CODE_FOR_nothing
2991 /* Expand into a movstr instruction, if one is available. Return 0 if
2992 we failed, the caller should emit a normal call, otherwise try to
2993 get the result in TARGET, if convenient. If ENDP is 0 return the
2994 destination pointer, if ENDP is 1 return the end pointer ala
2995 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2999 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3005 const struct insn_data
* data
;
3010 dest_mem
= get_memory_rtx (dest
);
3011 src_mem
= get_memory_rtx (src
);
3014 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3015 dest_mem
= replace_equiv_address (dest_mem
, target
);
3016 end
= gen_reg_rtx (Pmode
);
3020 if (target
== 0 || target
== const0_rtx
)
3022 end
= gen_reg_rtx (Pmode
);
3030 data
= insn_data
+ CODE_FOR_movstr
;
3032 if (data
->operand
[0].mode
!= VOIDmode
)
3033 end
= gen_lowpart (data
->operand
[0].mode
, end
);
3035 insn
= data
->genfun (end
, dest_mem
, src_mem
);
3041 /* movstr is supposed to set end to the address of the NUL
3042 terminator. If the caller requested a mempcpy-like return value,
3044 if (endp
== 1 && target
!= const0_rtx
)
3045 emit_move_insn (target
, plus_constant (gen_lowpart (GET_MODE (target
),
3051 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
3052 if we failed the caller should emit a normal call, otherwise try to get
3053 the result in TARGET, if convenient (and in mode MODE if that's
3057 expand_builtin_strcpy (tree arglist
, rtx target
, enum machine_mode mode
)
3059 tree fn
, len
, src
, dst
;
3061 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3064 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3065 dst
= TREE_VALUE (arglist
);
3067 /* If SRC and DST are equal (and not volatile), return DST. */
3068 if (operand_equal_p (src
, dst
, 0))
3069 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3071 len
= c_strlen (src
, 1);
3072 if (len
== 0 || TREE_SIDE_EFFECTS (len
))
3073 return expand_movstr (TREE_VALUE (arglist
),
3074 TREE_VALUE (TREE_CHAIN (arglist
)),
3075 target
, /*endp=*/0);
3077 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3081 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3082 arglist
= build_tree_list (NULL_TREE
, len
);
3083 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
3084 arglist
= tree_cons (NULL_TREE
, dst
, arglist
);
3085 return expand_expr (build_function_call_expr (fn
, arglist
),
3086 target
, mode
, EXPAND_NORMAL
);
3089 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3090 Return 0 if we failed the caller should emit a normal call,
3091 otherwise try to get the result in TARGET, if convenient (and in
3092 mode MODE if that's convenient). */
3095 expand_builtin_stpcpy (tree arglist
, rtx target
, enum machine_mode mode
)
3097 /* If return value is ignored, transform stpcpy into strcpy. */
3098 if (target
== const0_rtx
)
3100 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
3104 return expand_expr (build_function_call_expr (fn
, arglist
),
3105 target
, mode
, EXPAND_NORMAL
);
3108 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3112 tree dst
, src
, len
, lenp1
;
3116 /* Ensure we get an actual string whose length can be evaluated at
3117 compile-time, not an expression containing a string. This is
3118 because the latter will potentially produce pessimized code
3119 when used to produce the return value. */
3120 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3121 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3122 return expand_movstr (TREE_VALUE (arglist
),
3123 TREE_VALUE (TREE_CHAIN (arglist
)),
3124 target
, /*endp=*/2);
3126 dst
= TREE_VALUE (arglist
);
3127 lenp1
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3128 narglist
= build_tree_list (NULL_TREE
, lenp1
);
3129 narglist
= tree_cons (NULL_TREE
, src
, narglist
);
3130 narglist
= tree_cons (NULL_TREE
, dst
, narglist
);
3131 ret
= expand_builtin_mempcpy (narglist
, target
, mode
, /*endp=*/2);
3136 if (TREE_CODE (len
) == INTEGER_CST
)
3138 rtx len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3140 if (GET_CODE (len_rtx
) == CONST_INT
)
3142 ret
= expand_builtin_strcpy (arglist
, target
, mode
);
3148 if (mode
!= VOIDmode
)
3149 target
= gen_reg_rtx (mode
);
3151 target
= gen_reg_rtx (GET_MODE (ret
));
3153 if (GET_MODE (target
) != GET_MODE (ret
))
3154 ret
= gen_lowpart (GET_MODE (target
), ret
);
3156 ret
= emit_move_insn (target
,
3166 return expand_movstr (TREE_VALUE (arglist
),
3167 TREE_VALUE (TREE_CHAIN (arglist
)),
3168 target
, /*endp=*/2);
3172 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3173 bytes from constant string DATA + OFFSET and return it as target
3177 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3178 enum machine_mode mode
)
3180 const char *str
= (const char *) data
;
3182 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3185 return c_readstr (str
+ offset
, mode
);
3188 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3189 if we failed the caller should emit a normal call. */
3192 expand_builtin_strncpy (tree arglist
, rtx target
, enum machine_mode mode
)
3194 if (!validate_arglist (arglist
,
3195 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3199 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)), 1);
3200 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3203 /* We must be passed a constant len parameter. */
3204 if (TREE_CODE (len
) != INTEGER_CST
)
3207 /* If the len parameter is zero, return the dst parameter. */
3208 if (integer_zerop (len
))
3210 /* Evaluate and ignore the src argument in case it has
3212 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
3213 VOIDmode
, EXPAND_NORMAL
);
3214 /* Return the dst parameter. */
3215 return expand_expr (TREE_VALUE (arglist
), target
, mode
,
3219 /* Now, we must be passed a constant src ptr parameter. */
3220 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
3223 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
3225 /* We're required to pad with trailing zeros if the requested
3226 len is greater than strlen(s2)+1. In that case try to
3227 use store_by_pieces, if it fails, punt. */
3228 if (tree_int_cst_lt (slen
, len
))
3230 tree dest
= TREE_VALUE (arglist
);
3231 unsigned int dest_align
3232 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3233 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
3236 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3237 || !can_store_by_pieces (tree_low_cst (len
, 1),
3238 builtin_strncpy_read_str
,
3239 (void *) p
, dest_align
))
3242 dest_mem
= get_memory_rtx (dest
);
3243 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3244 builtin_strncpy_read_str
,
3245 (void *) p
, dest_align
, 0);
3246 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3247 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3251 /* OK transform into builtin memcpy. */
3252 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3255 return expand_expr (build_function_call_expr (fn
, arglist
),
3256 target
, mode
, EXPAND_NORMAL
);
3260 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3261 bytes from constant string DATA + OFFSET and return it as target
3265 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3266 enum machine_mode mode
)
3268 const char *c
= (const char *) data
;
3269 char *p
= alloca (GET_MODE_SIZE (mode
));
3271 memset (p
, *c
, GET_MODE_SIZE (mode
));
3273 return c_readstr (p
, mode
);
3276 /* Callback routine for store_by_pieces. Return the RTL of a register
3277 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3278 char value given in the RTL register data. For example, if mode is
3279 4 bytes wide, return the RTL for 0x01010101*data. */
3282 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3283 enum machine_mode mode
)
3289 size
= GET_MODE_SIZE (mode
);
3294 memset (p
, 1, size
);
3295 coeff
= c_readstr (p
, mode
);
3297 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3298 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3299 return force_reg (mode
, target
);
3302 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3303 if we failed the caller should emit a normal call, otherwise try to get
3304 the result in TARGET, if convenient (and in mode MODE if that's
3308 expand_builtin_memset (tree arglist
, rtx target
, enum machine_mode mode
)
3310 if (!validate_arglist (arglist
,
3311 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3315 tree dest
= TREE_VALUE (arglist
);
3316 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
3317 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3320 unsigned int dest_align
3321 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3322 rtx dest_mem
, dest_addr
, len_rtx
;
3324 /* If DEST is not a pointer type, don't do this
3325 operation in-line. */
3326 if (dest_align
== 0)
3329 /* If the LEN parameter is zero, return DEST. */
3330 if (integer_zerop (len
))
3332 /* Evaluate and ignore VAL in case it has side-effects. */
3333 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3334 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3337 if (TREE_CODE (val
) != INTEGER_CST
)
3341 if (!host_integerp (len
, 1))
3344 if (optimize_size
&& tree_low_cst (len
, 1) > 1)
3347 /* Assume that we can memset by pieces if we can store the
3348 * the coefficients by pieces (in the required modes).
3349 * We can't pass builtin_memset_gen_str as that emits RTL. */
3351 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3352 builtin_memset_read_str
,
3356 val
= fold (build1 (CONVERT_EXPR
, unsigned_char_type_node
, val
));
3357 val_rtx
= expand_expr (val
, NULL_RTX
, VOIDmode
, 0);
3358 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3360 dest_mem
= get_memory_rtx (dest
);
3361 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3362 builtin_memset_gen_str
,
3363 val_rtx
, dest_align
, 0);
3364 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3365 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3369 if (target_char_cast (val
, &c
))
3374 if (!host_integerp (len
, 1))
3376 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3377 builtin_memset_read_str
, &c
,
3381 dest_mem
= get_memory_rtx (dest
);
3382 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3383 builtin_memset_read_str
,
3385 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3386 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3390 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3392 dest_mem
= get_memory_rtx (dest
);
3393 set_mem_align (dest_mem
, dest_align
);
3394 dest_addr
= clear_storage (dest_mem
, len_rtx
);
3398 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3399 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3406 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3407 if we failed the caller should emit a normal call. */
3410 expand_builtin_bzero (tree arglist
)
3412 tree dest
, size
, newarglist
;
3414 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3417 dest
= TREE_VALUE (arglist
);
3418 size
= TREE_VALUE (TREE_CHAIN (arglist
));
3420 /* New argument list transforming bzero(ptr x, int y) to
3421 memset(ptr x, int 0, size_t y). This is done this way
3422 so that if it isn't expanded inline, we fallback to
3423 calling bzero instead of memset. */
3425 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3426 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
3427 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3429 return expand_builtin_memset (newarglist
, const0_rtx
, VOIDmode
);
3432 /* Expand expression EXP, which is a call to the memcmp built-in function.
3433 ARGLIST is the argument list for this call. Return 0 if we failed and the
3434 caller should emit a normal call, otherwise try to get the result in
3435 TARGET, if convenient (and in mode MODE, if that's convenient). */
3438 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED
, tree arglist
, rtx target
,
3439 enum machine_mode mode
)
3441 tree arg1
, arg2
, len
;
3442 const char *p1
, *p2
;
3444 if (!validate_arglist (arglist
,
3445 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3448 arg1
= TREE_VALUE (arglist
);
3449 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3450 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3452 /* If the len parameter is zero, return zero. */
3453 if (integer_zerop (len
))
3455 /* Evaluate and ignore arg1 and arg2 in case they have
3457 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3458 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3462 /* If both arguments are equal (and not volatile), return zero. */
3463 if (operand_equal_p (arg1
, arg2
, 0))
3465 /* Evaluate and ignore len in case it has side-effects. */
3466 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3470 p1
= c_getstr (arg1
);
3471 p2
= c_getstr (arg2
);
3473 /* If all arguments are constant, and the value of len is not greater
3474 than the lengths of arg1 and arg2, evaluate at compile-time. */
3475 if (host_integerp (len
, 1) && p1
&& p2
3476 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
3477 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
3479 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
3481 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
3484 /* If len parameter is one, return an expression corresponding to
3485 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3486 if (integer_onep (len
))
3488 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3489 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3491 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3492 build1 (INDIRECT_REF
, cst_uchar_node
,
3493 fold_convert (cst_uchar_ptr_node
, arg1
))));
3495 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3496 build1 (INDIRECT_REF
, cst_uchar_node
,
3497 fold_convert (cst_uchar_ptr_node
, arg2
))));
3498 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3499 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3502 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
3504 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3509 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3511 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3512 enum machine_mode insn_mode
;
3514 #ifdef HAVE_cmpmemsi
3516 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3519 #ifdef HAVE_cmpstrsi
3521 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3526 /* If we don't have POINTER_TYPE, call the function. */
3527 if (arg1_align
== 0 || arg2_align
== 0)
3530 /* Make a place to write the result of the instruction. */
3533 && REG_P (result
) && GET_MODE (result
) == insn_mode
3534 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3535 result
= gen_reg_rtx (insn_mode
);
3537 arg1_rtx
= get_memory_rtx (arg1
);
3538 arg2_rtx
= get_memory_rtx (arg2
);
3539 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3540 #ifdef HAVE_cmpmemsi
3542 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3543 GEN_INT (MIN (arg1_align
, arg2_align
)));
3546 #ifdef HAVE_cmpstrsi
3548 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3549 GEN_INT (MIN (arg1_align
, arg2_align
)));
3557 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
3558 TYPE_MODE (integer_type_node
), 3,
3559 XEXP (arg1_rtx
, 0), Pmode
,
3560 XEXP (arg2_rtx
, 0), Pmode
,
3561 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3562 TYPE_UNSIGNED (sizetype
)),
3563 TYPE_MODE (sizetype
));
3565 /* Return the value in the proper mode for this function. */
3566 mode
= TYPE_MODE (TREE_TYPE (exp
));
3567 if (GET_MODE (result
) == mode
)
3569 else if (target
!= 0)
3571 convert_move (target
, result
, 0);
3575 return convert_to_mode (mode
, result
, 0);
3582 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3583 if we failed the caller should emit a normal call, otherwise try to get
3584 the result in TARGET, if convenient. */
3587 expand_builtin_strcmp (tree exp
, rtx target
, enum machine_mode mode
)
3589 tree arglist
= TREE_OPERAND (exp
, 1);
3591 const char *p1
, *p2
;
3593 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3596 arg1
= TREE_VALUE (arglist
);
3597 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3599 /* If both arguments are equal (and not volatile), return zero. */
3600 if (operand_equal_p (arg1
, arg2
, 0))
3603 p1
= c_getstr (arg1
);
3604 p2
= c_getstr (arg2
);
3608 const int i
= strcmp (p1
, p2
);
3609 return (i
< 0 ? constm1_rtx
: (i
> 0 ? const1_rtx
: const0_rtx
));
3612 /* If either arg is "", return an expression corresponding to
3613 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3614 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
3616 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3617 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3619 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3620 build1 (INDIRECT_REF
, cst_uchar_node
,
3621 fold_convert (cst_uchar_ptr_node
, arg1
))));
3623 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3624 build1 (INDIRECT_REF
, cst_uchar_node
,
3625 fold_convert (cst_uchar_ptr_node
, arg2
))));
3626 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3627 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3630 #ifdef HAVE_cmpstrsi
3633 tree len
, len1
, len2
;
3634 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3639 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3641 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3642 enum machine_mode insn_mode
3643 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3645 len1
= c_strlen (arg1
, 1);
3646 len2
= c_strlen (arg2
, 1);
3649 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3651 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3653 /* If we don't have a constant length for the first, use the length
3654 of the second, if we know it. We don't require a constant for
3655 this case; some cost analysis could be done if both are available
3656 but neither is constant. For now, assume they're equally cheap,
3657 unless one has side effects. If both strings have constant lengths,
3664 else if (TREE_SIDE_EFFECTS (len1
))
3666 else if (TREE_SIDE_EFFECTS (len2
))
3668 else if (TREE_CODE (len1
) != INTEGER_CST
)
3670 else if (TREE_CODE (len2
) != INTEGER_CST
)
3672 else if (tree_int_cst_lt (len1
, len2
))
3677 /* If both arguments have side effects, we cannot optimize. */
3678 if (!len
|| TREE_SIDE_EFFECTS (len
))
3681 /* If we don't have POINTER_TYPE, call the function. */
3682 if (arg1_align
== 0 || arg2_align
== 0)
3685 /* Make a place to write the result of the instruction. */
3688 && REG_P (result
) && GET_MODE (result
) == insn_mode
3689 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3690 result
= gen_reg_rtx (insn_mode
);
3692 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3693 arg1
= builtin_save_expr (arg1
);
3694 arg2
= builtin_save_expr (arg2
);
3696 arg1_rtx
= get_memory_rtx (arg1
);
3697 arg2_rtx
= get_memory_rtx (arg2
);
3698 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3699 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3700 GEN_INT (MIN (arg1_align
, arg2_align
)));
3705 /* Return the value in the proper mode for this function. */
3706 mode
= TYPE_MODE (TREE_TYPE (exp
));
3707 if (GET_MODE (result
) == mode
)
3710 return convert_to_mode (mode
, result
, 0);
3711 convert_move (target
, result
, 0);
3715 /* Expand the library call ourselves using a stabilized argument
3716 list to avoid re-evaluating the function's arguments twice. */
3717 arglist
= build_tree_list (NULL_TREE
, arg2
);
3718 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3719 fndecl
= get_callee_fndecl (exp
);
3720 exp
= build_function_call_expr (fndecl
, arglist
);
3721 return expand_call (exp
, target
, target
== const0_rtx
);
3727 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3728 if we failed the caller should emit a normal call, otherwise try to get
3729 the result in TARGET, if convenient. */
3732 expand_builtin_strncmp (tree exp
, rtx target
, enum machine_mode mode
)
3734 tree arglist
= TREE_OPERAND (exp
, 1);
3735 tree arg1
, arg2
, arg3
;
3736 const char *p1
, *p2
;
3738 if (!validate_arglist (arglist
,
3739 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3742 arg1
= TREE_VALUE (arglist
);
3743 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3744 arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3746 /* If the len parameter is zero, return zero. */
3747 if (integer_zerop (arg3
))
3749 /* Evaluate and ignore arg1 and arg2 in case they have
3751 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3752 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3756 /* If arg1 and arg2 are equal (and not volatile), return zero. */
3757 if (operand_equal_p (arg1
, arg2
, 0))
3759 /* Evaluate and ignore arg3 in case it has side-effects. */
3760 expand_expr (arg3
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3764 p1
= c_getstr (arg1
);
3765 p2
= c_getstr (arg2
);
3767 /* If all arguments are constant, evaluate at compile-time. */
3768 if (host_integerp (arg3
, 1) && p1
&& p2
)
3770 const int r
= strncmp (p1
, p2
, tree_low_cst (arg3
, 1));
3771 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
3774 /* If len == 1 or (either string parameter is "" and (len >= 1)),
3775 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
3776 if (host_integerp (arg3
, 1)
3777 && (tree_low_cst (arg3
, 1) == 1
3778 || (tree_low_cst (arg3
, 1) > 1
3779 && ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0')))))
3781 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3782 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3784 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3785 build1 (INDIRECT_REF
, cst_uchar_node
,
3786 fold_convert (cst_uchar_ptr_node
, arg1
))));
3788 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3789 build1 (INDIRECT_REF
, cst_uchar_node
,
3790 fold_convert (cst_uchar_ptr_node
, arg2
))));
3791 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3792 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3795 /* If c_strlen can determine an expression for one of the string
3796 lengths, and it doesn't have side effects, then emit cmpstrsi
3797 using length MIN(strlen(string)+1, arg3). */
3798 #ifdef HAVE_cmpstrsi
3801 tree len
, len1
, len2
;
3802 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3807 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3809 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3810 enum machine_mode insn_mode
3811 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3813 len1
= c_strlen (arg1
, 1);
3814 len2
= c_strlen (arg2
, 1);
3817 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3819 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3821 /* If we don't have a constant length for the first, use the length
3822 of the second, if we know it. We don't require a constant for
3823 this case; some cost analysis could be done if both are available
3824 but neither is constant. For now, assume they're equally cheap,
3825 unless one has side effects. If both strings have constant lengths,
3832 else if (TREE_SIDE_EFFECTS (len1
))
3834 else if (TREE_SIDE_EFFECTS (len2
))
3836 else if (TREE_CODE (len1
) != INTEGER_CST
)
3838 else if (TREE_CODE (len2
) != INTEGER_CST
)
3840 else if (tree_int_cst_lt (len1
, len2
))
3845 /* If both arguments have side effects, we cannot optimize. */
3846 if (!len
|| TREE_SIDE_EFFECTS (len
))
3849 /* The actual new length parameter is MIN(len,arg3). */
3850 len
= fold (build2 (MIN_EXPR
, TREE_TYPE (len
), len
,
3851 fold_convert (TREE_TYPE (len
), arg3
)));
3853 /* If we don't have POINTER_TYPE, call the function. */
3854 if (arg1_align
== 0 || arg2_align
== 0)
3857 /* Make a place to write the result of the instruction. */
3860 && REG_P (result
) && GET_MODE (result
) == insn_mode
3861 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3862 result
= gen_reg_rtx (insn_mode
);
3864 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3865 arg1
= builtin_save_expr (arg1
);
3866 arg2
= builtin_save_expr (arg2
);
3867 len
= builtin_save_expr (len
);
3869 arg1_rtx
= get_memory_rtx (arg1
);
3870 arg2_rtx
= get_memory_rtx (arg2
);
3871 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3872 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3873 GEN_INT (MIN (arg1_align
, arg2_align
)));
3878 /* Return the value in the proper mode for this function. */
3879 mode
= TYPE_MODE (TREE_TYPE (exp
));
3880 if (GET_MODE (result
) == mode
)
3883 return convert_to_mode (mode
, result
, 0);
3884 convert_move (target
, result
, 0);
3888 /* Expand the library call ourselves using a stabilized argument
3889 list to avoid re-evaluating the function's arguments twice. */
3890 arglist
= build_tree_list (NULL_TREE
, len
);
3891 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3892 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3893 fndecl
= get_callee_fndecl (exp
);
3894 exp
= build_function_call_expr (fndecl
, arglist
);
3895 return expand_call (exp
, target
, target
== const0_rtx
);
3901 /* Expand expression EXP, which is a call to the strcat builtin.
3902 Return 0 if we failed the caller should emit a normal call,
3903 otherwise try to get the result in TARGET, if convenient. */
3906 expand_builtin_strcat (tree arglist
, rtx target
, enum machine_mode mode
)
3908 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3912 tree dst
= TREE_VALUE (arglist
),
3913 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3914 const char *p
= c_getstr (src
);
3918 /* If the string length is zero, return the dst parameter. */
3920 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3921 else if (!optimize_size
)
3923 /* Otherwise if !optimize_size, see if we can store by
3924 pieces into (dst + strlen(dst)). */
3925 tree newdst
, arglist
,
3926 strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
3928 /* This is the length argument. */
3929 arglist
= build_tree_list (NULL_TREE
,
3930 fold (size_binop (PLUS_EXPR
,
3933 /* Prepend src argument. */
3934 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
3936 /* We're going to use dst more than once. */
3937 dst
= builtin_save_expr (dst
);
3939 /* Create strlen (dst). */
3941 fold (build_function_call_expr (strlen_fn
,
3942 build_tree_list (NULL_TREE
,
3944 /* Create (dst + strlen (dst)). */
3945 newdst
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dst
), dst
, newdst
));
3947 /* Prepend the new dst argument. */
3948 arglist
= tree_cons (NULL_TREE
, newdst
, arglist
);
3950 /* We don't want to get turned into a memcpy if the
3951 target is const0_rtx, i.e. when the return value
3952 isn't used. That would produce pessimized code so
3953 pass in a target of zero, it should never actually be
3954 used. If this was successful return the original
3955 dst, not the result of mempcpy. */
3956 if (expand_builtin_mempcpy (arglist
, /*target=*/0, mode
, /*endp=*/0))
3957 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3967 /* Expand expression EXP, which is a call to the strncat builtin.
3968 Return 0 if we failed the caller should emit a normal call,
3969 otherwise try to get the result in TARGET, if convenient. */
3972 expand_builtin_strncat (tree arglist
, rtx target
, enum machine_mode mode
)
3974 if (!validate_arglist (arglist
,
3975 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3979 tree dst
= TREE_VALUE (arglist
),
3980 src
= TREE_VALUE (TREE_CHAIN (arglist
)),
3981 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3982 const char *p
= c_getstr (src
);
3984 /* If the requested length is zero, or the src parameter string
3985 length is zero, return the dst parameter. */
3986 if (integer_zerop (len
) || (p
&& *p
== '\0'))
3988 /* Evaluate and ignore the src and len parameters in case
3989 they have side-effects. */
3990 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3991 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3992 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3995 /* If the requested len is greater than or equal to the string
3996 length, call strcat. */
3997 if (TREE_CODE (len
) == INTEGER_CST
&& p
3998 && compare_tree_int (len
, strlen (p
)) >= 0)
4001 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
4002 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
4004 /* If the replacement _DECL isn't initialized, don't do the
4009 return expand_expr (build_function_call_expr (fn
, newarglist
),
4010 target
, mode
, EXPAND_NORMAL
);
4016 /* Expand expression EXP, which is a call to the strspn builtin.
4017 Return 0 if we failed the caller should emit a normal call,
4018 otherwise try to get the result in TARGET, if convenient. */
4021 expand_builtin_strspn (tree arglist
, rtx target
, enum machine_mode mode
)
4023 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4027 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
4028 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
4030 /* If both arguments are constants, evaluate at compile-time. */
4033 const size_t r
= strspn (p1
, p2
);
4034 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
4037 /* If either argument is "", return 0. */
4038 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
4040 /* Evaluate and ignore both arguments in case either one has
4042 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4043 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4050 /* Expand expression EXP, which is a call to the strcspn builtin.
4051 Return 0 if we failed the caller should emit a normal call,
4052 otherwise try to get the result in TARGET, if convenient. */
4055 expand_builtin_strcspn (tree arglist
, rtx target
, enum machine_mode mode
)
4057 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4061 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
4062 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
4064 /* If both arguments are constants, evaluate at compile-time. */
4067 const size_t r
= strcspn (p1
, p2
);
4068 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
4071 /* If the first argument is "", return 0. */
4072 if (p1
&& *p1
== '\0')
4074 /* Evaluate and ignore argument s2 in case it has
4076 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4080 /* If the second argument is "", return __builtin_strlen(s1). */
4081 if (p2
&& *p2
== '\0')
4083 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
4084 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
4086 /* If the replacement _DECL isn't initialized, don't do the
4091 return expand_expr (build_function_call_expr (fn
, newarglist
),
4092 target
, mode
, EXPAND_NORMAL
);
4098 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4099 if that's convenient. */
4102 expand_builtin_saveregs (void)
4106 /* Don't do __builtin_saveregs more than once in a function.
4107 Save the result of the first call and reuse it. */
4108 if (saveregs_value
!= 0)
4109 return saveregs_value
;
4111 /* When this function is called, it means that registers must be
4112 saved on entry to this function. So we migrate the call to the
4113 first insn of this function. */
4117 /* Do whatever the machine needs done in this case. */
4118 val
= targetm
.calls
.expand_builtin_saveregs ();
4123 saveregs_value
= val
;
4125 /* Put the insns after the NOTE that starts the function. If this
4126 is inside a start_sequence, make the outer-level insn chain current, so
4127 the code is placed at the start of the function. */
4128 push_topmost_sequence ();
4129 emit_insn_after (seq
, entry_of_function ());
4130 pop_topmost_sequence ();
4135 /* __builtin_args_info (N) returns word N of the arg space info
4136 for the current function. The number and meanings of words
4137 is controlled by the definition of CUMULATIVE_ARGS. */
4140 expand_builtin_args_info (tree arglist
)
4142 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4143 int *word_ptr
= (int *) ¤t_function_args_info
;
4145 gcc_assert (sizeof (CUMULATIVE_ARGS
) % sizeof (int) == 0);
4149 if (!host_integerp (TREE_VALUE (arglist
), 0))
4150 error ("argument of %<__builtin_args_info%> must be constant");
4153 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
4155 if (wordnum
< 0 || wordnum
>= nwords
)
4156 error ("argument of %<__builtin_args_info%> out of range");
4158 return GEN_INT (word_ptr
[wordnum
]);
4162 error ("missing argument in %<__builtin_args_info%>");
4167 /* Expand ARGLIST, from a call to __builtin_next_arg. */
4170 expand_builtin_next_arg (tree arglist
)
4172 tree fntype
= TREE_TYPE (current_function_decl
);
4174 if (TYPE_ARG_TYPES (fntype
) == 0
4175 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
4178 error ("%<va_start%> used in function with fixed args");
4184 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
4185 tree arg
= TREE_VALUE (arglist
);
4187 /* Strip off all nops for the sake of the comparison. This
4188 is not quite the same as STRIP_NOPS. It does more.
4189 We must also strip off INDIRECT_EXPR for C++ reference
4191 while (TREE_CODE (arg
) == NOP_EXPR
4192 || TREE_CODE (arg
) == CONVERT_EXPR
4193 || TREE_CODE (arg
) == NON_LVALUE_EXPR
4194 || TREE_CODE (arg
) == INDIRECT_REF
)
4195 arg
= TREE_OPERAND (arg
, 0);
4196 if (arg
!= last_parm
)
4197 warning ("second parameter of %<va_start%> not last named argument");
4200 /* Evidently an out of date version of <stdarg.h>; can't validate
4201 va_start's second argument, but can still work as intended. */
4202 warning ("%<__builtin_next_arg%> called without an argument");
4204 return expand_binop (Pmode
, add_optab
,
4205 current_function_internal_arg_pointer
,
4206 current_function_arg_offset_rtx
,
4207 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4210 /* Make it easier for the backends by protecting the valist argument
4211 from multiple evaluations. */
4214 stabilize_va_list (tree valist
, int needs_lvalue
)
4216 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4218 if (TREE_SIDE_EFFECTS (valist
))
4219 valist
= save_expr (valist
);
4221 /* For this case, the backends will be expecting a pointer to
4222 TREE_TYPE (va_list_type_node), but it's possible we've
4223 actually been given an array (an actual va_list_type_node).
4225 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4227 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4228 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4237 if (! TREE_SIDE_EFFECTS (valist
))
4240 pt
= build_pointer_type (va_list_type_node
);
4241 valist
= fold (build1 (ADDR_EXPR
, pt
, valist
));
4242 TREE_SIDE_EFFECTS (valist
) = 1;
4245 if (TREE_SIDE_EFFECTS (valist
))
4246 valist
= save_expr (valist
);
4247 valist
= build_fold_indirect_ref (valist
);
4253 /* The "standard" definition of va_list is void*. */
4256 std_build_builtin_va_list (void)
4258 return ptr_type_node
;
4261 /* The "standard" implementation of va_start: just assign `nextarg' to
4265 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4269 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4270 make_tree (ptr_type_node
, nextarg
));
4271 TREE_SIDE_EFFECTS (t
) = 1;
4273 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4276 /* Expand ARGLIST, from a call to __builtin_va_start. */
4279 expand_builtin_va_start (tree arglist
)
4284 chain
= TREE_CHAIN (arglist
);
4286 if (TREE_CHAIN (chain
))
4287 error ("too many arguments to function %<va_start%>");
4289 nextarg
= expand_builtin_next_arg (chain
);
4290 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
4292 #ifdef EXPAND_BUILTIN_VA_START
4293 EXPAND_BUILTIN_VA_START (valist
, nextarg
);
4295 std_expand_builtin_va_start (valist
, nextarg
);
4301 /* The "standard" implementation of va_arg: read the value from the
4302 current (padded) address and increment by the (padded) size. */
4305 std_gimplify_va_arg_expr (tree valist
, tree type
, tree
*pre_p
, tree
*post_p
)
4307 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
4308 unsigned HOST_WIDE_INT align
, boundary
;
4311 #ifdef ARGS_GROW_DOWNWARD
4312 /* All of the alignment and movement below is for args-grow-up machines.
4313 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4314 implement their own specialized gimplify_va_arg_expr routines. */
4318 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
4320 type
= build_pointer_type (type
);
4322 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
4323 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
) / BITS_PER_UNIT
;
4325 /* Hoist the valist value into a temporary for the moment. */
4326 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
4328 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4329 requires greater alignment, we must perform dynamic alignment. */
4330 if (boundary
> align
)
4332 t
= fold_convert (TREE_TYPE (valist
), size_int (boundary
- 1));
4333 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4334 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4335 gimplify_and_add (t
, pre_p
);
4337 t
= fold_convert (TREE_TYPE (valist
), size_int (-boundary
));
4338 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4339 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4340 gimplify_and_add (t
, pre_p
);
4343 /* Compute the rounded size of the type. */
4344 type_size
= size_in_bytes (type
);
4345 rounded_size
= round_up (type_size
, align
);
4347 /* Reduce rounded_size so it's sharable with the postqueue. */
4348 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4352 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
4354 /* Small args are padded downward. */
4355 t
= fold (build2 (GT_EXPR
, sizetype
, rounded_size
, size_int (align
)));
4356 t
= fold (build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4357 size_binop (MINUS_EXPR
, rounded_size
, type_size
)));
4358 t
= fold_convert (TREE_TYPE (addr
), t
);
4359 addr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (addr
), addr
, t
));
4362 /* Compute new value for AP. */
4363 t
= fold_convert (TREE_TYPE (valist
), rounded_size
);
4364 t
= build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
);
4365 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4366 gimplify_and_add (t
, pre_p
);
4368 addr
= fold_convert (build_pointer_type (type
), addr
);
4371 addr
= build_va_arg_indirect_ref (addr
);
4373 return build_va_arg_indirect_ref (addr
);
4376 /* Build an indirect-ref expression over the given TREE, which represents a
4377 piece of a va_arg() expansion. */
4379 build_va_arg_indirect_ref (tree addr
)
4381 addr
= build_fold_indirect_ref (addr
);
4383 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
4389 /* Return a dummy expression of type TYPE in order to keep going after an
4393 dummy_object (tree type
)
4395 tree t
= convert (build_pointer_type (type
), null_pointer_node
);
4396 return build1 (INDIRECT_REF
, type
, t
);
4399 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4400 builtin function, but a very special sort of operator. */
4402 enum gimplify_status
4403 gimplify_va_arg_expr (tree
*expr_p
, tree
*pre_p
, tree
*post_p
)
4405 tree promoted_type
, want_va_type
, have_va_type
;
4406 tree valist
= TREE_OPERAND (*expr_p
, 0);
4407 tree type
= TREE_TYPE (*expr_p
);
4410 /* Verify that valist is of the proper type. */
4411 want_va_type
= va_list_type_node
;
4412 have_va_type
= TREE_TYPE (valist
);
4414 if (have_va_type
== error_mark_node
)
4417 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4419 /* If va_list is an array type, the argument may have decayed
4420 to a pointer type, e.g. by being passed to another function.
4421 In that case, unwrap both types so that we can compare the
4422 underlying records. */
4423 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4424 || TREE_CODE (have_va_type
) == POINTER_TYPE
)
4426 want_va_type
= TREE_TYPE (want_va_type
);
4427 have_va_type
= TREE_TYPE (have_va_type
);
4431 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4433 error ("first argument to %<va_arg%> not of type %<va_list%>");
4437 /* Generate a diagnostic for requesting data of a type that cannot
4438 be passed through `...' due to type promotion at the call site. */
4439 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4442 static bool gave_help
;
4444 /* Unfortunately, this is merely undefined, rather than a constraint
4445 violation, so we cannot make this an error. If this call is never
4446 executed, the program is still strictly conforming. */
4447 warning ("%qT is promoted to %qT when passed through %<...%>",
4448 type
, promoted_type
);
4452 warning ("(so you should pass %qT not %qT to %<va_arg%>)",
4453 promoted_type
, type
);
4456 /* We can, however, treat "undefined" any way we please.
4457 Call abort to encourage the user to fix the program. */
4458 inform ("if this code is reached, the program will abort");
4459 t
= build_function_call_expr (implicit_built_in_decls
[BUILT_IN_TRAP
],
4461 append_to_statement_list (t
, pre_p
);
4463 /* This is dead code, but go ahead and finish so that the
4464 mode of the result comes out right. */
4465 *expr_p
= dummy_object (type
);
4470 /* Make it easier for the backends by protecting the valist argument
4471 from multiple evaluations. */
4472 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4474 /* For this case, the backends will be expecting a pointer to
4475 TREE_TYPE (va_list_type_node), but it's possible we've
4476 actually been given an array (an actual va_list_type_node).
4478 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4480 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4481 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4483 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4486 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4488 if (!targetm
.gimplify_va_arg_expr
)
4489 /* Once most targets are converted this should abort. */
4492 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4497 /* Expand ARGLIST, from a call to __builtin_va_end. */
4500 expand_builtin_va_end (tree arglist
)
4502 tree valist
= TREE_VALUE (arglist
);
4504 /* Evaluate for side effects, if needed. I hate macros that don't
4506 if (TREE_SIDE_EFFECTS (valist
))
4507 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4512 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4513 builtin rather than just as an assignment in stdarg.h because of the
4514 nastiness of array-type va_list types. */
4517 expand_builtin_va_copy (tree arglist
)
4521 dst
= TREE_VALUE (arglist
);
4522 src
= TREE_VALUE (TREE_CHAIN (arglist
));
4524 dst
= stabilize_va_list (dst
, 1);
4525 src
= stabilize_va_list (src
, 0);
4527 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
4529 t
= build2 (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
4530 TREE_SIDE_EFFECTS (t
) = 1;
4531 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4535 rtx dstb
, srcb
, size
;
4537 /* Evaluate to pointers. */
4538 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4539 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4540 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
4541 VOIDmode
, EXPAND_NORMAL
);
4543 dstb
= convert_memory_address (Pmode
, dstb
);
4544 srcb
= convert_memory_address (Pmode
, srcb
);
4546 /* "Dereference" to BLKmode memories. */
4547 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4548 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4549 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
4550 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4551 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4552 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
4555 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4561 /* Expand a call to one of the builtin functions __builtin_frame_address or
4562 __builtin_return_address. */
4565 expand_builtin_frame_address (tree fndecl
, tree arglist
)
4567 /* The argument must be a nonnegative integer constant.
4568 It counts the number of frames to scan up the stack.
4569 The value is the return address saved in that frame. */
4571 /* Warning about missing arg was already issued. */
4573 else if (! host_integerp (TREE_VALUE (arglist
), 1))
4575 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4576 error ("invalid arg to %<__builtin_frame_address%>");
4578 error ("invalid arg to %<__builtin_return_address%>");
4584 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4585 tree_low_cst (TREE_VALUE (arglist
), 1),
4586 hard_frame_pointer_rtx
);
4588 /* Some ports cannot access arbitrary stack frames. */
4591 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4592 warning ("unsupported arg to %<__builtin_frame_address%>");
4594 warning ("unsupported arg to %<__builtin_return_address%>");
4598 /* For __builtin_frame_address, return what we've got. */
4599 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4603 && ! CONSTANT_P (tem
))
4604 tem
= copy_to_mode_reg (Pmode
, tem
);
4609 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4610 we failed and the caller should emit a normal call, otherwise try to get
4611 the result in TARGET, if convenient. */
4614 expand_builtin_alloca (tree arglist
, rtx target
)
4619 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4620 should always expand to function calls. These can be intercepted
4625 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4628 /* Compute the argument. */
4629 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4631 /* Allocate the desired space. */
4632 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
4633 result
= convert_memory_address (ptr_mode
, result
);
4638 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4639 Return 0 if a normal call should be emitted rather than expanding the
4640 function in-line. If convenient, the result should be placed in TARGET.
4641 SUBTARGET may be used as the target for computing one of EXP's operands. */
4644 expand_builtin_unop (enum machine_mode target_mode
, tree arglist
, rtx target
,
4645 rtx subtarget
, optab op_optab
)
4648 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4651 /* Compute the argument. */
4652 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4653 /* Compute op, into TARGET if possible.
4654 Set TARGET to wherever the result comes back. */
4655 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4656 op_optab
, op0
, target
, 1);
4657 gcc_assert (target
);
4659 return convert_to_mode (target_mode
, target
, 0);
4662 /* If the string passed to fputs is a constant and is one character
4663 long, we attempt to transform this call into __builtin_fputc(). */
4666 expand_builtin_fputs (tree arglist
, rtx target
, bool unlocked
)
4669 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
4670 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4671 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
4672 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
4674 /* If the return value is used, or the replacement _DECL isn't
4675 initialized, don't do the transformation. */
4676 if (target
!= const0_rtx
|| !fn_fputc
|| !fn_fwrite
)
4679 /* Verify the arguments in the original call. */
4680 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4683 /* Get the length of the string passed to fputs. If the length
4684 can't be determined, punt. */
4685 if (!(len
= c_strlen (TREE_VALUE (arglist
), 1))
4686 || TREE_CODE (len
) != INTEGER_CST
)
4689 switch (compare_tree_int (len
, 1))
4691 case -1: /* length is 0, delete the call entirely . */
4693 /* Evaluate and ignore the argument in case it has
4695 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
4696 VOIDmode
, EXPAND_NORMAL
);
4699 case 0: /* length is 1, call fputc. */
4701 const char *p
= c_getstr (TREE_VALUE (arglist
));
4705 /* New argument list transforming fputs(string, stream) to
4706 fputc(string[0], stream). */
4707 arglist
= build_tree_list (NULL_TREE
,
4708 TREE_VALUE (TREE_CHAIN (arglist
)));
4709 arglist
= tree_cons (NULL_TREE
,
4710 build_int_cst (NULL_TREE
, p
[0]),
4717 case 1: /* length is greater than 1, call fwrite. */
4721 /* If optimizing for size keep fputs. */
4724 string_arg
= TREE_VALUE (arglist
);
4725 /* New argument list transforming fputs(string, stream) to
4726 fwrite(string, 1, len, stream). */
4727 arglist
= build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
4728 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
4729 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
4730 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
4738 return expand_expr (build_function_call_expr (fn
, arglist
),
4739 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4742 /* Expand a call to __builtin_expect. We return our argument and emit a
4743 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4744 a non-jump context. */
4747 expand_builtin_expect (tree arglist
, rtx target
)
4752 if (arglist
== NULL_TREE
4753 || TREE_CHAIN (arglist
) == NULL_TREE
)
4755 exp
= TREE_VALUE (arglist
);
4756 c
= TREE_VALUE (TREE_CHAIN (arglist
));
4758 if (TREE_CODE (c
) != INTEGER_CST
)
4760 error ("second arg to %<__builtin_expect%> must be a constant");
4761 c
= integer_zero_node
;
4764 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
4766 /* Don't bother with expected value notes for integral constants. */
4767 if (flag_guess_branch_prob
&& GET_CODE (target
) != CONST_INT
)
4769 /* We do need to force this into a register so that we can be
4770 moderately sure to be able to correctly interpret the branch
4772 target
= force_reg (GET_MODE (target
), target
);
4774 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
4776 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
4777 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
4783 /* Like expand_builtin_expect, except do this in a jump context. This is
4784 called from do_jump if the conditional is a __builtin_expect. Return either
4785 a list of insns to emit the jump or NULL if we cannot optimize
4786 __builtin_expect. We need to optimize this at jump time so that machines
4787 like the PowerPC don't turn the test into a SCC operation, and then jump
4788 based on the test being 0/1. */
4791 expand_builtin_expect_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
4793 tree arglist
= TREE_OPERAND (exp
, 1);
4794 tree arg0
= TREE_VALUE (arglist
);
4795 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
4798 /* Only handle __builtin_expect (test, 0) and
4799 __builtin_expect (test, 1). */
4800 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
4801 && (integer_zerop (arg1
) || integer_onep (arg1
)))
4803 rtx insn
, drop_through_label
, temp
;
4805 /* Expand the jump insns. */
4807 do_jump (arg0
, if_false_label
, if_true_label
);
4810 drop_through_label
= get_last_insn ();
4811 if (drop_through_label
&& NOTE_P (drop_through_label
))
4812 drop_through_label
= prev_nonnote_insn (drop_through_label
);
4813 if (drop_through_label
&& !LABEL_P (drop_through_label
))
4814 drop_through_label
= NULL_RTX
;
4817 if (! if_true_label
)
4818 if_true_label
= drop_through_label
;
4819 if (! if_false_label
)
4820 if_false_label
= drop_through_label
;
4822 /* Go through and add the expect's to each of the conditional jumps. */
4824 while (insn
!= NULL_RTX
)
4826 rtx next
= NEXT_INSN (insn
);
4828 if (JUMP_P (insn
) && any_condjump_p (insn
))
4830 rtx ifelse
= SET_SRC (pc_set (insn
));
4831 rtx then_dest
= XEXP (ifelse
, 1);
4832 rtx else_dest
= XEXP (ifelse
, 2);
4835 /* First check if we recognize any of the labels. */
4836 if (GET_CODE (then_dest
) == LABEL_REF
4837 && XEXP (then_dest
, 0) == if_true_label
)
4839 else if (GET_CODE (then_dest
) == LABEL_REF
4840 && XEXP (then_dest
, 0) == if_false_label
)
4842 else if (GET_CODE (else_dest
) == LABEL_REF
4843 && XEXP (else_dest
, 0) == if_false_label
)
4845 else if (GET_CODE (else_dest
) == LABEL_REF
4846 && XEXP (else_dest
, 0) == if_true_label
)
4848 /* Otherwise check where we drop through. */
4849 else if (else_dest
== pc_rtx
)
4851 if (next
&& NOTE_P (next
))
4852 next
= next_nonnote_insn (next
);
4854 if (next
&& JUMP_P (next
)
4855 && any_uncondjump_p (next
))
4856 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4860 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4861 else that can't possibly match either target label. */
4862 if (temp
== if_false_label
)
4864 else if (temp
== if_true_label
)
4867 else if (then_dest
== pc_rtx
)
4869 if (next
&& NOTE_P (next
))
4870 next
= next_nonnote_insn (next
);
4872 if (next
&& JUMP_P (next
)
4873 && any_uncondjump_p (next
))
4874 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4878 if (temp
== if_false_label
)
4880 else if (temp
== if_true_label
)
4886 /* If the test is expected to fail, reverse the
4888 if (integer_zerop (arg1
))
4890 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
4902 expand_builtin_trap (void)
4906 emit_insn (gen_trap ());
4909 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4913 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4914 Return 0 if a normal call should be emitted rather than expanding
4915 the function inline. If convenient, the result should be placed
4916 in TARGET. SUBTARGET may be used as the target for computing
4920 expand_builtin_fabs (tree arglist
, rtx target
, rtx subtarget
)
4922 enum machine_mode mode
;
4926 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
4929 arg
= TREE_VALUE (arglist
);
4930 mode
= TYPE_MODE (TREE_TYPE (arg
));
4931 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4932 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4935 /* Create a new constant string literal and return a char* pointer to it.
4936 The STRING_CST value is the LEN characters at STR. */
4938 build_string_literal (int len
, const char *str
)
4940 tree t
, elem
, index
, type
;
4942 t
= build_string (len
, str
);
4943 elem
= build_type_variant (char_type_node
, 1, 0);
4944 index
= build_index_type (build_int_cst (NULL_TREE
, len
- 1));
4945 type
= build_array_type (elem
, index
);
4946 TREE_TYPE (t
) = type
;
4947 TREE_CONSTANT (t
) = 1;
4948 TREE_INVARIANT (t
) = 1;
4949 TREE_READONLY (t
) = 1;
4950 TREE_STATIC (t
) = 1;
4952 type
= build_pointer_type (type
);
4953 t
= build1 (ADDR_EXPR
, type
, t
);
4955 type
= build_pointer_type (elem
);
4956 t
= build1 (NOP_EXPR
, type
, t
);
4960 /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
4961 Return 0 if a normal call should be emitted rather than transforming
4962 the function inline. If convenient, the result should be placed in
4963 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4966 expand_builtin_printf (tree arglist
, rtx target
, enum machine_mode mode
,
4969 tree fn_putchar
= unlocked
4970 ? implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
]
4971 : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4972 tree fn_puts
= unlocked
? implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
]
4973 : implicit_built_in_decls
[BUILT_IN_PUTS
];
4974 const char *fmt_str
;
4977 /* If the return value is used, don't do the transformation. */
4978 if (target
!= const0_rtx
)
4981 /* Verify the required arguments in the original call. */
4984 fmt
= TREE_VALUE (arglist
);
4985 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
4987 arglist
= TREE_CHAIN (arglist
);
4989 /* Check whether the format is a literal string constant. */
4990 fmt_str
= c_getstr (fmt
);
4991 if (fmt_str
== NULL
)
4994 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4995 if (strcmp (fmt_str
, "%s\n") == 0)
4998 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
4999 || TREE_CHAIN (arglist
))
5003 /* If the format specifier was "%c", call __builtin_putchar(arg). */
5004 else if (strcmp (fmt_str
, "%c") == 0)
5007 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
5008 || TREE_CHAIN (arglist
))
5014 /* We can't handle anything else with % args or %% ... yet. */
5015 if (strchr (fmt_str
, '%'))
5021 /* If the format specifier was "", printf does nothing. */
5022 if (fmt_str
[0] == '\0')
5024 /* If the format specifier has length of 1, call putchar. */
5025 if (fmt_str
[1] == '\0')
5027 /* Given printf("c"), (where c is any one character,)
5028 convert "c"[0] to an int and pass that to the replacement
5030 arg
= build_int_cst (NULL_TREE
, fmt_str
[0]);
5031 arglist
= build_tree_list (NULL_TREE
, arg
);
5036 /* If the format specifier was "string\n", call puts("string"). */
5037 size_t len
= strlen (fmt_str
);
5038 if (fmt_str
[len
- 1] == '\n')
5040 /* Create a NUL-terminated string that's one char shorter
5041 than the original, stripping off the trailing '\n'. */
5042 char *newstr
= alloca (len
);
5043 memcpy (newstr
, fmt_str
, len
- 1);
5044 newstr
[len
- 1] = 0;
5046 arg
= build_string_literal (len
, newstr
);
5047 arglist
= build_tree_list (NULL_TREE
, arg
);
5051 /* We'd like to arrange to call fputs(string,stdout) here,
5052 but we need stdout and don't have a way to get it yet. */
5059 return expand_expr (build_function_call_expr (fn
, arglist
),
5060 target
, mode
, EXPAND_NORMAL
);
5063 /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
5064 Return 0 if a normal call should be emitted rather than transforming
5065 the function inline. If convenient, the result should be placed in
5066 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5069 expand_builtin_fprintf (tree arglist
, rtx target
, enum machine_mode mode
,
5072 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
5073 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
5074 tree fn_fputs
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
]
5075 : implicit_built_in_decls
[BUILT_IN_FPUTS
];
5076 const char *fmt_str
;
5077 tree fn
, fmt
, fp
, arg
;
5079 /* If the return value is used, don't do the transformation. */
5080 if (target
!= const0_rtx
)
5083 /* Verify the required arguments in the original call. */
5086 fp
= TREE_VALUE (arglist
);
5087 if (TREE_CODE (TREE_TYPE (fp
)) != POINTER_TYPE
)
5089 arglist
= TREE_CHAIN (arglist
);
5092 fmt
= TREE_VALUE (arglist
);
5093 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
5095 arglist
= TREE_CHAIN (arglist
);
5097 /* Check whether the format is a literal string constant. */
5098 fmt_str
= c_getstr (fmt
);
5099 if (fmt_str
== NULL
)
5102 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5103 if (strcmp (fmt_str
, "%s") == 0)
5106 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5107 || TREE_CHAIN (arglist
))
5109 arg
= TREE_VALUE (arglist
);
5110 arglist
= build_tree_list (NULL_TREE
, fp
);
5111 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
5114 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5115 else if (strcmp (fmt_str
, "%c") == 0)
5118 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
5119 || TREE_CHAIN (arglist
))
5121 arg
= TREE_VALUE (arglist
);
5122 arglist
= build_tree_list (NULL_TREE
, fp
);
5123 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
5128 /* We can't handle anything else with % args or %% ... yet. */
5129 if (strchr (fmt_str
, '%'))
5135 /* If the format specifier was "", fprintf does nothing. */
5136 if (fmt_str
[0] == '\0')
5138 /* Evaluate and ignore FILE* argument for side-effects. */
5139 expand_expr (fp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5143 /* When "string" doesn't contain %, replace all cases of
5144 fprintf(stream,string) with fputs(string,stream). The fputs
5145 builtin will take care of special cases like length == 1. */
5146 arglist
= build_tree_list (NULL_TREE
, fp
);
5147 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
5153 return expand_expr (build_function_call_expr (fn
, arglist
),
5154 target
, mode
, EXPAND_NORMAL
);
5157 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
5158 a normal call should be emitted rather than expanding the function
5159 inline. If convenient, the result should be placed in TARGET with
5163 expand_builtin_sprintf (tree arglist
, rtx target
, enum machine_mode mode
)
5165 tree orig_arglist
, dest
, fmt
;
5166 const char *fmt_str
;
5168 orig_arglist
= arglist
;
5170 /* Verify the required arguments in the original call. */
5173 dest
= TREE_VALUE (arglist
);
5174 if (TREE_CODE (TREE_TYPE (dest
)) != POINTER_TYPE
)
5176 arglist
= TREE_CHAIN (arglist
);
5179 fmt
= TREE_VALUE (arglist
);
5180 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
5182 arglist
= TREE_CHAIN (arglist
);
5184 /* Check whether the format is a literal string constant. */
5185 fmt_str
= c_getstr (fmt
);
5186 if (fmt_str
== NULL
)
5189 /* If the format doesn't contain % args or %%, use strcpy. */
5190 if (strchr (fmt_str
, '%') == 0)
5192 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5195 if (arglist
|| ! fn
)
5197 expand_expr (build_function_call_expr (fn
, orig_arglist
),
5198 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5199 if (target
== const0_rtx
)
5201 exp
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
5202 return expand_expr (exp
, target
, mode
, EXPAND_NORMAL
);
5204 /* If the format is "%s", use strcpy if the result isn't used. */
5205 else if (strcmp (fmt_str
, "%s") == 0)
5208 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5213 if (! arglist
|| TREE_CHAIN (arglist
))
5215 arg
= TREE_VALUE (arglist
);
5216 if (TREE_CODE (TREE_TYPE (arg
)) != POINTER_TYPE
)
5219 if (target
!= const0_rtx
)
5221 len
= c_strlen (arg
, 1);
5222 if (! len
|| TREE_CODE (len
) != INTEGER_CST
)
5228 arglist
= build_tree_list (NULL_TREE
, arg
);
5229 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
5230 expand_expr (build_function_call_expr (fn
, arglist
),
5231 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5233 if (target
== const0_rtx
)
5235 return expand_expr (len
, target
, mode
, EXPAND_NORMAL
);
5241 /* Expand a call to either the entry or exit function profiler. */
5244 expand_builtin_profile_func (bool exitp
)
5248 this = DECL_RTL (current_function_decl
);
5249 gcc_assert (MEM_P (this));
5250 this = XEXP (this, 0);
5253 which
= profile_function_exit_libfunc
;
5255 which
= profile_function_entry_libfunc
;
5257 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this, Pmode
,
5258 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
5259 0, hard_frame_pointer_rtx
),
5265 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5268 round_trampoline_addr (rtx tramp
)
5270 rtx temp
, addend
, mask
;
5272 /* If we don't need too much alignment, we'll have been guaranteed
5273 proper alignment by get_trampoline_type. */
5274 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
5277 /* Round address up to desired boundary. */
5278 temp
= gen_reg_rtx (Pmode
);
5279 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
5280 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
5282 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
5283 temp
, 0, OPTAB_LIB_WIDEN
);
5284 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
5285 temp
, 0, OPTAB_LIB_WIDEN
);
5291 expand_builtin_init_trampoline (tree arglist
)
5293 tree t_tramp
, t_func
, t_chain
;
5294 rtx r_tramp
, r_func
, r_chain
;
5295 #ifdef TRAMPOLINE_TEMPLATE
5299 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
,
5300 POINTER_TYPE
, VOID_TYPE
))
5303 t_tramp
= TREE_VALUE (arglist
);
5304 arglist
= TREE_CHAIN (arglist
);
5305 t_func
= TREE_VALUE (arglist
);
5306 arglist
= TREE_CHAIN (arglist
);
5307 t_chain
= TREE_VALUE (arglist
);
5309 r_tramp
= expand_expr (t_tramp
, NULL_RTX
, VOIDmode
, 0);
5310 r_func
= expand_expr (t_func
, NULL_RTX
, VOIDmode
, 0);
5311 r_chain
= expand_expr (t_chain
, NULL_RTX
, VOIDmode
, 0);
5313 /* Generate insns to initialize the trampoline. */
5314 r_tramp
= round_trampoline_addr (r_tramp
);
5315 #ifdef TRAMPOLINE_TEMPLATE
5316 blktramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
5317 set_mem_align (blktramp
, TRAMPOLINE_ALIGNMENT
);
5318 emit_block_move (blktramp
, assemble_trampoline_template (),
5319 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
5321 trampolines_created
= 1;
5322 INITIALIZE_TRAMPOLINE (r_tramp
, r_func
, r_chain
);
5328 expand_builtin_adjust_trampoline (tree arglist
)
5332 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5335 tramp
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5336 tramp
= round_trampoline_addr (tramp
);
5337 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5338 TRAMPOLINE_ADJUST_ADDRESS (tramp
);
5344 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5345 Return NULL_RTX if a normal call should be emitted rather than expanding
5346 the function in-line. EXP is the expression that is a call to the builtin
5347 function; if convenient, the result should be placed in TARGET. */
5350 expand_builtin_signbit (tree exp
, rtx target
)
5352 const struct real_format
*fmt
;
5353 enum machine_mode fmode
, imode
, rmode
;
5354 HOST_WIDE_INT hi
, lo
;
5359 arglist
= TREE_OPERAND (exp
, 1);
5360 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
5363 arg
= TREE_VALUE (arglist
);
5364 fmode
= TYPE_MODE (TREE_TYPE (arg
));
5365 rmode
= TYPE_MODE (TREE_TYPE (exp
));
5366 fmt
= REAL_MODE_FORMAT (fmode
);
5368 /* For floating point formats without a sign bit, implement signbit
5370 if (fmt
->signbit
< 0)
5372 /* But we can't do this if the format supports signed zero. */
5373 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5376 arg
= fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
5377 build_real (TREE_TYPE (arg
), dconst0
)));
5378 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5381 imode
= int_mode_for_mode (fmode
);
5382 if (imode
== BLKmode
)
5385 bitpos
= fmt
->signbit
;
5386 /* Handle targets with different FP word orders. */
5387 if (FLOAT_WORDS_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
5389 int nwords
= GET_MODE_BITSIZE (fmode
) / BITS_PER_WORD
;
5390 int word
= nwords
- (bitpos
/ BITS_PER_WORD
) - 1;
5391 bitpos
= word
* BITS_PER_WORD
+ bitpos
% BITS_PER_WORD
;
5394 /* If the sign bit is not in the lowpart and the floating point format
5395 is wider than an integer, check that is twice the size of an integer
5396 so that we can use gen_highpart below. */
5397 if (bitpos
>= GET_MODE_BITSIZE (rmode
)
5398 && GET_MODE_BITSIZE (imode
) != 2 * GET_MODE_BITSIZE (rmode
))
5401 temp
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5402 temp
= gen_lowpart (imode
, temp
);
5404 if (GET_MODE_BITSIZE (imode
) > GET_MODE_BITSIZE (rmode
))
5406 if (BYTES_BIG_ENDIAN
)
5407 bitpos
= GET_MODE_BITSIZE (imode
) - 1 - bitpos
;
5408 temp
= copy_to_mode_reg (imode
, temp
);
5409 temp
= extract_bit_field (temp
, 1, bitpos
, 1,
5410 NULL_RTX
, rmode
, rmode
);
5414 if (GET_MODE_BITSIZE (imode
) < GET_MODE_BITSIZE (rmode
))
5415 temp
= gen_lowpart (rmode
, temp
);
5416 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5419 lo
= (HOST_WIDE_INT
) 1 << bitpos
;
5423 hi
= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5427 temp
= force_reg (rmode
, temp
);
5428 temp
= expand_binop (rmode
, and_optab
, temp
,
5429 immed_double_const (lo
, hi
, rmode
),
5430 target
, 1, OPTAB_LIB_WIDEN
);
5435 /* Expand fork or exec calls. TARGET is the desired target of the
5436 call. ARGLIST is the list of arguments of the call. FN is the
5437 identificator of the actual function. IGNORE is nonzero if the
5438 value is to be ignored. */
5441 expand_builtin_fork_or_exec (tree fn
, tree arglist
, rtx target
, int ignore
)
5446 /* If we are not profiling, just call the function. */
5447 if (!profile_arc_flag
)
5450 /* Otherwise call the wrapper. This should be equivalent for the rest of
5451 compiler, so the code does not diverge, and the wrapper may run the
5452 code necessary for keeping the profiling sane. */
5454 switch (DECL_FUNCTION_CODE (fn
))
5457 id
= get_identifier ("__gcov_fork");
5460 case BUILT_IN_EXECL
:
5461 id
= get_identifier ("__gcov_execl");
5464 case BUILT_IN_EXECV
:
5465 id
= get_identifier ("__gcov_execv");
5468 case BUILT_IN_EXECLP
:
5469 id
= get_identifier ("__gcov_execlp");
5472 case BUILT_IN_EXECLE
:
5473 id
= get_identifier ("__gcov_execle");
5476 case BUILT_IN_EXECVP
:
5477 id
= get_identifier ("__gcov_execvp");
5480 case BUILT_IN_EXECVE
:
5481 id
= get_identifier ("__gcov_execve");
5488 decl
= build_decl (FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5489 DECL_EXTERNAL (decl
) = 1;
5490 TREE_PUBLIC (decl
) = 1;
5491 DECL_ARTIFICIAL (decl
) = 1;
5492 TREE_NOTHROW (decl
) = 1;
5493 call
= build_function_call_expr (decl
, arglist
);
5495 return expand_call (call
, target
, ignore
);
5498 /* Expand an expression EXP that calls a built-in function,
5499 with result going to TARGET if that's convenient
5500 (and in mode MODE if that's convenient).
5501 SUBTARGET may be used as the target for computing one of EXP's operands.
5502 IGNORE is nonzero if the value is to be ignored. */
5505 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5508 tree fndecl
= get_callee_fndecl (exp
);
5509 tree arglist
= TREE_OPERAND (exp
, 1);
5510 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5511 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5513 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5514 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5516 /* When not optimizing, generate calls to library functions for a certain
5519 && !CALLED_AS_BUILT_IN (fndecl
)
5520 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5521 && fcode
!= BUILT_IN_ALLOCA
)
5522 return expand_call (exp
, target
, ignore
);
5524 /* The built-in function expanders test for target == const0_rtx
5525 to determine whether the function's result will be ignored. */
5527 target
= const0_rtx
;
5529 /* If the result of a pure or const built-in function is ignored, and
5530 none of its arguments are volatile, we can avoid expanding the
5531 built-in call and just evaluate the arguments for side-effects. */
5532 if (target
== const0_rtx
5533 && (DECL_IS_PURE (fndecl
) || TREE_READONLY (fndecl
)))
5535 bool volatilep
= false;
5538 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5539 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
5547 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5548 expand_expr (TREE_VALUE (arg
), const0_rtx
,
5549 VOIDmode
, EXPAND_NORMAL
);
5557 case BUILT_IN_FABSF
:
5558 case BUILT_IN_FABSL
:
5559 target
= expand_builtin_fabs (arglist
, target
, subtarget
);
5564 /* Just do a normal library call if we were unable to fold
5567 case BUILT_IN_CABSF
:
5568 case BUILT_IN_CABSL
:
5574 case BUILT_IN_EXP10
:
5575 case BUILT_IN_EXP10F
:
5576 case BUILT_IN_EXP10L
:
5577 case BUILT_IN_POW10
:
5578 case BUILT_IN_POW10F
:
5579 case BUILT_IN_POW10L
:
5581 case BUILT_IN_EXP2F
:
5582 case BUILT_IN_EXP2L
:
5583 case BUILT_IN_EXPM1
:
5584 case BUILT_IN_EXPM1F
:
5585 case BUILT_IN_EXPM1L
:
5587 case BUILT_IN_LOGBF
:
5588 case BUILT_IN_LOGBL
:
5589 case BUILT_IN_ILOGB
:
5590 case BUILT_IN_ILOGBF
:
5591 case BUILT_IN_ILOGBL
:
5595 case BUILT_IN_LOG10
:
5596 case BUILT_IN_LOG10F
:
5597 case BUILT_IN_LOG10L
:
5599 case BUILT_IN_LOG2F
:
5600 case BUILT_IN_LOG2L
:
5601 case BUILT_IN_LOG1P
:
5602 case BUILT_IN_LOG1PF
:
5603 case BUILT_IN_LOG1PL
:
5608 case BUILT_IN_ASINF
:
5609 case BUILT_IN_ASINL
:
5611 case BUILT_IN_ACOSF
:
5612 case BUILT_IN_ACOSL
:
5614 case BUILT_IN_ATANF
:
5615 case BUILT_IN_ATANL
:
5616 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5617 because of possible accuracy problems. */
5618 if (! flag_unsafe_math_optimizations
)
5621 case BUILT_IN_SQRTF
:
5622 case BUILT_IN_SQRTL
:
5623 case BUILT_IN_FLOOR
:
5624 case BUILT_IN_FLOORF
:
5625 case BUILT_IN_FLOORL
:
5627 case BUILT_IN_CEILF
:
5628 case BUILT_IN_CEILL
:
5629 case BUILT_IN_TRUNC
:
5630 case BUILT_IN_TRUNCF
:
5631 case BUILT_IN_TRUNCL
:
5632 case BUILT_IN_ROUND
:
5633 case BUILT_IN_ROUNDF
:
5634 case BUILT_IN_ROUNDL
:
5635 case BUILT_IN_NEARBYINT
:
5636 case BUILT_IN_NEARBYINTF
:
5637 case BUILT_IN_NEARBYINTL
:
5639 case BUILT_IN_RINTF
:
5640 case BUILT_IN_RINTL
:
5641 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5649 target
= expand_builtin_pow (exp
, target
, subtarget
);
5654 case BUILT_IN_ATAN2
:
5655 case BUILT_IN_ATAN2F
:
5656 case BUILT_IN_ATAN2L
:
5658 case BUILT_IN_FMODF
:
5659 case BUILT_IN_FMODL
:
5661 case BUILT_IN_DREMF
:
5662 case BUILT_IN_DREML
:
5663 if (! flag_unsafe_math_optimizations
)
5665 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5676 if (! flag_unsafe_math_optimizations
)
5678 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5683 case BUILT_IN_APPLY_ARGS
:
5684 return expand_builtin_apply_args ();
5686 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5687 FUNCTION with a copy of the parameters described by
5688 ARGUMENTS, and ARGSIZE. It returns a block of memory
5689 allocated on the stack into which is stored all the registers
5690 that might possibly be used for returning the result of a
5691 function. ARGUMENTS is the value returned by
5692 __builtin_apply_args. ARGSIZE is the number of bytes of
5693 arguments that must be copied. ??? How should this value be
5694 computed? We'll also need a safe worst case value for varargs
5696 case BUILT_IN_APPLY
:
5697 if (!validate_arglist (arglist
, POINTER_TYPE
,
5698 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5699 && !validate_arglist (arglist
, REFERENCE_TYPE
,
5700 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5708 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
5709 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
5711 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5714 /* __builtin_return (RESULT) causes the function to return the
5715 value described by RESULT. RESULT is address of the block of
5716 memory returned by __builtin_apply. */
5717 case BUILT_IN_RETURN
:
5718 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5719 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
5720 NULL_RTX
, VOIDmode
, 0));
5723 case BUILT_IN_SAVEREGS
:
5724 return expand_builtin_saveregs ();
5726 case BUILT_IN_ARGS_INFO
:
5727 return expand_builtin_args_info (arglist
);
5729 /* Return the address of the first anonymous stack arg. */
5730 case BUILT_IN_NEXT_ARG
:
5731 simplify_builtin_next_arg (arglist
);
5732 return expand_builtin_next_arg (arglist
);
5734 case BUILT_IN_CLASSIFY_TYPE
:
5735 return expand_builtin_classify_type (arglist
);
5737 case BUILT_IN_CONSTANT_P
:
5740 case BUILT_IN_FRAME_ADDRESS
:
5741 case BUILT_IN_RETURN_ADDRESS
:
5742 return expand_builtin_frame_address (fndecl
, arglist
);
5744 /* Returns the address of the area where the structure is returned.
5746 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
5748 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
5749 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
5752 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
5754 case BUILT_IN_ALLOCA
:
5755 target
= expand_builtin_alloca (arglist
, target
);
5760 case BUILT_IN_STACK_SAVE
:
5761 return expand_stack_save ();
5763 case BUILT_IN_STACK_RESTORE
:
5764 expand_stack_restore (TREE_VALUE (arglist
));
5769 case BUILT_IN_FFSLL
:
5770 case BUILT_IN_FFSIMAX
:
5771 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5772 subtarget
, ffs_optab
);
5779 case BUILT_IN_CLZLL
:
5780 case BUILT_IN_CLZIMAX
:
5781 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5782 subtarget
, clz_optab
);
5789 case BUILT_IN_CTZLL
:
5790 case BUILT_IN_CTZIMAX
:
5791 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5792 subtarget
, ctz_optab
);
5797 case BUILT_IN_POPCOUNT
:
5798 case BUILT_IN_POPCOUNTL
:
5799 case BUILT_IN_POPCOUNTLL
:
5800 case BUILT_IN_POPCOUNTIMAX
:
5801 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5802 subtarget
, popcount_optab
);
5807 case BUILT_IN_PARITY
:
5808 case BUILT_IN_PARITYL
:
5809 case BUILT_IN_PARITYLL
:
5810 case BUILT_IN_PARITYIMAX
:
5811 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5812 subtarget
, parity_optab
);
5817 case BUILT_IN_STRLEN
:
5818 target
= expand_builtin_strlen (arglist
, target
, target_mode
);
5823 case BUILT_IN_STRCPY
:
5824 target
= expand_builtin_strcpy (arglist
, target
, mode
);
5829 case BUILT_IN_STRNCPY
:
5830 target
= expand_builtin_strncpy (arglist
, target
, mode
);
5835 case BUILT_IN_STPCPY
:
5836 target
= expand_builtin_stpcpy (arglist
, target
, mode
);
5841 case BUILT_IN_STRCAT
:
5842 target
= expand_builtin_strcat (arglist
, target
, mode
);
5847 case BUILT_IN_STRNCAT
:
5848 target
= expand_builtin_strncat (arglist
, target
, mode
);
5853 case BUILT_IN_STRSPN
:
5854 target
= expand_builtin_strspn (arglist
, target
, mode
);
5859 case BUILT_IN_STRCSPN
:
5860 target
= expand_builtin_strcspn (arglist
, target
, mode
);
5865 case BUILT_IN_STRSTR
:
5866 target
= expand_builtin_strstr (arglist
, target
, mode
);
5871 case BUILT_IN_STRPBRK
:
5872 target
= expand_builtin_strpbrk (arglist
, target
, mode
);
5877 case BUILT_IN_INDEX
:
5878 case BUILT_IN_STRCHR
:
5879 target
= expand_builtin_strchr (arglist
, target
, mode
);
5884 case BUILT_IN_RINDEX
:
5885 case BUILT_IN_STRRCHR
:
5886 target
= expand_builtin_strrchr (arglist
, target
, mode
);
5891 case BUILT_IN_MEMCPY
:
5892 target
= expand_builtin_memcpy (arglist
, target
, mode
);
5897 case BUILT_IN_MEMPCPY
:
5898 target
= expand_builtin_mempcpy (arglist
, target
, mode
, /*endp=*/ 1);
5903 case BUILT_IN_MEMMOVE
:
5904 target
= expand_builtin_memmove (arglist
, target
, mode
);
5909 case BUILT_IN_BCOPY
:
5910 target
= expand_builtin_bcopy (arglist
);
5915 case BUILT_IN_MEMSET
:
5916 target
= expand_builtin_memset (arglist
, target
, mode
);
5921 case BUILT_IN_BZERO
:
5922 target
= expand_builtin_bzero (arglist
);
5927 case BUILT_IN_STRCMP
:
5928 target
= expand_builtin_strcmp (exp
, target
, mode
);
5933 case BUILT_IN_STRNCMP
:
5934 target
= expand_builtin_strncmp (exp
, target
, mode
);
5940 case BUILT_IN_MEMCMP
:
5941 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
5946 case BUILT_IN_SETJMP
:
5947 target
= expand_builtin_setjmp (arglist
, target
);
5952 /* __builtin_longjmp is passed a pointer to an array of five words.
5953 It's similar to the C library longjmp function but works with
5954 __builtin_setjmp above. */
5955 case BUILT_IN_LONGJMP
:
5956 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5960 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
5962 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
5963 NULL_RTX
, VOIDmode
, 0);
5965 if (value
!= const1_rtx
)
5967 error ("__builtin_longjmp second argument must be 1");
5971 expand_builtin_longjmp (buf_addr
, value
);
5975 case BUILT_IN_NONLOCAL_GOTO
:
5976 target
= expand_builtin_nonlocal_goto (arglist
);
5981 /* This updates the setjmp buffer that is its argument with the value
5982 of the current stack pointer. */
5983 case BUILT_IN_UPDATE_SETJMP_BUF
:
5984 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5987 = expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5989 expand_builtin_update_setjmp_buf (buf_addr
);
5995 expand_builtin_trap ();
5998 case BUILT_IN_PRINTF
:
5999 target
= expand_builtin_printf (arglist
, target
, mode
, false);
6004 case BUILT_IN_PRINTF_UNLOCKED
:
6005 target
= expand_builtin_printf (arglist
, target
, mode
, true);
6010 case BUILT_IN_FPUTS
:
6011 target
= expand_builtin_fputs (arglist
, target
, false);
6015 case BUILT_IN_FPUTS_UNLOCKED
:
6016 target
= expand_builtin_fputs (arglist
, target
, true);
6021 case BUILT_IN_FPRINTF
:
6022 target
= expand_builtin_fprintf (arglist
, target
, mode
, false);
6027 case BUILT_IN_FPRINTF_UNLOCKED
:
6028 target
= expand_builtin_fprintf (arglist
, target
, mode
, true);
6033 case BUILT_IN_SPRINTF
:
6034 target
= expand_builtin_sprintf (arglist
, target
, mode
);
6039 case BUILT_IN_SIGNBIT
:
6040 case BUILT_IN_SIGNBITF
:
6041 case BUILT_IN_SIGNBITL
:
6042 target
= expand_builtin_signbit (exp
, target
);
6047 /* Various hooks for the DWARF 2 __throw routine. */
6048 case BUILT_IN_UNWIND_INIT
:
6049 expand_builtin_unwind_init ();
6051 case BUILT_IN_DWARF_CFA
:
6052 return virtual_cfa_rtx
;
6053 #ifdef DWARF2_UNWIND_INFO
6054 case BUILT_IN_DWARF_SP_COLUMN
:
6055 return expand_builtin_dwarf_sp_column ();
6056 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6057 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
6060 case BUILT_IN_FROB_RETURN_ADDR
:
6061 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
6062 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6063 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
6064 case BUILT_IN_EH_RETURN
:
6065 expand_builtin_eh_return (TREE_VALUE (arglist
),
6066 TREE_VALUE (TREE_CHAIN (arglist
)));
6068 #ifdef EH_RETURN_DATA_REGNO
6069 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6070 return expand_builtin_eh_return_data_regno (arglist
);
6072 case BUILT_IN_EXTEND_POINTER
:
6073 return expand_builtin_extend_pointer (TREE_VALUE (arglist
));
6075 case BUILT_IN_VA_START
:
6076 case BUILT_IN_STDARG_START
:
6077 return expand_builtin_va_start (arglist
);
6078 case BUILT_IN_VA_END
:
6079 return expand_builtin_va_end (arglist
);
6080 case BUILT_IN_VA_COPY
:
6081 return expand_builtin_va_copy (arglist
);
6082 case BUILT_IN_EXPECT
:
6083 return expand_builtin_expect (arglist
, target
);
6084 case BUILT_IN_PREFETCH
:
6085 expand_builtin_prefetch (arglist
);
6088 case BUILT_IN_PROFILE_FUNC_ENTER
:
6089 return expand_builtin_profile_func (false);
6090 case BUILT_IN_PROFILE_FUNC_EXIT
:
6091 return expand_builtin_profile_func (true);
6093 case BUILT_IN_INIT_TRAMPOLINE
:
6094 return expand_builtin_init_trampoline (arglist
);
6095 case BUILT_IN_ADJUST_TRAMPOLINE
:
6096 return expand_builtin_adjust_trampoline (arglist
);
6099 case BUILT_IN_EXECL
:
6100 case BUILT_IN_EXECV
:
6101 case BUILT_IN_EXECLP
:
6102 case BUILT_IN_EXECLE
:
6103 case BUILT_IN_EXECVP
:
6104 case BUILT_IN_EXECVE
:
6105 target
= expand_builtin_fork_or_exec (fndecl
, arglist
, target
, ignore
);
6110 default: /* just do library call, if unknown builtin */
6114 /* The switch statement above can drop through to cause the function
6115 to be called normally. */
6116 return expand_call (exp
, target
, ignore
);
6119 /* Determine whether a tree node represents a call to a built-in
6120 function. If the tree T is a call to a built-in function with
6121 the right number of arguments of the appropriate types, return
6122 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6123 Otherwise the return value is END_BUILTINS. */
6125 enum built_in_function
6126 builtin_mathfn_code (tree t
)
6128 tree fndecl
, arglist
, parmlist
;
6129 tree argtype
, parmtype
;
6131 if (TREE_CODE (t
) != CALL_EXPR
6132 || TREE_CODE (TREE_OPERAND (t
, 0)) != ADDR_EXPR
)
6133 return END_BUILTINS
;
6135 fndecl
= get_callee_fndecl (t
);
6136 if (fndecl
== NULL_TREE
6137 || TREE_CODE (fndecl
) != FUNCTION_DECL
6138 || ! DECL_BUILT_IN (fndecl
)
6139 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6140 return END_BUILTINS
;
6142 arglist
= TREE_OPERAND (t
, 1);
6143 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6144 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6146 /* If a function doesn't take a variable number of arguments,
6147 the last element in the list will have type `void'. */
6148 parmtype
= TREE_VALUE (parmlist
);
6149 if (VOID_TYPE_P (parmtype
))
6152 return END_BUILTINS
;
6153 return DECL_FUNCTION_CODE (fndecl
);
6157 return END_BUILTINS
;
6159 argtype
= TREE_TYPE (TREE_VALUE (arglist
));
6161 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6163 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6164 return END_BUILTINS
;
6166 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6168 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6169 return END_BUILTINS
;
6171 else if (POINTER_TYPE_P (parmtype
))
6173 if (! POINTER_TYPE_P (argtype
))
6174 return END_BUILTINS
;
6176 else if (INTEGRAL_TYPE_P (parmtype
))
6178 if (! INTEGRAL_TYPE_P (argtype
))
6179 return END_BUILTINS
;
6182 return END_BUILTINS
;
6184 arglist
= TREE_CHAIN (arglist
);
6187 /* Variable-length argument list. */
6188 return DECL_FUNCTION_CODE (fndecl
);
6191 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6192 constant. ARGLIST is the argument list of the call. */
6195 fold_builtin_constant_p (tree arglist
)
6200 arglist
= TREE_VALUE (arglist
);
6202 /* We return 1 for a numeric type that's known to be a constant
6203 value at compile-time or for an aggregate type that's a
6204 literal constant. */
6205 STRIP_NOPS (arglist
);
6207 /* If we know this is a constant, emit the constant of one. */
6208 if (CONSTANT_CLASS_P (arglist
)
6209 || (TREE_CODE (arglist
) == CONSTRUCTOR
6210 && TREE_CONSTANT (arglist
))
6211 || (TREE_CODE (arglist
) == ADDR_EXPR
6212 && TREE_CODE (TREE_OPERAND (arglist
, 0)) == STRING_CST
))
6213 return integer_one_node
;
6215 /* If this expression has side effects, show we don't know it to be a
6216 constant. Likewise if it's a pointer or aggregate type since in
6217 those case we only want literals, since those are only optimized
6218 when generating RTL, not later.
6219 And finally, if we are compiling an initializer, not code, we
6220 need to return a definite result now; there's not going to be any
6221 more optimization done. */
6222 if (TREE_SIDE_EFFECTS (arglist
)
6223 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
6224 || POINTER_TYPE_P (TREE_TYPE (arglist
))
6226 return integer_zero_node
;
6231 /* Fold a call to __builtin_expect, if we expect that a comparison against
6232 the argument will fold to a constant. In practice, this means a true
6233 constant or the address of a non-weak symbol. ARGLIST is the argument
6234 list of the call. */
6237 fold_builtin_expect (tree arglist
)
6244 arg
= TREE_VALUE (arglist
);
6246 /* If the argument isn't invariant, then there's nothing we can do. */
6247 if (!TREE_INVARIANT (arg
))
6250 /* If we're looking at an address of a weak decl, then do not fold. */
6253 if (TREE_CODE (inner
) == ADDR_EXPR
)
6257 inner
= TREE_OPERAND (inner
, 0);
6259 while (TREE_CODE (inner
) == COMPONENT_REF
6260 || TREE_CODE (inner
) == ARRAY_REF
);
6261 if (DECL_P (inner
) && DECL_WEAK (inner
))
6265 /* Otherwise, ARG already has the proper type for the return value. */
6269 /* Fold a call to __builtin_classify_type. */
6272 fold_builtin_classify_type (tree arglist
)
6275 return build_int_cst (NULL_TREE
, no_type_class
);
6277 return build_int_cst (NULL_TREE
,
6278 type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
6281 /* Fold a call to __builtin_strlen. */
6284 fold_builtin_strlen (tree arglist
)
6286 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6290 tree len
= c_strlen (TREE_VALUE (arglist
), 0);
6294 /* Convert from the internal "sizetype" type to "size_t". */
6296 len
= fold_convert (size_type_node
, len
);
6304 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6307 fold_builtin_inf (tree type
, int warn
)
6309 REAL_VALUE_TYPE real
;
6311 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
6312 warning ("target format does not support infinity");
6315 return build_real (type
, real
);
6318 /* Fold a call to __builtin_nan or __builtin_nans. */
6321 fold_builtin_nan (tree arglist
, tree type
, int quiet
)
6323 REAL_VALUE_TYPE real
;
6326 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6328 str
= c_getstr (TREE_VALUE (arglist
));
6332 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
6335 return build_real (type
, real
);
6338 /* Return true if the floating point expression T has an integer value.
6339 We also allow +Inf, -Inf and NaN to be considered integer values. */
6342 integer_valued_real_p (tree t
)
6344 switch (TREE_CODE (t
))
6351 case NON_LVALUE_EXPR
:
6352 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6357 return integer_valued_real_p (TREE_OPERAND (t
, 1));
6364 return integer_valued_real_p (TREE_OPERAND (t
, 0))
6365 && integer_valued_real_p (TREE_OPERAND (t
, 1));
6368 return integer_valued_real_p (TREE_OPERAND (t
, 1))
6369 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6372 if (! TREE_CONSTANT_OVERFLOW (t
))
6374 REAL_VALUE_TYPE c
, cint
;
6376 c
= TREE_REAL_CST (t
);
6377 real_trunc (&cint
, TYPE_MODE (TREE_TYPE (t
)), &c
);
6378 return real_identical (&c
, &cint
);
6383 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6384 if (TREE_CODE (type
) == INTEGER_TYPE
)
6386 if (TREE_CODE (type
) == REAL_TYPE
)
6387 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6392 switch (builtin_mathfn_code (t
))
6395 case BUILT_IN_CEILF
:
6396 case BUILT_IN_CEILL
:
6397 case BUILT_IN_FLOOR
:
6398 case BUILT_IN_FLOORF
:
6399 case BUILT_IN_FLOORL
:
6400 case BUILT_IN_NEARBYINT
:
6401 case BUILT_IN_NEARBYINTF
:
6402 case BUILT_IN_NEARBYINTL
:
6404 case BUILT_IN_RINTF
:
6405 case BUILT_IN_RINTL
:
6406 case BUILT_IN_ROUND
:
6407 case BUILT_IN_ROUNDF
:
6408 case BUILT_IN_ROUNDL
:
6409 case BUILT_IN_TRUNC
:
6410 case BUILT_IN_TRUNCF
:
6411 case BUILT_IN_TRUNCL
:
6425 /* EXP is assumed to be builtin call where truncation can be propagated
6426 across (for instance floor((double)f) == (double)floorf (f).
6427 Do the transformation. */
6430 fold_trunc_transparent_mathfn (tree exp
)
6432 tree fndecl
= get_callee_fndecl (exp
);
6433 tree arglist
= TREE_OPERAND (exp
, 1);
6434 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6437 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6440 arg
= TREE_VALUE (arglist
);
6441 /* Integer rounding functions are idempotent. */
6442 if (fcode
== builtin_mathfn_code (arg
))
6445 /* If argument is already integer valued, and we don't need to worry
6446 about setting errno, there's no need to perform rounding. */
6447 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6452 tree arg0
= strip_float_extensions (arg
);
6453 tree ftype
= TREE_TYPE (exp
);
6454 tree newtype
= TREE_TYPE (arg0
);
6457 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6458 && (decl
= mathfn_built_in (newtype
, fcode
)))
6461 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6462 return fold_convert (ftype
,
6463 build_function_call_expr (decl
, arglist
));
6469 /* EXP is assumed to be builtin call which can narrow the FP type of
6470 the argument, for instance lround((double)f) -> lroundf (f). */
6473 fold_fixed_mathfn (tree exp
)
6475 tree fndecl
= get_callee_fndecl (exp
);
6476 tree arglist
= TREE_OPERAND (exp
, 1);
6477 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6480 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6483 arg
= TREE_VALUE (arglist
);
6485 /* If argument is already integer valued, and we don't need to worry
6486 about setting errno, there's no need to perform rounding. */
6487 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6488 return fold (build1 (FIX_TRUNC_EXPR
, TREE_TYPE (exp
), arg
));
6492 tree ftype
= TREE_TYPE (arg
);
6493 tree arg0
= strip_float_extensions (arg
);
6494 tree newtype
= TREE_TYPE (arg0
);
6497 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6498 && (decl
= mathfn_built_in (newtype
, fcode
)))
6501 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6502 return build_function_call_expr (decl
, arglist
);
6508 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6509 is the argument list and TYPE is the return type. Return
6510 NULL_TREE if no if no simplification can be made. */
6513 fold_builtin_cabs (tree arglist
, tree type
)
6517 if (!arglist
|| TREE_CHAIN (arglist
))
6520 arg
= TREE_VALUE (arglist
);
6521 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
6522 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
6525 /* Evaluate cabs of a constant at compile-time. */
6526 if (flag_unsafe_math_optimizations
6527 && TREE_CODE (arg
) == COMPLEX_CST
6528 && TREE_CODE (TREE_REALPART (arg
)) == REAL_CST
6529 && TREE_CODE (TREE_IMAGPART (arg
)) == REAL_CST
6530 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg
))
6531 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg
)))
6533 REAL_VALUE_TYPE r
, i
;
6535 r
= TREE_REAL_CST (TREE_REALPART (arg
));
6536 i
= TREE_REAL_CST (TREE_IMAGPART (arg
));
6538 real_arithmetic (&r
, MULT_EXPR
, &r
, &r
);
6539 real_arithmetic (&i
, MULT_EXPR
, &i
, &i
);
6540 real_arithmetic (&r
, PLUS_EXPR
, &r
, &i
);
6541 if (real_sqrt (&r
, TYPE_MODE (type
), &r
)
6542 || ! flag_trapping_math
)
6543 return build_real (type
, r
);
6546 /* If either part is zero, cabs is fabs of the other. */
6547 if (TREE_CODE (arg
) == COMPLEX_EXPR
6548 && real_zerop (TREE_OPERAND (arg
, 0)))
6549 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 1)));
6550 if (TREE_CODE (arg
) == COMPLEX_EXPR
6551 && real_zerop (TREE_OPERAND (arg
, 1)))
6552 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 0)));
6554 /* Don't do this when optimizing for size. */
6555 if (flag_unsafe_math_optimizations
6556 && optimize
&& !optimize_size
)
6558 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6560 if (sqrtfn
!= NULL_TREE
)
6562 tree rpart
, ipart
, result
, arglist
;
6564 arg
= builtin_save_expr (arg
);
6566 rpart
= fold (build1 (REALPART_EXPR
, type
, arg
));
6567 ipart
= fold (build1 (IMAGPART_EXPR
, type
, arg
));
6569 rpart
= builtin_save_expr (rpart
);
6570 ipart
= builtin_save_expr (ipart
);
6572 result
= fold (build2 (PLUS_EXPR
, type
,
6573 fold (build2 (MULT_EXPR
, type
,
6575 fold (build2 (MULT_EXPR
, type
,
6578 arglist
= build_tree_list (NULL_TREE
, result
);
6579 return build_function_call_expr (sqrtfn
, arglist
);
6586 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
6587 NULL_TREE if no simplification can be made. */
6590 fold_builtin_sqrt (tree arglist
, tree type
)
6593 enum built_in_function fcode
;
6594 tree arg
= TREE_VALUE (arglist
);
6596 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6599 /* Optimize sqrt of constant value. */
6600 if (TREE_CODE (arg
) == REAL_CST
6601 && ! TREE_CONSTANT_OVERFLOW (arg
))
6603 REAL_VALUE_TYPE r
, x
;
6605 x
= TREE_REAL_CST (arg
);
6606 if (real_sqrt (&r
, TYPE_MODE (type
), &x
)
6607 || (!flag_trapping_math
&& !flag_errno_math
))
6608 return build_real (type
, r
);
6611 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6612 fcode
= builtin_mathfn_code (arg
);
6613 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6615 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6616 arg
= fold (build2 (MULT_EXPR
, type
,
6617 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6618 build_real (type
, dconsthalf
)));
6619 arglist
= build_tree_list (NULL_TREE
, arg
);
6620 return build_function_call_expr (expfn
, arglist
);
6623 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
6624 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
6626 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6630 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6632 /* The inner root was either sqrt or cbrt. */
6633 REAL_VALUE_TYPE dconstroot
=
6634 BUILTIN_SQRT_P (fcode
) ? dconsthalf
: dconstthird
;
6636 /* Adjust for the outer root. */
6637 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6638 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6639 tree_root
= build_real (type
, dconstroot
);
6640 arglist
= tree_cons (NULL_TREE
, arg0
,
6641 build_tree_list (NULL_TREE
, tree_root
));
6642 return build_function_call_expr (powfn
, arglist
);
6646 /* Optimize sqrt(pow(x,y)) = pow(x,y*0.5). */
6647 if (flag_unsafe_math_optimizations
6648 && (fcode
== BUILT_IN_POW
6649 || fcode
== BUILT_IN_POWF
6650 || fcode
== BUILT_IN_POWL
))
6652 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6653 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6654 tree arg1
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6655 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
6656 build_real (type
, dconsthalf
)));
6657 arglist
= tree_cons (NULL_TREE
, arg0
,
6658 build_tree_list (NULL_TREE
, narg1
));
6659 return build_function_call_expr (powfn
, arglist
);
6665 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
6666 NULL_TREE if no simplification can be made. */
6668 fold_builtin_cbrt (tree arglist
, tree type
)
6670 tree arg
= TREE_VALUE (arglist
);
6671 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
6673 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6676 /* Optimize cbrt of constant value. */
6677 if (real_zerop (arg
) || real_onep (arg
) || real_minus_onep (arg
))
6680 /* Optimize cbrt(expN(x)) -> expN(x/3). */
6681 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6683 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6684 const REAL_VALUE_TYPE third_trunc
=
6685 real_value_truncate (TYPE_MODE (type
), dconstthird
);
6686 arg
= fold (build2 (MULT_EXPR
, type
,
6687 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6688 build_real (type
, third_trunc
)));
6689 arglist
= build_tree_list (NULL_TREE
, arg
);
6690 return build_function_call_expr (expfn
, arglist
);
6693 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
6694 /* We don't optimize cbrt(cbrt(x)) -> pow(x,1/9) because if
6695 x is negative pow will error but cbrt won't. */
6696 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
6698 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6702 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6704 REAL_VALUE_TYPE dconstroot
= dconstthird
;
6706 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6707 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6708 tree_root
= build_real (type
, dconstroot
);
6709 arglist
= tree_cons (NULL_TREE
, arg0
,
6710 build_tree_list (NULL_TREE
, tree_root
));
6711 return build_function_call_expr (powfn
, arglist
);
6718 /* Fold function call to builtin sin, sinf, or sinl. Return
6719 NULL_TREE if no simplification can be made. */
6721 fold_builtin_sin (tree arglist
)
6723 tree arg
= TREE_VALUE (arglist
);
6725 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6728 /* Optimize sin (0.0) = 0.0. */
6729 if (real_zerop (arg
))
6735 /* Fold function call to builtin cos, cosf, or cosl. Return
6736 NULL_TREE if no simplification can be made. */
6738 fold_builtin_cos (tree arglist
, tree type
, tree fndecl
)
6740 tree arg
= TREE_VALUE (arglist
);
6742 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6745 /* Optimize cos (0.0) = 1.0. */
6746 if (real_zerop (arg
))
6747 return build_real (type
, dconst1
);
6749 /* Optimize cos(-x) into cos (x). */
6750 if (TREE_CODE (arg
) == NEGATE_EXPR
)
6752 tree args
= build_tree_list (NULL_TREE
,
6753 TREE_OPERAND (arg
, 0));
6754 return build_function_call_expr (fndecl
, args
);
6760 /* Fold function call to builtin tan, tanf, or tanl. Return
6761 NULL_TREE if no simplification can be made. */
6763 fold_builtin_tan (tree arglist
)
6765 enum built_in_function fcode
;
6766 tree arg
= TREE_VALUE (arglist
);
6768 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6771 /* Optimize tan(0.0) = 0.0. */
6772 if (real_zerop (arg
))
6775 /* Optimize tan(atan(x)) = x. */
6776 fcode
= builtin_mathfn_code (arg
);
6777 if (flag_unsafe_math_optimizations
6778 && (fcode
== BUILT_IN_ATAN
6779 || fcode
== BUILT_IN_ATANF
6780 || fcode
== BUILT_IN_ATANL
))
6781 return TREE_VALUE (TREE_OPERAND (arg
, 1));
6786 /* Fold function call to builtin atan, atanf, or atanl. Return
6787 NULL_TREE if no simplification can be made. */
6790 fold_builtin_atan (tree arglist
, tree type
)
6793 tree arg
= TREE_VALUE (arglist
);
6795 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6798 /* Optimize atan(0.0) = 0.0. */
6799 if (real_zerop (arg
))
6802 /* Optimize atan(1.0) = pi/4. */
6803 if (real_onep (arg
))
6805 REAL_VALUE_TYPE cst
;
6807 real_convert (&cst
, TYPE_MODE (type
), &dconstpi
);
6808 SET_REAL_EXP (&cst
, REAL_EXP (&cst
) - 2);
6809 return build_real (type
, cst
);
6815 /* Fold function call to builtin trunc, truncf or truncl. Return
6816 NULL_TREE if no simplification can be made. */
6819 fold_builtin_trunc (tree exp
)
6821 tree arglist
= TREE_OPERAND (exp
, 1);
6824 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6827 /* Optimize trunc of constant value. */
6828 arg
= TREE_VALUE (arglist
);
6829 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6831 REAL_VALUE_TYPE r
, x
;
6832 tree type
= TREE_TYPE (exp
);
6834 x
= TREE_REAL_CST (arg
);
6835 real_trunc (&r
, TYPE_MODE (type
), &x
);
6836 return build_real (type
, r
);
6839 return fold_trunc_transparent_mathfn (exp
);
6842 /* Fold function call to builtin floor, floorf or floorl. Return
6843 NULL_TREE if no simplification can be made. */
6846 fold_builtin_floor (tree exp
)
6848 tree arglist
= TREE_OPERAND (exp
, 1);
6851 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6854 /* Optimize floor of constant value. */
6855 arg
= TREE_VALUE (arglist
);
6856 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6860 x
= TREE_REAL_CST (arg
);
6861 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6863 tree type
= TREE_TYPE (exp
);
6866 real_floor (&r
, TYPE_MODE (type
), &x
);
6867 return build_real (type
, r
);
6871 return fold_trunc_transparent_mathfn (exp
);
6874 /* Fold function call to builtin ceil, ceilf or ceill. Return
6875 NULL_TREE if no simplification can be made. */
6878 fold_builtin_ceil (tree exp
)
6880 tree arglist
= TREE_OPERAND (exp
, 1);
6883 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6886 /* Optimize ceil of constant value. */
6887 arg
= TREE_VALUE (arglist
);
6888 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6892 x
= TREE_REAL_CST (arg
);
6893 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6895 tree type
= TREE_TYPE (exp
);
6898 real_ceil (&r
, TYPE_MODE (type
), &x
);
6899 return build_real (type
, r
);
6903 return fold_trunc_transparent_mathfn (exp
);
6906 /* Fold function call to builtin round, roundf or roundl. Return
6907 NULL_TREE if no simplification can be made. */
6910 fold_builtin_round (tree exp
)
6912 tree arglist
= TREE_OPERAND (exp
, 1);
6915 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6918 /* Optimize round of constant value. */
6919 arg
= TREE_VALUE (arglist
);
6920 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6924 x
= TREE_REAL_CST (arg
);
6925 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6927 tree type
= TREE_TYPE (exp
);
6930 real_round (&r
, TYPE_MODE (type
), &x
);
6931 return build_real (type
, r
);
6935 return fold_trunc_transparent_mathfn (exp
);
6938 /* Fold function call to builtin lround, lroundf or lroundl (or the
6939 corresponding long long versions). Return NULL_TREE if no
6940 simplification can be made. */
6943 fold_builtin_lround (tree exp
)
6945 tree arglist
= TREE_OPERAND (exp
, 1);
6948 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6951 /* Optimize lround of constant value. */
6952 arg
= TREE_VALUE (arglist
);
6953 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6955 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
6957 if (! REAL_VALUE_ISNAN (x
) && ! REAL_VALUE_ISINF (x
))
6959 tree itype
= TREE_TYPE (exp
), ftype
= TREE_TYPE (arg
), result
;
6960 HOST_WIDE_INT hi
, lo
;
6963 real_round (&r
, TYPE_MODE (ftype
), &x
);
6964 REAL_VALUE_TO_INT (&lo
, &hi
, r
);
6965 result
= build_int_cst_wide (NULL_TREE
, lo
, hi
);
6966 if (int_fits_type_p (result
, itype
))
6967 return fold_convert (itype
, result
);
6971 return fold_fixed_mathfn (exp
);
6974 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
6975 and their long and long long variants (i.e. ffsl and ffsll).
6976 Return NULL_TREE if no simplification can be made. */
6979 fold_builtin_bitop (tree exp
)
6981 tree fndecl
= get_callee_fndecl (exp
);
6982 tree arglist
= TREE_OPERAND (exp
, 1);
6985 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
6988 /* Optimize for constant argument. */
6989 arg
= TREE_VALUE (arglist
);
6990 if (TREE_CODE (arg
) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6992 HOST_WIDE_INT hi
, width
, result
;
6993 unsigned HOST_WIDE_INT lo
;
6996 type
= TREE_TYPE (arg
);
6997 width
= TYPE_PRECISION (type
);
6998 lo
= TREE_INT_CST_LOW (arg
);
7000 /* Clear all the bits that are beyond the type's precision. */
7001 if (width
> HOST_BITS_PER_WIDE_INT
)
7003 hi
= TREE_INT_CST_HIGH (arg
);
7004 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
7005 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
7010 if (width
< HOST_BITS_PER_WIDE_INT
)
7011 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
7014 switch (DECL_FUNCTION_CODE (fndecl
))
7018 case BUILT_IN_FFSLL
:
7020 result
= exact_log2 (lo
& -lo
) + 1;
7022 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
) + 1;
7029 case BUILT_IN_CLZLL
:
7031 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
7033 result
= width
- floor_log2 (lo
) - 1;
7034 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7040 case BUILT_IN_CTZLL
:
7042 result
= exact_log2 (lo
& -lo
);
7044 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
);
7045 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7049 case BUILT_IN_POPCOUNT
:
7050 case BUILT_IN_POPCOUNTL
:
7051 case BUILT_IN_POPCOUNTLL
:
7054 result
++, lo
&= lo
- 1;
7056 result
++, hi
&= hi
- 1;
7059 case BUILT_IN_PARITY
:
7060 case BUILT_IN_PARITYL
:
7061 case BUILT_IN_PARITYLL
:
7064 result
++, lo
&= lo
- 1;
7066 result
++, hi
&= hi
- 1;
7074 return build_int_cst (TREE_TYPE (exp
), result
);
7080 /* Return true if EXPR is the real constant contained in VALUE. */
7083 real_dconstp (tree expr
, const REAL_VALUE_TYPE
*value
)
7087 return ((TREE_CODE (expr
) == REAL_CST
7088 && ! TREE_CONSTANT_OVERFLOW (expr
)
7089 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), *value
))
7090 || (TREE_CODE (expr
) == COMPLEX_CST
7091 && real_dconstp (TREE_REALPART (expr
), value
)
7092 && real_zerop (TREE_IMAGPART (expr
))));
7095 /* A subroutine of fold_builtin to fold the various logarithmic
7096 functions. EXP is the CALL_EXPR of a call to a builtin logN
7097 function. VALUE is the base of the logN function. */
7100 fold_builtin_logarithm (tree exp
, const REAL_VALUE_TYPE
*value
)
7102 tree arglist
= TREE_OPERAND (exp
, 1);
7104 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7106 tree fndecl
= get_callee_fndecl (exp
);
7107 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7108 tree arg
= TREE_VALUE (arglist
);
7109 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7111 /* Optimize logN(1.0) = 0.0. */
7112 if (real_onep (arg
))
7113 return build_real (type
, dconst0
);
7115 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
7116 exactly, then only do this if flag_unsafe_math_optimizations. */
7117 if (exact_real_truncate (TYPE_MODE (type
), value
)
7118 || flag_unsafe_math_optimizations
)
7120 const REAL_VALUE_TYPE value_truncate
=
7121 real_value_truncate (TYPE_MODE (type
), *value
);
7122 if (real_dconstp (arg
, &value_truncate
))
7123 return build_real (type
, dconst1
);
7126 /* Special case, optimize logN(expN(x)) = x. */
7127 if (flag_unsafe_math_optimizations
7128 && ((value
== &dconste
7129 && (fcode
== BUILT_IN_EXP
7130 || fcode
== BUILT_IN_EXPF
7131 || fcode
== BUILT_IN_EXPL
))
7132 || (value
== &dconst2
7133 && (fcode
== BUILT_IN_EXP2
7134 || fcode
== BUILT_IN_EXP2F
7135 || fcode
== BUILT_IN_EXP2L
))
7136 || (value
== &dconst10
&& (BUILTIN_EXP10_P (fcode
)))))
7137 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7139 /* Optimize logN(func()) for various exponential functions. We
7140 want to determine the value "x" and the power "exponent" in
7141 order to transform logN(x**exponent) into exponent*logN(x). */
7142 if (flag_unsafe_math_optimizations
)
7144 tree exponent
= 0, x
= 0;
7151 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7152 x
= build_real (type
,
7153 real_value_truncate (TYPE_MODE (type
), dconste
));
7154 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7157 case BUILT_IN_EXP2F
:
7158 case BUILT_IN_EXP2L
:
7159 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7160 x
= build_real (type
, dconst2
);
7161 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7163 case BUILT_IN_EXP10
:
7164 case BUILT_IN_EXP10F
:
7165 case BUILT_IN_EXP10L
:
7166 case BUILT_IN_POW10
:
7167 case BUILT_IN_POW10F
:
7168 case BUILT_IN_POW10L
:
7169 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7170 x
= build_real (type
, dconst10
);
7171 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7174 case BUILT_IN_SQRTF
:
7175 case BUILT_IN_SQRTL
:
7176 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7177 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7178 exponent
= build_real (type
, dconsthalf
);
7181 case BUILT_IN_CBRTF
:
7182 case BUILT_IN_CBRTL
:
7183 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7184 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7185 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7191 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7192 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7193 exponent
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
7199 /* Now perform the optimization. */
7203 arglist
= build_tree_list (NULL_TREE
, x
);
7204 logfn
= build_function_call_expr (fndecl
, arglist
);
7205 return fold (build2 (MULT_EXPR
, type
, exponent
, logfn
));
7213 /* Fold a builtin function call to pow, powf, or powl. Return
7214 NULL_TREE if no simplification can be made. */
7216 fold_builtin_pow (tree fndecl
, tree arglist
, tree type
)
7218 enum built_in_function fcode
;
7219 tree arg0
= TREE_VALUE (arglist
);
7220 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7222 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7225 /* Optimize pow(1.0,y) = 1.0. */
7226 if (real_onep (arg0
))
7227 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
7229 if (TREE_CODE (arg1
) == REAL_CST
7230 && ! TREE_CONSTANT_OVERFLOW (arg1
))
7233 c
= TREE_REAL_CST (arg1
);
7235 /* Optimize pow(x,0.0) = 1.0. */
7236 if (REAL_VALUES_EQUAL (c
, dconst0
))
7237 return omit_one_operand (type
, build_real (type
, dconst1
),
7240 /* Optimize pow(x,1.0) = x. */
7241 if (REAL_VALUES_EQUAL (c
, dconst1
))
7244 /* Optimize pow(x,-1.0) = 1.0/x. */
7245 if (REAL_VALUES_EQUAL (c
, dconstm1
))
7246 return fold (build2 (RDIV_EXPR
, type
,
7247 build_real (type
, dconst1
), arg0
));
7249 /* Optimize pow(x,0.5) = sqrt(x). */
7250 if (flag_unsafe_math_optimizations
7251 && REAL_VALUES_EQUAL (c
, dconsthalf
))
7253 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7255 if (sqrtfn
!= NULL_TREE
)
7257 tree arglist
= build_tree_list (NULL_TREE
, arg0
);
7258 return build_function_call_expr (sqrtfn
, arglist
);
7262 /* Attempt to evaluate pow at compile-time. */
7263 if (TREE_CODE (arg0
) == REAL_CST
7264 && ! TREE_CONSTANT_OVERFLOW (arg0
))
7266 REAL_VALUE_TYPE cint
;
7269 n
= real_to_integer (&c
);
7270 real_from_integer (&cint
, VOIDmode
, n
,
7272 if (real_identical (&c
, &cint
))
7277 x
= TREE_REAL_CST (arg0
);
7278 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
7279 if (flag_unsafe_math_optimizations
|| !inexact
)
7280 return build_real (type
, x
);
7285 /* Optimize pow(expN(x),y) = expN(x*y). */
7286 fcode
= builtin_mathfn_code (arg0
);
7287 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
7289 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
7290 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7291 arg
= fold (build2 (MULT_EXPR
, type
, arg
, arg1
));
7292 arglist
= build_tree_list (NULL_TREE
, arg
);
7293 return build_function_call_expr (expfn
, arglist
);
7296 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
7297 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
7299 tree narg0
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7300 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
7301 build_real (type
, dconsthalf
)));
7303 arglist
= tree_cons (NULL_TREE
, narg0
,
7304 build_tree_list (NULL_TREE
, narg1
));
7305 return build_function_call_expr (fndecl
, arglist
);
7308 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
7309 if (flag_unsafe_math_optimizations
7310 && (fcode
== BUILT_IN_POW
7311 || fcode
== BUILT_IN_POWF
7312 || fcode
== BUILT_IN_POWL
))
7314 tree arg00
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7315 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0
, 1)));
7316 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg01
, arg1
));
7317 arglist
= tree_cons (NULL_TREE
, arg00
,
7318 build_tree_list (NULL_TREE
, narg1
));
7319 return build_function_call_expr (fndecl
, arglist
);
7324 /* A subroutine of fold_builtin to fold the various exponent
7325 functions. EXP is the CALL_EXPR of a call to a builtin function.
7326 VALUE is the value which will be raised to a power. */
7329 fold_builtin_exponent (tree exp
, const REAL_VALUE_TYPE
*value
)
7331 tree arglist
= TREE_OPERAND (exp
, 1);
7333 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7335 tree fndecl
= get_callee_fndecl (exp
);
7336 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7337 tree arg
= TREE_VALUE (arglist
);
7339 /* Optimize exp*(0.0) = 1.0. */
7340 if (real_zerop (arg
))
7341 return build_real (type
, dconst1
);
7343 /* Optimize expN(1.0) = N. */
7344 if (real_onep (arg
))
7346 REAL_VALUE_TYPE cst
;
7348 real_convert (&cst
, TYPE_MODE (type
), value
);
7349 return build_real (type
, cst
);
7352 /* Attempt to evaluate expN(integer) at compile-time. */
7353 if (flag_unsafe_math_optimizations
7354 && TREE_CODE (arg
) == REAL_CST
7355 && ! TREE_CONSTANT_OVERFLOW (arg
))
7357 REAL_VALUE_TYPE cint
;
7361 c
= TREE_REAL_CST (arg
);
7362 n
= real_to_integer (&c
);
7363 real_from_integer (&cint
, VOIDmode
, n
,
7365 if (real_identical (&c
, &cint
))
7369 real_powi (&x
, TYPE_MODE (type
), value
, n
);
7370 return build_real (type
, x
);
7374 /* Optimize expN(logN(x)) = x. */
7375 if (flag_unsafe_math_optimizations
)
7377 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7379 if ((value
== &dconste
7380 && (fcode
== BUILT_IN_LOG
7381 || fcode
== BUILT_IN_LOGF
7382 || fcode
== BUILT_IN_LOGL
))
7383 || (value
== &dconst2
7384 && (fcode
== BUILT_IN_LOG2
7385 || fcode
== BUILT_IN_LOG2F
7386 || fcode
== BUILT_IN_LOG2L
))
7387 || (value
== &dconst10
7388 && (fcode
== BUILT_IN_LOG10
7389 || fcode
== BUILT_IN_LOG10F
7390 || fcode
== BUILT_IN_LOG10L
)))
7391 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7398 /* Fold function call to builtin memcpy. Return
7399 NULL_TREE if no simplification can be made. */
7402 fold_builtin_memcpy (tree exp
)
7404 tree arglist
= TREE_OPERAND (exp
, 1);
7405 tree dest
, src
, len
;
7407 if (!validate_arglist (arglist
,
7408 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7411 dest
= TREE_VALUE (arglist
);
7412 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7413 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7415 /* If the LEN parameter is zero, return DEST. */
7416 if (integer_zerop (len
))
7417 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7419 /* If SRC and DEST are the same (and not volatile), return DEST. */
7420 if (operand_equal_p (src
, dest
, 0))
7421 return omit_one_operand (TREE_TYPE (exp
), dest
, len
);
7426 /* Fold function call to builtin mempcpy. Return
7427 NULL_TREE if no simplification can be made. */
7430 fold_builtin_mempcpy (tree exp
)
7432 tree arglist
= TREE_OPERAND (exp
, 1);
7433 tree dest
, src
, len
;
7435 if (!validate_arglist (arglist
,
7436 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7439 dest
= TREE_VALUE (arglist
);
7440 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7441 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7443 /* If the LEN parameter is zero, return DEST. */
7444 if (integer_zerop (len
))
7445 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7447 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
7448 if (operand_equal_p (src
, dest
, 0))
7450 tree temp
= fold_convert (TREE_TYPE (dest
), len
);
7451 temp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, temp
));
7452 return fold_convert (TREE_TYPE (exp
), temp
);
7458 /* Fold function call to builtin memmove. Return
7459 NULL_TREE if no simplification can be made. */
7462 fold_builtin_memmove (tree exp
)
7464 tree arglist
= TREE_OPERAND (exp
, 1);
7465 tree dest
, src
, len
;
7467 if (!validate_arglist (arglist
,
7468 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7471 dest
= TREE_VALUE (arglist
);
7472 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7473 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7475 /* If the LEN parameter is zero, return DEST. */
7476 if (integer_zerop (len
))
7477 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7479 /* If SRC and DEST are the same (and not volatile), return DEST. */
7480 if (operand_equal_p (src
, dest
, 0))
7481 return omit_one_operand (TREE_TYPE (exp
), dest
, len
);
7486 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
7487 the length of the string to be copied. Return NULL_TREE if no
7488 simplification can be made. */
7491 fold_builtin_strcpy (tree exp
, tree len
)
7493 tree arglist
= TREE_OPERAND (exp
, 1);
7496 if (!validate_arglist (arglist
,
7497 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7500 dest
= TREE_VALUE (arglist
);
7501 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7503 /* If SRC and DEST are the same (and not volatile), return DEST. */
7504 if (operand_equal_p (src
, dest
, 0))
7505 return fold_convert (TREE_TYPE (exp
), dest
);
7510 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7516 len
= c_strlen (src
, 1);
7517 if (! len
|| TREE_SIDE_EFFECTS (len
))
7521 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
7522 arglist
= build_tree_list (NULL_TREE
, len
);
7523 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
7524 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
7525 return fold_convert (TREE_TYPE (exp
),
7526 build_function_call_expr (fn
, arglist
));
7529 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
7530 the length of the source string. Return NULL_TREE if no simplification
7534 fold_builtin_strncpy (tree exp
, tree slen
)
7536 tree arglist
= TREE_OPERAND (exp
, 1);
7537 tree dest
, src
, len
, fn
;
7539 if (!validate_arglist (arglist
,
7540 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7543 dest
= TREE_VALUE (arglist
);
7544 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7545 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7547 /* If the LEN parameter is zero, return DEST. */
7548 if (integer_zerop (len
))
7549 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7551 /* We can't compare slen with len as constants below if len is not a
7553 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
7557 slen
= c_strlen (src
, 1);
7559 /* Now, we must be passed a constant src ptr parameter. */
7560 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
7563 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
7565 /* We do not support simplification of this case, though we do
7566 support it when expanding trees into RTL. */
7567 /* FIXME: generate a call to __builtin_memset. */
7568 if (tree_int_cst_lt (slen
, len
))
7571 /* OK transform into builtin memcpy. */
7572 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7575 return fold_convert (TREE_TYPE (exp
),
7576 build_function_call_expr (fn
, arglist
));
7579 /* Fold function call to builtin strchr and strrchr.
7580 Return NULL_TREE if no simplification can be made. */
7583 fold_builtin_strchr (tree exp
, bool actually_strrchr
)
7585 tree arglist
= TREE_OPERAND (exp
, 1);
7586 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7590 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
7593 if (TREE_CODE (s2
) != INTEGER_CST
)
7602 if (target_char_cast (s2
, &c
))
7605 r
= actually_strrchr
? strrchr (p1
, c
) : strchr (p1
, c
);
7608 return build_int_cst (TREE_TYPE (s1
), 0);
7610 /* Return an offset into the constant string argument. */
7611 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
7612 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
7615 if (actually_strrchr
)
7619 if (!integer_zerop (s2
))
7622 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
7626 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
7627 return build_function_call_expr (fn
, arglist
);
7634 /* Fold function call to builtin memcmp. Return
7635 NULL_TREE if no simplification can be made. */
7638 fold_builtin_memcmp (tree arglist
)
7640 tree arg1
, arg2
, len
;
7641 const char *p1
, *p2
;
7643 if (!validate_arglist (arglist
,
7644 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7647 arg1
= TREE_VALUE (arglist
);
7648 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7649 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7651 /* If the LEN parameter is zero, return zero. */
7652 if (integer_zerop (len
))
7653 return omit_two_operands (integer_type_node
, integer_zero_node
,
7656 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7657 if (operand_equal_p (arg1
, arg2
, 0))
7658 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
7660 p1
= c_getstr (arg1
);
7661 p2
= c_getstr (arg2
);
7663 /* If all arguments are constant, and the value of len is not greater
7664 than the lengths of arg1 and arg2, evaluate at compile-time. */
7665 if (host_integerp (len
, 1) && p1
&& p2
7666 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
7667 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
7669 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
7672 return integer_one_node
;
7674 return integer_minus_one_node
;
7676 return integer_zero_node
;
7679 /* If len parameter is one, return an expression corresponding to
7680 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7681 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
7683 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7684 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7685 tree ind1
= fold_convert (integer_type_node
,
7686 build1 (INDIRECT_REF
, cst_uchar_node
,
7687 fold_convert (cst_uchar_ptr_node
,
7689 tree ind2
= fold_convert (integer_type_node
,
7690 build1 (INDIRECT_REF
, cst_uchar_node
,
7691 fold_convert (cst_uchar_ptr_node
,
7693 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
7699 /* Fold function call to builtin strcmp. Return
7700 NULL_TREE if no simplification can be made. */
7703 fold_builtin_strcmp (tree arglist
)
7706 const char *p1
, *p2
;
7708 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7711 arg1
= TREE_VALUE (arglist
);
7712 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7714 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7715 if (operand_equal_p (arg1
, arg2
, 0))
7716 return integer_zero_node
;
7718 p1
= c_getstr (arg1
);
7719 p2
= c_getstr (arg2
);
7723 const int i
= strcmp (p1
, p2
);
7725 return integer_minus_one_node
;
7727 return integer_one_node
;
7729 return integer_zero_node
;
7732 /* If the second arg is "", return *(const unsigned char*)arg1. */
7733 if (p2
&& *p2
== '\0')
7735 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7736 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7737 return fold_convert (integer_type_node
,
7738 build1 (INDIRECT_REF
, cst_uchar_node
,
7739 fold_convert (cst_uchar_ptr_node
,
7743 /* If the first arg is "", return -*(const unsigned char*)arg2. */
7744 if (p1
&& *p1
== '\0')
7746 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7747 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7748 tree temp
= fold_convert (integer_type_node
,
7749 build1 (INDIRECT_REF
, cst_uchar_node
,
7750 fold_convert (cst_uchar_ptr_node
,
7752 return fold (build1 (NEGATE_EXPR
, integer_type_node
, temp
));
7758 /* Fold function call to builtin strncmp. Return
7759 NULL_TREE if no simplification can be made. */
7762 fold_builtin_strncmp (tree arglist
)
7764 tree arg1
, arg2
, len
;
7765 const char *p1
, *p2
;
7767 if (!validate_arglist (arglist
,
7768 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7771 arg1
= TREE_VALUE (arglist
);
7772 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7773 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7775 /* If the LEN parameter is zero, return zero. */
7776 if (integer_zerop (len
))
7777 return omit_two_operands (integer_type_node
, integer_zero_node
,
7780 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7781 if (operand_equal_p (arg1
, arg2
, 0))
7782 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
7784 p1
= c_getstr (arg1
);
7785 p2
= c_getstr (arg2
);
7787 if (host_integerp (len
, 1) && p1
&& p2
)
7789 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
7791 return integer_one_node
;
7793 return integer_minus_one_node
;
7795 return integer_zero_node
;
7798 /* If the second arg is "", and the length is greater than zero,
7799 return *(const unsigned char*)arg1. */
7800 if (p2
&& *p2
== '\0'
7801 && TREE_CODE (len
) == INTEGER_CST
7802 && tree_int_cst_sgn (len
) == 1)
7804 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7805 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7806 return fold_convert (integer_type_node
,
7807 build1 (INDIRECT_REF
, cst_uchar_node
,
7808 fold_convert (cst_uchar_ptr_node
,
7812 /* If the first arg is "", and the length is greater than zero,
7813 return -*(const unsigned char*)arg2. */
7814 if (p1
&& *p1
== '\0'
7815 && TREE_CODE (len
) == INTEGER_CST
7816 && tree_int_cst_sgn (len
) == 1)
7818 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7819 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7820 tree temp
= fold_convert (integer_type_node
,
7821 build1 (INDIRECT_REF
, cst_uchar_node
,
7822 fold_convert (cst_uchar_ptr_node
,
7824 return fold (build1 (NEGATE_EXPR
, integer_type_node
, temp
));
7827 /* If len parameter is one, return an expression corresponding to
7828 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7829 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
7831 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7832 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7833 tree ind1
= fold_convert (integer_type_node
,
7834 build1 (INDIRECT_REF
, cst_uchar_node
,
7835 fold_convert (cst_uchar_ptr_node
,
7837 tree ind2
= fold_convert (integer_type_node
,
7838 build1 (INDIRECT_REF
, cst_uchar_node
,
7839 fold_convert (cst_uchar_ptr_node
,
7841 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
7847 /* Fold function call to builtin signbit, signbitf or signbitl. Return
7848 NULL_TREE if no simplification can be made. */
7851 fold_builtin_signbit (tree exp
)
7853 tree arglist
= TREE_OPERAND (exp
, 1);
7856 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7859 arg
= TREE_VALUE (arglist
);
7861 /* If ARG is a compile-time constant, determine the result. */
7862 if (TREE_CODE (arg
) == REAL_CST
7863 && !TREE_CONSTANT_OVERFLOW (arg
))
7867 c
= TREE_REAL_CST (arg
);
7868 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
7869 return fold_convert (TREE_TYPE (exp
), temp
);
7872 /* If ARG is non-negative, the result is always zero. */
7873 if (tree_expr_nonnegative_p (arg
))
7874 return omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, arg
);
7876 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
7877 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
7878 return fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
7879 build_real (TREE_TYPE (arg
), dconst0
)));
7884 /* Fold function call to builtin copysign, copysignf or copysignl.
7885 Return NULL_TREE if no simplification can be made. */
7888 fold_builtin_copysign (tree arglist
, tree type
)
7892 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7895 arg1
= TREE_VALUE (arglist
);
7896 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7898 /* copysign(X,X) is X. */
7899 if (operand_equal_p (arg1
, arg2
, 0))
7900 return fold_convert (type
, arg1
);
7902 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
7903 if (TREE_CODE (arg1
) == REAL_CST
7904 && TREE_CODE (arg2
) == REAL_CST
7905 && !TREE_CONSTANT_OVERFLOW (arg1
)
7906 && !TREE_CONSTANT_OVERFLOW (arg2
))
7908 REAL_VALUE_TYPE c1
, c2
;
7910 c1
= TREE_REAL_CST (arg1
);
7911 c2
= TREE_REAL_CST (arg2
);
7912 real_copysign (&c1
, &c2
);
7913 return build_real (type
, c1
);
7917 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
7918 Remember to evaluate Y for side-effects. */
7919 if (tree_expr_nonnegative_p (arg2
))
7920 return omit_one_operand (type
,
7921 fold (build1 (ABS_EXPR
, type
, arg1
)),
7927 /* Fold a call to builtin isascii. */
7930 fold_builtin_isascii (tree arglist
)
7932 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7936 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
7937 tree arg
= TREE_VALUE (arglist
);
7939 arg
= build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7940 build_int_cst (NULL_TREE
,
7941 ~ (unsigned HOST_WIDE_INT
) 0x7f));
7942 arg
= fold (build2 (EQ_EXPR
, integer_type_node
,
7943 arg
, integer_zero_node
));
7945 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7952 /* Fold a call to builtin toascii. */
7955 fold_builtin_toascii (tree arglist
)
7957 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7961 /* Transform toascii(c) -> (c & 0x7f). */
7962 tree arg
= TREE_VALUE (arglist
);
7964 return fold (build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7965 build_int_cst (NULL_TREE
, 0x7f)));
7969 /* Fold a call to builtin isdigit. */
7972 fold_builtin_isdigit (tree arglist
)
7974 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7978 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
7979 /* According to the C standard, isdigit is unaffected by locale. */
7980 tree arg
= TREE_VALUE (arglist
);
7981 arg
= fold_convert (unsigned_type_node
, arg
);
7982 arg
= build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
7983 build_int_cst (unsigned_type_node
, TARGET_DIGIT0
));
7984 arg
= build2 (LE_EXPR
, integer_type_node
, arg
,
7985 build_int_cst (unsigned_type_node
, 9));
7987 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7994 /* Fold a call to fabs, fabsf or fabsl. */
7997 fold_builtin_fabs (tree arglist
, tree type
)
8001 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8004 arg
= TREE_VALUE (arglist
);
8005 if (TREE_CODE (arg
) == REAL_CST
)
8006 return fold_abs_const (arg
, type
);
8007 return fold (build1 (ABS_EXPR
, type
, arg
));
8010 /* Fold a call to abs, labs, llabs or imaxabs. */
8013 fold_builtin_abs (tree arglist
, tree type
)
8017 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8020 arg
= TREE_VALUE (arglist
);
8021 if (TREE_CODE (arg
) == INTEGER_CST
)
8022 return fold_abs_const (arg
, type
);
8023 return fold (build1 (ABS_EXPR
, type
, arg
));
8026 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8027 EXP is the CALL_EXPR for the call. */
8030 fold_builtin_classify (tree exp
, int builtin_index
)
8032 tree fndecl
= get_callee_fndecl (exp
);
8033 tree arglist
= TREE_OPERAND (exp
, 1);
8034 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8038 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8040 /* Check that we have exactly one argument. */
8043 error ("too few arguments to function %qs",
8044 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8045 return error_mark_node
;
8047 else if (TREE_CHAIN (arglist
) != 0)
8049 error ("too many arguments to function %qs",
8050 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8051 return error_mark_node
;
8055 error ("non-floating-point argument to function %qs",
8056 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8057 return error_mark_node
;
8061 arg
= TREE_VALUE (arglist
);
8062 switch (builtin_index
)
8064 case BUILT_IN_ISINF
:
8065 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8066 return omit_one_operand (type
, integer_zero_node
, arg
);
8068 if (TREE_CODE (arg
) == REAL_CST
)
8070 r
= TREE_REAL_CST (arg
);
8071 if (real_isinf (&r
))
8072 return real_compare (GT_EXPR
, &r
, &dconst0
)
8073 ? integer_one_node
: integer_minus_one_node
;
8075 return integer_zero_node
;
8080 case BUILT_IN_FINITE
:
8081 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
)))
8082 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8083 return omit_one_operand (type
, integer_zero_node
, arg
);
8085 if (TREE_CODE (arg
) == REAL_CST
)
8087 r
= TREE_REAL_CST (arg
);
8088 return real_isinf (&r
) || real_isnan (&r
)
8089 ? integer_zero_node
: integer_one_node
;
8094 case BUILT_IN_ISNAN
:
8095 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
))))
8096 return omit_one_operand (type
, integer_zero_node
, arg
);
8098 if (TREE_CODE (arg
) == REAL_CST
)
8100 r
= TREE_REAL_CST (arg
);
8101 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
8104 arg
= builtin_save_expr (arg
);
8105 return fold (build2 (UNORDERED_EXPR
, type
, arg
, arg
));
8112 /* Fold a call to an unordered comparison function such as
8113 __builtin_isgreater(). EXP is the CALL_EXPR for the call.
8114 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8115 the opposite of the desired result. UNORDERED_CODE is used
8116 for modes that can hold NaNs and ORDERED_CODE is used for
8120 fold_builtin_unordered_cmp (tree exp
,
8121 enum tree_code unordered_code
,
8122 enum tree_code ordered_code
)
8124 tree fndecl
= get_callee_fndecl (exp
);
8125 tree arglist
= TREE_OPERAND (exp
, 1);
8126 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8127 enum tree_code code
;
8130 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8132 enum tree_code code0
, code1
;
8136 /* Check that we have exactly two arguments. */
8137 if (arglist
== 0 || TREE_CHAIN (arglist
) == 0)
8139 error ("too few arguments to function %qs",
8140 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8141 return error_mark_node
;
8143 else if (TREE_CHAIN (TREE_CHAIN (arglist
)) != 0)
8145 error ("too many arguments to function %qs",
8146 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8147 return error_mark_node
;
8150 arg0
= TREE_VALUE (arglist
);
8151 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
8153 type0
= TREE_TYPE (arg0
);
8154 type1
= TREE_TYPE (arg1
);
8156 code0
= TREE_CODE (type0
);
8157 code1
= TREE_CODE (type1
);
8159 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8160 /* Choose the wider of two real types. */
8161 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
8163 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8165 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
8169 error ("non-floating-point argument to function %qs",
8170 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8171 return error_mark_node
;
8174 arg0
= fold_convert (cmp_type
, arg0
);
8175 arg1
= fold_convert (cmp_type
, arg1
);
8179 arg0
= TREE_VALUE (arglist
);
8180 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
8183 if (unordered_code
== UNORDERED_EXPR
)
8185 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
8186 return omit_two_operands (type
, integer_zero_node
, arg0
, arg1
);
8187 return fold (build2 (UNORDERED_EXPR
, type
, arg0
, arg1
));
8190 code
= MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
8192 return fold (build1 (TRUTH_NOT_EXPR
, type
,
8193 fold (build2 (code
, type
, arg0
, arg1
))));
8196 /* Used by constant folding to simplify calls to builtin functions. EXP is
8197 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
8198 result of the function call is ignored. This function returns NULL_TREE
8199 if no simplification was possible. */
8202 fold_builtin_1 (tree exp
, bool ignore
)
8204 tree fndecl
= get_callee_fndecl (exp
);
8205 tree arglist
= TREE_OPERAND (exp
, 1);
8206 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8208 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
8209 return targetm
.fold_builtin (exp
, ignore
);
8211 switch (DECL_FUNCTION_CODE (fndecl
))
8213 case BUILT_IN_CONSTANT_P
:
8214 return fold_builtin_constant_p (arglist
);
8216 case BUILT_IN_EXPECT
:
8217 return fold_builtin_expect (arglist
);
8219 case BUILT_IN_CLASSIFY_TYPE
:
8220 return fold_builtin_classify_type (arglist
);
8222 case BUILT_IN_STRLEN
:
8223 return fold_builtin_strlen (arglist
);
8226 case BUILT_IN_FABSF
:
8227 case BUILT_IN_FABSL
:
8228 return fold_builtin_fabs (arglist
, type
);
8232 case BUILT_IN_LLABS
:
8233 case BUILT_IN_IMAXABS
:
8234 return fold_builtin_abs (arglist
, type
);
8237 case BUILT_IN_CONJF
:
8238 case BUILT_IN_CONJL
:
8239 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8240 return fold (build1 (CONJ_EXPR
, type
, TREE_VALUE (arglist
)));
8243 case BUILT_IN_CREAL
:
8244 case BUILT_IN_CREALF
:
8245 case BUILT_IN_CREALL
:
8246 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8247 return non_lvalue (fold (build1 (REALPART_EXPR
, type
,
8248 TREE_VALUE (arglist
))));
8251 case BUILT_IN_CIMAG
:
8252 case BUILT_IN_CIMAGF
:
8253 case BUILT_IN_CIMAGL
:
8254 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8255 return non_lvalue (fold (build1 (IMAGPART_EXPR
, type
,
8256 TREE_VALUE (arglist
))));
8260 case BUILT_IN_CABSF
:
8261 case BUILT_IN_CABSL
:
8262 return fold_builtin_cabs (arglist
, type
);
8265 case BUILT_IN_SQRTF
:
8266 case BUILT_IN_SQRTL
:
8267 return fold_builtin_sqrt (arglist
, type
);
8270 case BUILT_IN_CBRTF
:
8271 case BUILT_IN_CBRTL
:
8272 return fold_builtin_cbrt (arglist
, type
);
8277 return fold_builtin_sin (arglist
);
8282 return fold_builtin_cos (arglist
, type
, fndecl
);
8287 return fold_builtin_exponent (exp
, &dconste
);
8290 case BUILT_IN_EXP2F
:
8291 case BUILT_IN_EXP2L
:
8292 return fold_builtin_exponent (exp
, &dconst2
);
8294 case BUILT_IN_EXP10
:
8295 case BUILT_IN_EXP10F
:
8296 case BUILT_IN_EXP10L
:
8297 case BUILT_IN_POW10
:
8298 case BUILT_IN_POW10F
:
8299 case BUILT_IN_POW10L
:
8300 return fold_builtin_exponent (exp
, &dconst10
);
8305 return fold_builtin_logarithm (exp
, &dconste
);
8308 case BUILT_IN_LOG2F
:
8309 case BUILT_IN_LOG2L
:
8310 return fold_builtin_logarithm (exp
, &dconst2
);
8312 case BUILT_IN_LOG10
:
8313 case BUILT_IN_LOG10F
:
8314 case BUILT_IN_LOG10L
:
8315 return fold_builtin_logarithm (exp
, &dconst10
);
8320 return fold_builtin_tan (arglist
);
8323 case BUILT_IN_ATANF
:
8324 case BUILT_IN_ATANL
:
8325 return fold_builtin_atan (arglist
, type
);
8330 return fold_builtin_pow (fndecl
, arglist
, type
);
8335 return fold_builtin_inf (type
, true);
8337 case BUILT_IN_HUGE_VAL
:
8338 case BUILT_IN_HUGE_VALF
:
8339 case BUILT_IN_HUGE_VALL
:
8340 return fold_builtin_inf (type
, false);
8345 return fold_builtin_nan (arglist
, type
, true);
8348 case BUILT_IN_NANSF
:
8349 case BUILT_IN_NANSL
:
8350 return fold_builtin_nan (arglist
, type
, false);
8352 case BUILT_IN_FLOOR
:
8353 case BUILT_IN_FLOORF
:
8354 case BUILT_IN_FLOORL
:
8355 return fold_builtin_floor (exp
);
8358 case BUILT_IN_CEILF
:
8359 case BUILT_IN_CEILL
:
8360 return fold_builtin_ceil (exp
);
8362 case BUILT_IN_TRUNC
:
8363 case BUILT_IN_TRUNCF
:
8364 case BUILT_IN_TRUNCL
:
8365 return fold_builtin_trunc (exp
);
8367 case BUILT_IN_ROUND
:
8368 case BUILT_IN_ROUNDF
:
8369 case BUILT_IN_ROUNDL
:
8370 return fold_builtin_round (exp
);
8372 case BUILT_IN_NEARBYINT
:
8373 case BUILT_IN_NEARBYINTF
:
8374 case BUILT_IN_NEARBYINTL
:
8376 case BUILT_IN_RINTF
:
8377 case BUILT_IN_RINTL
:
8378 return fold_trunc_transparent_mathfn (exp
);
8380 case BUILT_IN_LROUND
:
8381 case BUILT_IN_LROUNDF
:
8382 case BUILT_IN_LROUNDL
:
8383 case BUILT_IN_LLROUND
:
8384 case BUILT_IN_LLROUNDF
:
8385 case BUILT_IN_LLROUNDL
:
8386 return fold_builtin_lround (exp
);
8388 case BUILT_IN_LRINT
:
8389 case BUILT_IN_LRINTF
:
8390 case BUILT_IN_LRINTL
:
8391 case BUILT_IN_LLRINT
:
8392 case BUILT_IN_LLRINTF
:
8393 case BUILT_IN_LLRINTL
:
8394 return fold_fixed_mathfn (exp
);
8398 case BUILT_IN_FFSLL
:
8401 case BUILT_IN_CLZLL
:
8404 case BUILT_IN_CTZLL
:
8405 case BUILT_IN_POPCOUNT
:
8406 case BUILT_IN_POPCOUNTL
:
8407 case BUILT_IN_POPCOUNTLL
:
8408 case BUILT_IN_PARITY
:
8409 case BUILT_IN_PARITYL
:
8410 case BUILT_IN_PARITYLL
:
8411 return fold_builtin_bitop (exp
);
8413 case BUILT_IN_MEMCPY
:
8414 return fold_builtin_memcpy (exp
);
8416 case BUILT_IN_MEMPCPY
:
8417 return fold_builtin_mempcpy (exp
);
8419 case BUILT_IN_MEMMOVE
:
8420 return fold_builtin_memmove (exp
);
8422 case BUILT_IN_STRCPY
:
8423 return fold_builtin_strcpy (exp
, NULL_TREE
);
8425 case BUILT_IN_STRNCPY
:
8426 return fold_builtin_strncpy (exp
, NULL_TREE
);
8428 case BUILT_IN_INDEX
:
8429 case BUILT_IN_STRCHR
:
8430 return fold_builtin_strchr (exp
, false);
8432 case BUILT_IN_RINDEX
:
8433 case BUILT_IN_STRRCHR
:
8434 return fold_builtin_strchr (exp
, true);
8436 case BUILT_IN_MEMCMP
:
8437 return fold_builtin_memcmp (arglist
);
8439 case BUILT_IN_STRCMP
:
8440 return fold_builtin_strcmp (arglist
);
8442 case BUILT_IN_STRNCMP
:
8443 return fold_builtin_strncmp (arglist
);
8445 case BUILT_IN_SIGNBIT
:
8446 case BUILT_IN_SIGNBITF
:
8447 case BUILT_IN_SIGNBITL
:
8448 return fold_builtin_signbit (exp
);
8450 case BUILT_IN_ISASCII
:
8451 return fold_builtin_isascii (arglist
);
8453 case BUILT_IN_TOASCII
:
8454 return fold_builtin_toascii (arglist
);
8456 case BUILT_IN_ISDIGIT
:
8457 return fold_builtin_isdigit (arglist
);
8459 case BUILT_IN_COPYSIGN
:
8460 case BUILT_IN_COPYSIGNF
:
8461 case BUILT_IN_COPYSIGNL
:
8462 return fold_builtin_copysign (arglist
, type
);
8464 case BUILT_IN_FINITE
:
8465 case BUILT_IN_FINITEF
:
8466 case BUILT_IN_FINITEL
:
8467 return fold_builtin_classify (exp
, BUILT_IN_FINITE
);
8469 case BUILT_IN_ISINF
:
8470 case BUILT_IN_ISINFF
:
8471 case BUILT_IN_ISINFL
:
8472 return fold_builtin_classify (exp
, BUILT_IN_ISINF
);
8474 case BUILT_IN_ISNAN
:
8475 case BUILT_IN_ISNANF
:
8476 case BUILT_IN_ISNANL
:
8477 return fold_builtin_classify (exp
, BUILT_IN_ISNAN
);
8479 case BUILT_IN_ISGREATER
:
8480 return fold_builtin_unordered_cmp (exp
, UNLE_EXPR
, LE_EXPR
);
8481 case BUILT_IN_ISGREATEREQUAL
:
8482 return fold_builtin_unordered_cmp (exp
, UNLT_EXPR
, LT_EXPR
);
8483 case BUILT_IN_ISLESS
:
8484 return fold_builtin_unordered_cmp (exp
, UNGE_EXPR
, GE_EXPR
);
8485 case BUILT_IN_ISLESSEQUAL
:
8486 return fold_builtin_unordered_cmp (exp
, UNGT_EXPR
, GT_EXPR
);
8487 case BUILT_IN_ISLESSGREATER
:
8488 return fold_builtin_unordered_cmp (exp
, UNEQ_EXPR
, EQ_EXPR
);
8489 case BUILT_IN_ISUNORDERED
:
8490 return fold_builtin_unordered_cmp (exp
, UNORDERED_EXPR
, NOP_EXPR
);
8492 case BUILT_IN_FPUTS
:
8493 return fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8495 case BUILT_IN_FPUTS_UNLOCKED
:
8496 return fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8505 /* A wrapper function for builtin folding that prevents warnings for
8506 "statement without effect" and the like, caused by removing the
8507 call node earlier than the warning is generated. */
8510 fold_builtin (tree exp
, bool ignore
)
8512 exp
= fold_builtin_1 (exp
, ignore
);
8515 /* ??? Don't clobber shared nodes such as integer_zero_node. */
8516 if (CONSTANT_CLASS_P (exp
))
8517 exp
= build1 (NOP_EXPR
, TREE_TYPE (exp
), exp
);
8518 TREE_NO_WARNING (exp
) = 1;
8523 /* Conveniently construct a function call expression. */
8526 build_function_call_expr (tree fn
, tree arglist
)
8530 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
8531 call_expr
= build3 (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
8532 call_expr
, arglist
, NULL_TREE
);
8533 return fold (call_expr
);
8536 /* This function validates the types of a function call argument list
8537 represented as a tree chain of parameters against a specified list
8538 of tree_codes. If the last specifier is a 0, that represents an
8539 ellipses, otherwise the last specifier must be a VOID_TYPE. */
8542 validate_arglist (tree arglist
, ...)
8544 enum tree_code code
;
8548 va_start (ap
, arglist
);
8552 code
= va_arg (ap
, enum tree_code
);
8556 /* This signifies an ellipses, any further arguments are all ok. */
8560 /* This signifies an endlink, if no arguments remain, return
8561 true, otherwise return false. */
8565 /* If no parameters remain or the parameter's code does not
8566 match the specified code, return false. Otherwise continue
8567 checking any remaining arguments. */
8569 || code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
8573 arglist
= TREE_CHAIN (arglist
);
8577 /* We need gotos here since we can only have one VA_CLOSE in a
8585 /* Default target-specific builtin expander that does nothing. */
8588 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
8589 rtx target ATTRIBUTE_UNUSED
,
8590 rtx subtarget ATTRIBUTE_UNUSED
,
8591 enum machine_mode mode ATTRIBUTE_UNUSED
,
8592 int ignore ATTRIBUTE_UNUSED
)
8597 /* Returns true is EXP represents data that would potentially reside
8598 in a readonly section. */
8601 readonly_data_expr (tree exp
)
8605 if (TREE_CODE (exp
) != ADDR_EXPR
)
8608 exp
= get_base_address (TREE_OPERAND (exp
, 0));
8612 /* Make sure we call decl_readonly_section only for trees it
8613 can handle (since it returns true for everything it doesn't
8615 if (TREE_CODE (exp
) == STRING_CST
8616 || TREE_CODE (exp
) == CONSTRUCTOR
8617 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
8618 return decl_readonly_section (exp
, 0);
8623 /* Front-end to the simplify_builtin_XXX routines.
8625 EXP is a call to a builtin function. If possible try to simplify
8626 that into a constant, expression or call to a more efficient
8629 If IGNORE is nonzero, then the result of this builtin function
8632 If simplification is possible, return the simplified tree, otherwise
8633 return NULL_TREE. */
8636 simplify_builtin (tree exp
, int ignore
)
8638 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
8639 tree arglist
= TREE_OPERAND (exp
, 1);
8640 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
8645 case BUILT_IN_FPUTS
:
8646 val
= fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8648 case BUILT_IN_FPUTS_UNLOCKED
:
8649 val
= fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8651 case BUILT_IN_STRSTR
:
8652 val
= simplify_builtin_strstr (arglist
);
8654 case BUILT_IN_STRCAT
:
8655 val
= simplify_builtin_strcat (arglist
);
8657 case BUILT_IN_STRNCAT
:
8658 val
= simplify_builtin_strncat (arglist
);
8660 case BUILT_IN_STRSPN
:
8661 val
= simplify_builtin_strspn (arglist
);
8663 case BUILT_IN_STRCSPN
:
8664 val
= simplify_builtin_strcspn (arglist
);
8666 case BUILT_IN_STRCHR
:
8667 case BUILT_IN_INDEX
:
8668 val
= simplify_builtin_strchr (arglist
);
8670 case BUILT_IN_STRRCHR
:
8671 case BUILT_IN_RINDEX
:
8672 val
= simplify_builtin_strrchr (arglist
);
8674 case BUILT_IN_STRCPY
:
8675 val
= fold_builtin_strcpy (exp
, NULL_TREE
);
8677 case BUILT_IN_STRNCPY
:
8678 val
= fold_builtin_strncpy (exp
, NULL_TREE
);
8680 case BUILT_IN_STRCMP
:
8681 val
= fold_builtin_strcmp (arglist
);
8683 case BUILT_IN_STRNCMP
:
8684 val
= fold_builtin_strncmp (arglist
);
8686 case BUILT_IN_STRPBRK
:
8687 val
= simplify_builtin_strpbrk (arglist
);
8690 case BUILT_IN_MEMCMP
:
8691 val
= fold_builtin_memcmp (arglist
);
8693 case BUILT_IN_VA_START
:
8694 simplify_builtin_va_start (arglist
);
8697 case BUILT_IN_SPRINTF
:
8698 val
= simplify_builtin_sprintf (arglist
, ignore
);
8700 case BUILT_IN_CONSTANT_P
:
8701 val
= fold_builtin_constant_p (arglist
);
8702 /* Gimplification will pull the CALL_EXPR for the builtin out of
8703 an if condition. When not optimizing, we'll not CSE it back.
8704 To avoid link error types of regressions, return false now. */
8705 if (!val
&& !optimize
)
8706 val
= integer_zero_node
;
8714 val
= fold_convert (TREE_TYPE (exp
), val
);
8718 /* Simplify a call to the strstr builtin.
8720 Return 0 if no simplification was possible, otherwise return the
8721 simplified form of the call as a tree.
8723 The simplified form may be a constant or other expression which
8724 computes the same value, but in a more efficient manner (including
8725 calls to other builtin functions).
8727 The call may contain arguments which need to be evaluated, but
8728 which are not useful to determine the result of the call. In
8729 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8730 COMPOUND_EXPR will be an argument which must be evaluated.
8731 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8732 COMPOUND_EXPR in the chain will contain the tree for the simplified
8733 form of the builtin function call. */
8736 simplify_builtin_strstr (tree arglist
)
8738 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8742 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8744 const char *p1
, *p2
;
8753 const char *r
= strstr (p1
, p2
);
8756 return build_int_cst (TREE_TYPE (s1
), 0);
8758 /* Return an offset into the constant string argument. */
8759 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8760 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8769 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8773 /* New argument list transforming strstr(s1, s2) to
8774 strchr(s1, s2[0]). */
8775 arglist
= build_tree_list (NULL_TREE
,
8776 build_int_cst (NULL_TREE
, p2
[0]));
8777 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8778 return build_function_call_expr (fn
, arglist
);
8782 /* Simplify a call to the strstr builtin.
8784 Return 0 if no simplification was possible, otherwise return the
8785 simplified form of the call as a tree.
8787 The simplified form may be a constant or other expression which
8788 computes the same value, but in a more efficient manner (including
8789 calls to other builtin functions).
8791 The call may contain arguments which need to be evaluated, but
8792 which are not useful to determine the result of the call. In
8793 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8794 COMPOUND_EXPR will be an argument which must be evaluated.
8795 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8796 COMPOUND_EXPR in the chain will contain the tree for the simplified
8797 form of the builtin function call. */
8800 simplify_builtin_strchr (tree arglist
)
8802 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8806 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8809 if (TREE_CODE (s2
) != INTEGER_CST
)
8818 if (target_char_cast (s2
, &c
))
8824 return build_int_cst (TREE_TYPE (s1
), 0);
8826 /* Return an offset into the constant string argument. */
8827 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8828 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8831 /* FIXME: Should use here strchrM optab so that ports can optimize
8837 /* Simplify a call to the strrchr builtin.
8839 Return 0 if no simplification was possible, otherwise return the
8840 simplified form of the call as a tree.
8842 The simplified form may be a constant or other expression which
8843 computes the same value, but in a more efficient manner (including
8844 calls to other builtin functions).
8846 The call may contain arguments which need to be evaluated, but
8847 which are not useful to determine the result of the call. In
8848 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8849 COMPOUND_EXPR will be an argument which must be evaluated.
8850 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8851 COMPOUND_EXPR in the chain will contain the tree for the simplified
8852 form of the builtin function call. */
8855 simplify_builtin_strrchr (tree arglist
)
8857 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8861 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8865 if (TREE_CODE (s2
) != INTEGER_CST
)
8874 if (target_char_cast (s2
, &c
))
8877 r
= strrchr (p1
, c
);
8880 return build_int_cst (TREE_TYPE (s1
), 0);
8882 /* Return an offset into the constant string argument. */
8883 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8884 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8887 if (! integer_zerop (s2
))
8890 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8894 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
8895 return build_function_call_expr (fn
, arglist
);
8899 /* Simplify a call to the strpbrk builtin.
8901 Return 0 if no simplification was possible, otherwise return the
8902 simplified form of the call as a tree.
8904 The simplified form may be a constant or other expression which
8905 computes the same value, but in a more efficient manner (including
8906 calls to other builtin functions).
8908 The call may contain arguments which need to be evaluated, but
8909 which are not useful to determine the result of the call. In
8910 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8911 COMPOUND_EXPR will be an argument which must be evaluated.
8912 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8913 COMPOUND_EXPR in the chain will contain the tree for the simplified
8914 form of the builtin function call. */
8917 simplify_builtin_strpbrk (tree arglist
)
8919 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8923 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8925 const char *p1
, *p2
;
8934 const char *r
= strpbrk (p1
, p2
);
8937 return build_int_cst (TREE_TYPE (s1
), 0);
8939 /* Return an offset into the constant string argument. */
8940 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8941 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8945 /* strpbrk(x, "") == NULL.
8946 Evaluate and ignore s1 in case it had side-effects. */
8947 return omit_one_operand (TREE_TYPE (s1
), integer_zero_node
, s1
);
8950 return 0; /* Really call strpbrk. */
8952 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8956 /* New argument list transforming strpbrk(s1, s2) to
8957 strchr(s1, s2[0]). */
8958 arglist
= build_tree_list (NULL_TREE
,
8959 build_int_cst (NULL_TREE
, p2
[0]));
8960 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8961 return build_function_call_expr (fn
, arglist
);
8965 /* Simplify a call to the strcat builtin.
8967 Return 0 if no simplification was possible, otherwise return the
8968 simplified form of the call as a tree.
8970 The simplified form may be a constant or other expression which
8971 computes the same value, but in a more efficient manner (including
8972 calls to other builtin functions).
8974 The call may contain arguments which need to be evaluated, but
8975 which are not useful to determine the result of the call. In
8976 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8977 COMPOUND_EXPR will be an argument which must be evaluated.
8978 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8979 COMPOUND_EXPR in the chain will contain the tree for the simplified
8980 form of the builtin function call. */
8983 simplify_builtin_strcat (tree arglist
)
8985 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8989 tree dst
= TREE_VALUE (arglist
),
8990 src
= TREE_VALUE (TREE_CHAIN (arglist
));
8991 const char *p
= c_getstr (src
);
8993 /* If the string length is zero, return the dst parameter. */
8994 if (p
&& *p
== '\0')
9001 /* Simplify a call to the strncat builtin.
9003 Return 0 if no simplification was possible, otherwise return the
9004 simplified form of the call as a tree.
9006 The simplified form may be a constant or other expression which
9007 computes the same value, but in a more efficient manner (including
9008 calls to other builtin functions).
9010 The call may contain arguments which need to be evaluated, but
9011 which are not useful to determine the result of the call. In
9012 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9013 COMPOUND_EXPR will be an argument which must be evaluated.
9014 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9015 COMPOUND_EXPR in the chain will contain the tree for the simplified
9016 form of the builtin function call. */
9019 simplify_builtin_strncat (tree arglist
)
9021 if (!validate_arglist (arglist
,
9022 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9026 tree dst
= TREE_VALUE (arglist
);
9027 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
9028 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9029 const char *p
= c_getstr (src
);
9031 /* If the requested length is zero, or the src parameter string
9032 length is zero, return the dst parameter. */
9033 if (integer_zerop (len
) || (p
&& *p
== '\0'))
9034 return omit_two_operands (TREE_TYPE (dst
), dst
, src
, len
);
9036 /* If the requested len is greater than or equal to the string
9037 length, call strcat. */
9038 if (TREE_CODE (len
) == INTEGER_CST
&& p
9039 && compare_tree_int (len
, strlen (p
)) >= 0)
9042 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
9043 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
9045 /* If the replacement _DECL isn't initialized, don't do the
9050 return build_function_call_expr (fn
, newarglist
);
9056 /* Simplify a call to the strspn builtin.
9058 Return 0 if no simplification was possible, otherwise return the
9059 simplified form of the call as a tree.
9061 The simplified form may be a constant or other expression which
9062 computes the same value, but in a more efficient manner (including
9063 calls to other builtin functions).
9065 The call may contain arguments which need to be evaluated, but
9066 which are not useful to determine the result of the call. In
9067 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9068 COMPOUND_EXPR will be an argument which must be evaluated.
9069 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9070 COMPOUND_EXPR in the chain will contain the tree for the simplified
9071 form of the builtin function call. */
9074 simplify_builtin_strspn (tree arglist
)
9076 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9080 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9081 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9083 /* If both arguments are constants, evaluate at compile-time. */
9086 const size_t r
= strspn (p1
, p2
);
9087 return size_int (r
);
9090 /* If either argument is "", return 0. */
9091 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
9092 /* Evaluate and ignore both arguments in case either one has
9094 return omit_two_operands (integer_type_node
, integer_zero_node
,
9100 /* Simplify a call to the strcspn builtin.
9102 Return 0 if no simplification was possible, otherwise return the
9103 simplified form of the call as a tree.
9105 The simplified form may be a constant or other expression which
9106 computes the same value, but in a more efficient manner (including
9107 calls to other builtin functions).
9109 The call may contain arguments which need to be evaluated, but
9110 which are not useful to determine the result of the call. In
9111 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9112 COMPOUND_EXPR will be an argument which must be evaluated.
9113 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9114 COMPOUND_EXPR in the chain will contain the tree for the simplified
9115 form of the builtin function call. */
9118 simplify_builtin_strcspn (tree arglist
)
9120 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9124 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9125 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9127 /* If both arguments are constants, evaluate at compile-time. */
9130 const size_t r
= strcspn (p1
, p2
);
9131 return size_int (r
);
9134 /* If the first argument is "", return 0. */
9135 if (p1
&& *p1
== '\0')
9137 /* Evaluate and ignore argument s2 in case it has
9139 return omit_one_operand (integer_type_node
,
9140 integer_zero_node
, s2
);
9143 /* If the second argument is "", return __builtin_strlen(s1). */
9144 if (p2
&& *p2
== '\0')
9146 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
9147 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
9149 /* If the replacement _DECL isn't initialized, don't do the
9154 return build_function_call_expr (fn
, newarglist
);
9160 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
9161 by the builtin will be ignored. UNLOCKED is true is true if this
9162 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
9163 the known length of the string. Return NULL_TREE if no simplification
9167 fold_builtin_fputs (tree arglist
, bool ignore
, bool unlocked
, tree len
)
9170 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
9171 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
9172 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
9173 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
9175 /* If the return value is used, or the replacement _DECL isn't
9176 initialized, don't do the transformation. */
9177 if (!ignore
|| !fn_fputc
|| !fn_fwrite
)
9180 /* Verify the arguments in the original call. */
9181 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9185 len
= c_strlen (TREE_VALUE (arglist
), 0);
9187 /* Get the length of the string passed to fputs. If the length
9188 can't be determined, punt. */
9190 || TREE_CODE (len
) != INTEGER_CST
)
9193 switch (compare_tree_int (len
, 1))
9195 case -1: /* length is 0, delete the call entirely . */
9196 return omit_one_operand (integer_type_node
, integer_zero_node
,
9197 TREE_VALUE (TREE_CHAIN (arglist
)));
9199 case 0: /* length is 1, call fputc. */
9201 const char *p
= c_getstr (TREE_VALUE (arglist
));
9205 /* New argument list transforming fputs(string, stream) to
9206 fputc(string[0], stream). */
9207 arglist
= build_tree_list (NULL_TREE
,
9208 TREE_VALUE (TREE_CHAIN (arglist
)));
9209 arglist
= tree_cons (NULL_TREE
,
9210 build_int_cst (NULL_TREE
, p
[0]),
9217 case 1: /* length is greater than 1, call fwrite. */
9221 /* If optimizing for size keep fputs. */
9224 string_arg
= TREE_VALUE (arglist
);
9225 /* New argument list transforming fputs(string, stream) to
9226 fwrite(string, 1, len, stream). */
9227 arglist
= build_tree_list (NULL_TREE
,
9228 TREE_VALUE (TREE_CHAIN (arglist
)));
9229 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
9230 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
9231 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
9239 /* These optimizations are only performed when the result is ignored,
9240 hence there's no need to cast the result to integer_type_node. */
9241 return build_function_call_expr (fn
, arglist
);
9245 simplify_builtin_va_start (tree arglist
)
9247 tree chain
= TREE_CHAIN (arglist
);
9249 if (TREE_CHAIN (chain
))
9250 error ("too many arguments to function %<va_start%>");
9252 simplify_builtin_next_arg (chain
);
9256 simplify_builtin_next_arg (tree arglist
)
9258 tree fntype
= TREE_TYPE (current_function_decl
);
9260 if (TYPE_ARG_TYPES (fntype
) == 0
9261 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
9263 error ("%<va_start%> used in function with fixed args");
9266 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
9267 tree arg
= TREE_VALUE (arglist
);
9269 /* Strip off all nops for the sake of the comparison. This
9270 is not quite the same as STRIP_NOPS. It does more.
9271 We must also strip off INDIRECT_EXPR for C++ reference
9273 while (TREE_CODE (arg
) == NOP_EXPR
9274 || TREE_CODE (arg
) == CONVERT_EXPR
9275 || TREE_CODE (arg
) == NON_LVALUE_EXPR
9276 || TREE_CODE (arg
) == INDIRECT_REF
)
9277 arg
= TREE_OPERAND (arg
, 0);
9278 if (arg
!= last_parm
)
9279 warning ("second parameter of %<va_start%> not last named argument");
9280 TREE_VALUE (arglist
) = arg
;
9283 /* Evidently an out of date version of <stdarg.h>; can't validate
9284 va_start's second argument, but can still work as intended. */
9285 warning ("%<__builtin_next_arg%> called without an argument");
9289 /* Simplify a call to the sprintf builtin.
9291 Return 0 if no simplification was possible, otherwise return the
9292 simplified form of the call as a tree. If IGNORED is true, it means that
9293 the caller does not use the returned value of the function. */
9296 simplify_builtin_sprintf (tree arglist
, int ignored
)
9298 tree call
, retval
, dest
, fmt
;
9299 const char *fmt_str
= NULL
;
9301 /* Verify the required arguments in the original call. We deal with two
9302 types of sprintf() calls: 'sprintf (str, fmt)' and
9303 'sprintf (dest, "%s", orig)'. */
9304 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
)
9305 && !validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
9309 /* Get the destination string and the format specifier. */
9310 dest
= TREE_VALUE (arglist
);
9311 fmt
= TREE_VALUE (TREE_CHAIN (arglist
));
9313 /* Check whether the format is a literal string constant. */
9314 fmt_str
= c_getstr (fmt
);
9315 if (fmt_str
== NULL
)
9321 /* If the format doesn't contain % args or %%, use strcpy. */
9322 if (strchr (fmt_str
, '%') == NULL
)
9324 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9329 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9330 'format' is known to contain no % formats. */
9331 arglist
= build_tree_list (NULL_TREE
, fmt
);
9332 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9333 call
= build_function_call_expr (fn
, arglist
);
9335 retval
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
9338 /* If the format is "%s", use strcpy if the result isn't used. */
9339 else if (fmt_str
&& strcmp (fmt_str
, "%s") == 0)
9342 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9347 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
9348 orig
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9349 arglist
= build_tree_list (NULL_TREE
, orig
);
9350 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9353 retval
= c_strlen (orig
, 1);
9354 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
9357 call
= build_function_call_expr (fn
, arglist
);
9363 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
9365 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);