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"
50 #define CALLED_AS_BUILT_IN(NODE) \
51 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
53 #ifndef PAD_VARARGS_DOWN
54 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
57 /* Define the names of the builtin function types and codes. */
58 const char *const built_in_class_names
[4]
59 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
61 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM) #X,
62 const char *const built_in_names
[(int) END_BUILTINS
] =
64 #include "builtins.def"
68 /* Setup an array of _DECL trees, make sure each element is
69 initialized to NULL_TREE. */
70 tree built_in_decls
[(int) END_BUILTINS
];
71 /* Declarations used when constructing the builtin implicitly in the compiler.
72 It may be NULL_TREE when this is invalid (for instance runtime is not
73 required to implement the function call in all cases). */
74 tree implicit_built_in_decls
[(int) END_BUILTINS
];
76 static int get_pointer_alignment (tree
, unsigned int);
77 static const char *c_getstr (tree
);
78 static rtx
c_readstr (const char *, enum machine_mode
);
79 static int target_char_cast (tree
, char *);
80 static rtx
get_memory_rtx (tree
);
81 static tree
build_string_literal (int, const char *);
82 static int apply_args_size (void);
83 static int apply_result_size (void);
84 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
85 static rtx
result_vector (int, rtx
);
87 static rtx
expand_builtin_setjmp (tree
, rtx
);
88 static void expand_builtin_update_setjmp_buf (rtx
);
89 static void expand_builtin_prefetch (tree
);
90 static rtx
expand_builtin_apply_args (void);
91 static rtx
expand_builtin_apply_args_1 (void);
92 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
93 static void expand_builtin_return (rtx
);
94 static enum type_class
type_to_class (tree
);
95 static rtx
expand_builtin_classify_type (tree
);
96 static void expand_errno_check (tree
, rtx
);
97 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
98 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
99 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
100 static rtx
expand_builtin_args_info (tree
);
101 static rtx
expand_builtin_next_arg (tree
);
102 static rtx
expand_builtin_va_start (tree
);
103 static rtx
expand_builtin_va_end (tree
);
104 static rtx
expand_builtin_va_copy (tree
);
105 static rtx
expand_builtin_memcmp (tree
, tree
, rtx
, enum machine_mode
);
106 static rtx
expand_builtin_strcmp (tree
, rtx
, enum machine_mode
);
107 static rtx
expand_builtin_strncmp (tree
, rtx
, enum machine_mode
);
108 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
109 static rtx
expand_builtin_strcat (tree
, rtx
, enum machine_mode
);
110 static rtx
expand_builtin_strncat (tree
, rtx
, enum machine_mode
);
111 static rtx
expand_builtin_strspn (tree
, rtx
, enum machine_mode
);
112 static rtx
expand_builtin_strcspn (tree
, rtx
, enum machine_mode
);
113 static rtx
expand_builtin_memcpy (tree
, rtx
, enum machine_mode
);
114 static rtx
expand_builtin_mempcpy (tree
, rtx
, enum machine_mode
, int);
115 static rtx
expand_builtin_memmove (tree
, rtx
, enum machine_mode
);
116 static rtx
expand_builtin_bcopy (tree
);
117 static rtx
expand_builtin_strcpy (tree
, rtx
, enum machine_mode
);
118 static rtx
expand_builtin_stpcpy (tree
, rtx
, enum machine_mode
);
119 static rtx
builtin_strncpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
120 static rtx
expand_builtin_strncpy (tree
, rtx
, enum machine_mode
);
121 static rtx
builtin_memset_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
122 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, enum machine_mode
);
123 static rtx
expand_builtin_memset (tree
, rtx
, enum machine_mode
);
124 static rtx
expand_builtin_bzero (tree
);
125 static rtx
expand_builtin_strlen (tree
, rtx
, enum machine_mode
);
126 static rtx
expand_builtin_strstr (tree
, rtx
, enum machine_mode
);
127 static rtx
expand_builtin_strpbrk (tree
, rtx
, enum machine_mode
);
128 static rtx
expand_builtin_strchr (tree
, rtx
, enum machine_mode
);
129 static rtx
expand_builtin_strrchr (tree
, rtx
, enum machine_mode
);
130 static rtx
expand_builtin_alloca (tree
, rtx
);
131 static rtx
expand_builtin_unop (enum machine_mode
, tree
, rtx
, rtx
, optab
);
132 static rtx
expand_builtin_frame_address (tree
, tree
);
133 static rtx
expand_builtin_fputs (tree
, rtx
, bool);
134 static rtx
expand_builtin_printf (tree
, rtx
, enum machine_mode
, bool);
135 static rtx
expand_builtin_fprintf (tree
, rtx
, enum machine_mode
, bool);
136 static rtx
expand_builtin_sprintf (tree
, rtx
, enum machine_mode
);
137 static tree
stabilize_va_list (tree
, int);
138 static rtx
expand_builtin_expect (tree
, rtx
);
139 static tree
fold_builtin_constant_p (tree
);
140 static tree
fold_builtin_classify_type (tree
);
141 static tree
fold_builtin_inf (tree
, int);
142 static tree
fold_builtin_nan (tree
, tree
, int);
143 static int validate_arglist (tree
, ...);
144 static bool integer_valued_real_p (tree
);
145 static tree
fold_trunc_transparent_mathfn (tree
);
146 static bool readonly_data_expr (tree
);
147 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
148 static rtx
expand_builtin_cabs (tree
, rtx
);
149 static rtx
expand_builtin_signbit (tree
, rtx
);
150 static tree
fold_builtin_cabs (tree
, tree
);
151 static tree
fold_builtin_trunc (tree
);
152 static tree
fold_builtin_floor (tree
);
153 static tree
fold_builtin_ceil (tree
);
154 static tree
fold_builtin_round (tree
);
155 static tree
fold_builtin_bitop (tree
);
156 static tree
fold_builtin_memcpy (tree
);
157 static tree
fold_builtin_mempcpy (tree
);
158 static tree
fold_builtin_memmove (tree
);
159 static tree
fold_builtin_strchr (tree
, bool);
160 static tree
fold_builtin_memcmp (tree
);
161 static tree
fold_builtin_strcmp (tree
);
162 static tree
fold_builtin_strncmp (tree
);
163 static tree
fold_builtin_signbit (tree
);
164 static tree
fold_builtin_copysign (tree
, tree
);
165 static tree
fold_builtin_isascii (tree
);
166 static tree
fold_builtin_toascii (tree
);
167 static tree
fold_builtin_isdigit (tree
);
168 static tree
fold_builtin_fabs (tree
, tree
);
169 static tree
fold_builtin_abs (tree
, tree
);
170 static tree
fold_builtin_unordered_cmp (tree
, enum tree_code
, enum tree_code
);
171 static tree
fold_builtin_1 (tree
, bool);
173 static tree
simplify_builtin_memcmp (tree
);
174 static tree
simplify_builtin_strcmp (tree
);
175 static tree
simplify_builtin_strncmp (tree
);
176 static tree
simplify_builtin_strpbrk (tree
);
177 static tree
simplify_builtin_strstr (tree
);
178 static tree
simplify_builtin_strchr (tree
);
179 static tree
simplify_builtin_strrchr (tree
);
180 static tree
simplify_builtin_strcat (tree
);
181 static tree
simplify_builtin_strncat (tree
);
182 static tree
simplify_builtin_strspn (tree
);
183 static tree
simplify_builtin_strcspn (tree
);
184 static void simplify_builtin_next_arg (tree
);
185 static void simplify_builtin_va_start (tree
);
186 static tree
simplify_builtin_sprintf (tree
, int);
189 /* Return the alignment in bits of EXP, a pointer valued expression.
190 But don't return more than MAX_ALIGN no matter what.
191 The alignment returned is, by default, the alignment of the thing that
192 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
194 Otherwise, look at the expression to see if we can do better, i.e., if the
195 expression is actually pointing at an object whose alignment is tighter. */
198 get_pointer_alignment (tree exp
, unsigned int max_align
)
200 unsigned int align
, inner
;
202 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
205 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
206 align
= MIN (align
, max_align
);
210 switch (TREE_CODE (exp
))
214 case NON_LVALUE_EXPR
:
215 exp
= TREE_OPERAND (exp
, 0);
216 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
219 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
220 align
= MIN (inner
, max_align
);
224 /* If sum of pointer + int, restrict our maximum alignment to that
225 imposed by the integer. If not, we can't do any better than
227 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
230 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
231 & (max_align
/ BITS_PER_UNIT
- 1))
235 exp
= TREE_OPERAND (exp
, 0);
239 /* See what we are pointing at and look at its alignment. */
240 exp
= TREE_OPERAND (exp
, 0);
241 if (TREE_CODE (exp
) == FUNCTION_DECL
)
242 align
= FUNCTION_BOUNDARY
;
243 else if (DECL_P (exp
))
244 align
= DECL_ALIGN (exp
);
245 #ifdef CONSTANT_ALIGNMENT
246 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
247 align
= CONSTANT_ALIGNMENT (exp
, align
);
249 return MIN (align
, max_align
);
257 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
258 way, because it could contain a zero byte in the middle.
259 TREE_STRING_LENGTH is the size of the character array, not the string.
261 ONLY_VALUE should be nonzero if the result is not going to be emitted
262 into the instruction stream and zero if it is going to be expanded.
263 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
264 is returned, otherwise NULL, since
265 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
266 evaluate the side-effects.
268 The value returned is of type `ssizetype'.
270 Unfortunately, string_constant can't access the values of const char
271 arrays with initializers, so neither can we do so here. */
274 c_strlen (tree src
, int only_value
)
277 HOST_WIDE_INT offset
;
282 if (TREE_CODE (src
) == COND_EXPR
283 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
287 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
288 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
289 if (tree_int_cst_equal (len1
, len2
))
293 if (TREE_CODE (src
) == COMPOUND_EXPR
294 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
295 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
297 src
= string_constant (src
, &offset_node
);
301 max
= TREE_STRING_LENGTH (src
) - 1;
302 ptr
= TREE_STRING_POINTER (src
);
304 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
306 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
307 compute the offset to the following null if we don't know where to
308 start searching for it. */
311 for (i
= 0; i
< max
; i
++)
315 /* We don't know the starting offset, but we do know that the string
316 has no internal zero bytes. We can assume that the offset falls
317 within the bounds of the string; otherwise, the programmer deserves
318 what he gets. Subtract the offset from the length of the string,
319 and return that. This would perhaps not be valid if we were dealing
320 with named arrays in addition to literal string constants. */
322 return size_diffop (size_int (max
), offset_node
);
325 /* We have a known offset into the string. Start searching there for
326 a null character if we can represent it as a single HOST_WIDE_INT. */
327 if (offset_node
== 0)
329 else if (! host_integerp (offset_node
, 0))
332 offset
= tree_low_cst (offset_node
, 0);
334 /* If the offset is known to be out of bounds, warn, and call strlen at
336 if (offset
< 0 || offset
> max
)
338 warning ("offset outside bounds of constant string");
342 /* Use strlen to search for the first zero byte. Since any strings
343 constructed with build_string will have nulls appended, we win even
344 if we get handed something like (char[4])"abcd".
346 Since OFFSET is our starting index into the string, no further
347 calculation is needed. */
348 return ssize_int (strlen (ptr
+ offset
));
351 /* Return a char pointer for a C string if it is a string constant
352 or sum of string constant and integer constant. */
359 src
= string_constant (src
, &offset_node
);
363 if (offset_node
== 0)
364 return TREE_STRING_POINTER (src
);
365 else if (!host_integerp (offset_node
, 1)
366 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
369 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
372 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
373 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
376 c_readstr (const char *str
, enum machine_mode mode
)
382 if (GET_MODE_CLASS (mode
) != MODE_INT
)
387 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
390 if (WORDS_BIG_ENDIAN
)
391 j
= GET_MODE_SIZE (mode
) - i
- 1;
392 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
393 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
394 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
396 if (j
> 2 * HOST_BITS_PER_WIDE_INT
)
399 ch
= (unsigned char) str
[i
];
400 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
402 return immed_double_const (c
[0], c
[1], mode
);
405 /* Cast a target constant CST to target CHAR and if that value fits into
406 host char type, return zero and put that value into variable pointed by
410 target_char_cast (tree cst
, char *p
)
412 unsigned HOST_WIDE_INT val
, hostval
;
414 if (!host_integerp (cst
, 1)
415 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
418 val
= tree_low_cst (cst
, 1);
419 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
420 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
423 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
424 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
433 /* Similar to save_expr, but assumes that arbitrary code is not executed
434 in between the multiple evaluations. In particular, we assume that a
435 non-addressable local variable will not be modified. */
438 builtin_save_expr (tree exp
)
440 if (TREE_ADDRESSABLE (exp
) == 0
441 && (TREE_CODE (exp
) == PARM_DECL
442 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
445 return save_expr (exp
);
448 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
449 times to get the address of either a higher stack frame, or a return
450 address located within it (depending on FNDECL_CODE). */
453 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
,
458 /* Some machines need special handling before we can access
459 arbitrary frames. For example, on the sparc, we must first flush
460 all register windows to the stack. */
461 #ifdef SETUP_FRAME_ADDRESSES
463 SETUP_FRAME_ADDRESSES ();
466 /* On the sparc, the return address is not in the frame, it is in a
467 register. There is no way to access it off of the current frame
468 pointer, but it can be accessed off the previous frame pointer by
469 reading the value from the register window save area. */
470 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
471 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
475 /* Scan back COUNT frames to the specified frame. */
476 for (i
= 0; i
< count
; i
++)
478 /* Assume the dynamic chain pointer is in the word that the
479 frame address points to, unless otherwise specified. */
480 #ifdef DYNAMIC_CHAIN_ADDRESS
481 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
483 tem
= memory_address (Pmode
, tem
);
484 tem
= gen_rtx_MEM (Pmode
, tem
);
485 set_mem_alias_set (tem
, get_frame_alias_set ());
486 tem
= copy_to_reg (tem
);
489 /* For __builtin_frame_address, return what we've got. */
490 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
493 /* For __builtin_return_address, Get the return address from that
495 #ifdef RETURN_ADDR_RTX
496 tem
= RETURN_ADDR_RTX (count
, tem
);
498 tem
= memory_address (Pmode
,
499 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
500 tem
= gen_rtx_MEM (Pmode
, tem
);
501 set_mem_alias_set (tem
, get_frame_alias_set ());
506 /* Alias set used for setjmp buffer. */
507 static HOST_WIDE_INT setjmp_alias_set
= -1;
509 /* Construct the leading half of a __builtin_setjmp call. Control will
510 return to RECEIVER_LABEL. This is used directly by sjlj exception
514 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
516 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
520 if (setjmp_alias_set
== -1)
521 setjmp_alias_set
= new_alias_set ();
523 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
525 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
527 /* We store the frame pointer and the address of receiver_label in
528 the buffer and use the rest of it for the stack save area, which
529 is machine-dependent. */
531 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
532 set_mem_alias_set (mem
, setjmp_alias_set
);
533 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
535 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
536 set_mem_alias_set (mem
, setjmp_alias_set
);
538 emit_move_insn (validize_mem (mem
),
539 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
541 stack_save
= gen_rtx_MEM (sa_mode
,
542 plus_constant (buf_addr
,
543 2 * GET_MODE_SIZE (Pmode
)));
544 set_mem_alias_set (stack_save
, setjmp_alias_set
);
545 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
547 /* If there is further processing to do, do it. */
548 #ifdef HAVE_builtin_setjmp_setup
549 if (HAVE_builtin_setjmp_setup
)
550 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
553 /* Tell optimize_save_area_alloca that extra work is going to
554 need to go on during alloca. */
555 current_function_calls_setjmp
= 1;
557 /* Set this so all the registers get saved in our frame; we need to be
558 able to copy the saved values for any registers from frames we unwind. */
559 current_function_has_nonlocal_label
= 1;
562 /* Construct the trailing part of a __builtin_setjmp call.
563 This is used directly by sjlj exception handling code. */
566 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
568 /* Clobber the FP when we get here, so we have to make sure it's
569 marked as used by this function. */
570 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
572 /* Mark the static chain as clobbered here so life information
573 doesn't get messed up for it. */
574 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
576 /* Now put in the code to restore the frame pointer, and argument
577 pointer, if needed. The code below is from expand_end_bindings
578 in stmt.c; see detailed documentation there. */
579 #ifdef HAVE_nonlocal_goto
580 if (! HAVE_nonlocal_goto
)
582 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
584 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
585 if (fixed_regs
[ARG_POINTER_REGNUM
])
587 #ifdef ELIMINABLE_REGS
589 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
591 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
592 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
593 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
596 if (i
== ARRAY_SIZE (elim_regs
))
599 /* Now restore our arg pointer from the address at which it
600 was saved in our stack frame. */
601 emit_move_insn (virtual_incoming_args_rtx
,
602 copy_to_reg (get_arg_pointer_save_area (cfun
)));
607 #ifdef HAVE_builtin_setjmp_receiver
608 if (HAVE_builtin_setjmp_receiver
)
609 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
612 #ifdef HAVE_nonlocal_goto_receiver
613 if (HAVE_nonlocal_goto_receiver
)
614 emit_insn (gen_nonlocal_goto_receiver ());
619 /* @@@ This is a kludge. Not all machine descriptions define a blockage
620 insn, but we must not allow the code we just generated to be reordered
621 by scheduling. Specifically, the update of the frame pointer must
622 happen immediately, not later. So emit an ASM_INPUT to act as blockage
624 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
627 /* __builtin_setjmp is passed a pointer to an array of five words (not
628 all will be used on all machines). It operates similarly to the C
629 library function of the same name, but is more efficient. Much of
630 the code below (and for longjmp) is copied from the handling of
633 NOTE: This is intended for use by GNAT and the exception handling
634 scheme in the compiler and will only work in the method used by
638 expand_builtin_setjmp (tree arglist
, rtx target
)
640 rtx buf_addr
, next_lab
, cont_lab
;
642 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
645 if (target
== 0 || !REG_P (target
)
646 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
647 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
649 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
651 next_lab
= gen_label_rtx ();
652 cont_lab
= gen_label_rtx ();
654 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
656 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
657 ensure that pending stack adjustments are flushed. */
658 emit_move_insn (target
, const0_rtx
);
659 emit_jump (cont_lab
);
661 emit_label (next_lab
);
663 expand_builtin_setjmp_receiver (next_lab
);
665 /* Set TARGET to one. */
666 emit_move_insn (target
, const1_rtx
);
667 emit_label (cont_lab
);
669 /* Tell flow about the strange goings on. Putting `next_lab' on
670 `nonlocal_goto_handler_labels' to indicates that function
671 calls may traverse the arc back to this label. */
673 current_function_has_nonlocal_label
= 1;
674 nonlocal_goto_handler_labels
675 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
680 /* __builtin_longjmp is passed a pointer to an array of five words (not
681 all will be used on all machines). It operates similarly to the C
682 library function of the same name, but is more efficient. Much of
683 the code below is copied from the handling of non-local gotos.
685 NOTE: This is intended for use by GNAT and the exception handling
686 scheme in the compiler and will only work in the method used by
690 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
692 rtx fp
, lab
, stack
, insn
, last
;
693 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
695 if (setjmp_alias_set
== -1)
696 setjmp_alias_set
= new_alias_set ();
698 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
700 buf_addr
= force_reg (Pmode
, buf_addr
);
702 /* We used to store value in static_chain_rtx, but that fails if pointers
703 are smaller than integers. We instead require that the user must pass
704 a second argument of 1, because that is what builtin_setjmp will
705 return. This also makes EH slightly more efficient, since we are no
706 longer copying around a value that we don't care about. */
707 if (value
!= const1_rtx
)
710 current_function_calls_longjmp
= 1;
712 last
= get_last_insn ();
713 #ifdef HAVE_builtin_longjmp
714 if (HAVE_builtin_longjmp
)
715 emit_insn (gen_builtin_longjmp (buf_addr
));
719 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
720 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
721 GET_MODE_SIZE (Pmode
)));
723 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
724 2 * GET_MODE_SIZE (Pmode
)));
725 set_mem_alias_set (fp
, setjmp_alias_set
);
726 set_mem_alias_set (lab
, setjmp_alias_set
);
727 set_mem_alias_set (stack
, setjmp_alias_set
);
729 /* Pick up FP, label, and SP from the block and jump. This code is
730 from expand_goto in stmt.c; see there for detailed comments. */
731 #if HAVE_nonlocal_goto
732 if (HAVE_nonlocal_goto
)
733 /* We have to pass a value to the nonlocal_goto pattern that will
734 get copied into the static_chain pointer, but it does not matter
735 what that value is, because builtin_setjmp does not use it. */
736 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
740 lab
= copy_to_reg (lab
);
742 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
743 gen_rtx_MEM (BLKmode
,
744 gen_rtx_SCRATCH (VOIDmode
))));
745 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
746 gen_rtx_MEM (BLKmode
,
747 hard_frame_pointer_rtx
)));
749 emit_move_insn (hard_frame_pointer_rtx
, fp
);
750 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
752 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
753 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
754 emit_indirect_jump (lab
);
758 /* Search backwards and mark the jump insn as a non-local goto.
759 Note that this precludes the use of __builtin_longjmp to a
760 __builtin_setjmp target in the same function. However, we've
761 already cautioned the user that these functions are for
762 internal exception handling use only. */
763 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
769 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
773 else if (CALL_P (insn
))
778 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
779 and the address of the save area. */
782 expand_builtin_nonlocal_goto (tree arglist
)
784 tree t_label
, t_save_area
;
785 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
787 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
790 t_label
= TREE_VALUE (arglist
);
791 arglist
= TREE_CHAIN (arglist
);
792 t_save_area
= TREE_VALUE (arglist
);
794 r_label
= expand_expr (t_label
, NULL_RTX
, VOIDmode
, 0);
795 r_label
= convert_memory_address (Pmode
, r_label
);
796 r_save_area
= expand_expr (t_save_area
, NULL_RTX
, VOIDmode
, 0);
797 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
798 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
799 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
800 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
802 current_function_has_nonlocal_goto
= 1;
804 #if HAVE_nonlocal_goto
805 /* ??? We no longer need to pass the static chain value, afaik. */
806 if (HAVE_nonlocal_goto
)
807 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
811 r_label
= copy_to_reg (r_label
);
813 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
814 gen_rtx_MEM (BLKmode
,
815 gen_rtx_SCRATCH (VOIDmode
))));
817 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
818 gen_rtx_MEM (BLKmode
,
819 hard_frame_pointer_rtx
)));
821 /* Restore frame pointer for containing function.
822 This sets the actual hard register used for the frame pointer
823 to the location of the function's incoming static chain info.
824 The non-local goto handler will then adjust it to contain the
825 proper value and reload the argument pointer, if needed. */
826 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
827 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
829 /* USE of hard_frame_pointer_rtx added for consistency;
830 not clear if really needed. */
831 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
832 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
833 emit_indirect_jump (r_label
);
836 /* Search backwards to the jump insn and mark it as a
838 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
842 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
,
843 const0_rtx
, REG_NOTES (insn
));
846 else if (CALL_P (insn
))
853 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
854 (not all will be used on all machines) that was passed to __builtin_setjmp.
855 It updates the stack pointer in that block to correspond to the current
859 expand_builtin_update_setjmp_buf (rtx buf_addr
)
861 enum machine_mode sa_mode
= Pmode
;
865 #ifdef HAVE_save_stack_nonlocal
866 if (HAVE_save_stack_nonlocal
)
867 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
869 #ifdef STACK_SAVEAREA_MODE
870 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
874 = gen_rtx_MEM (sa_mode
,
877 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
881 emit_insn (gen_setjmp ());
884 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
887 /* Expand a call to __builtin_prefetch. For a target that does not support
888 data prefetch, evaluate the memory address argument in case it has side
892 expand_builtin_prefetch (tree arglist
)
894 tree arg0
, arg1
, arg2
;
897 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
900 arg0
= TREE_VALUE (arglist
);
901 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
902 zero (read) and argument 2 (locality) defaults to 3 (high degree of
904 if (TREE_CHAIN (arglist
))
906 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
907 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
908 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
910 arg2
= build_int_2 (3, 0);
914 arg1
= integer_zero_node
;
915 arg2
= build_int_2 (3, 0);
918 /* Argument 0 is an address. */
919 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
921 /* Argument 1 (read/write flag) must be a compile-time constant int. */
922 if (TREE_CODE (arg1
) != INTEGER_CST
)
924 error ("second arg to `__builtin_prefetch' must be a constant");
925 arg1
= integer_zero_node
;
927 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
928 /* Argument 1 must be either zero or one. */
929 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
931 warning ("invalid second arg to __builtin_prefetch; using zero");
935 /* Argument 2 (locality) must be a compile-time constant int. */
936 if (TREE_CODE (arg2
) != INTEGER_CST
)
938 error ("third arg to `__builtin_prefetch' must be a constant");
939 arg2
= integer_zero_node
;
941 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
942 /* Argument 2 must be 0, 1, 2, or 3. */
943 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
945 warning ("invalid third arg to __builtin_prefetch; using zero");
952 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
954 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
955 || (GET_MODE (op0
) != Pmode
))
957 op0
= convert_memory_address (Pmode
, op0
);
958 op0
= force_reg (Pmode
, op0
);
960 emit_insn (gen_prefetch (op0
, op1
, op2
));
964 /* Don't do anything with direct references to volatile memory, but
965 generate code to handle other side effects. */
966 if (!MEM_P (op0
) && side_effects_p (op0
))
970 /* Get a MEM rtx for expression EXP which is the address of an operand
971 to be used to be used in a string instruction (cmpstrsi, movmemsi, ..). */
974 get_memory_rtx (tree exp
)
976 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
979 addr
= convert_memory_address (Pmode
, addr
);
981 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
983 /* Get an expression we can use to find the attributes to assign to MEM.
984 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
985 we can. First remove any nops. */
986 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
987 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
988 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
989 exp
= TREE_OPERAND (exp
, 0);
991 if (TREE_CODE (exp
) == ADDR_EXPR
)
993 exp
= TREE_OPERAND (exp
, 0);
994 set_mem_attributes (mem
, exp
, 0);
996 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
998 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
999 /* memcpy, memset and other builtin stringops can alias with anything. */
1000 set_mem_alias_set (mem
, 0);
1006 /* Built-in functions to perform an untyped call and return. */
1008 /* For each register that may be used for calling a function, this
1009 gives a mode used to copy the register's value. VOIDmode indicates
1010 the register is not used for calling a function. If the machine
1011 has register windows, this gives only the outbound registers.
1012 INCOMING_REGNO gives the corresponding inbound register. */
1013 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
1015 /* For each register that may be used for returning values, this gives
1016 a mode used to copy the register's value. VOIDmode indicates the
1017 register is not used for returning values. If the machine has
1018 register windows, this gives only the outbound registers.
1019 INCOMING_REGNO gives the corresponding inbound register. */
1020 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
1022 /* For each register that may be used for calling a function, this
1023 gives the offset of that register into the block returned by
1024 __builtin_apply_args. 0 indicates that the register is not
1025 used for calling a function. */
1026 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
1028 /* Return the size required for the block returned by __builtin_apply_args,
1029 and initialize apply_args_mode. */
1032 apply_args_size (void)
1034 static int size
= -1;
1037 enum machine_mode mode
;
1039 /* The values computed by this function never change. */
1042 /* The first value is the incoming arg-pointer. */
1043 size
= GET_MODE_SIZE (Pmode
);
1045 /* The second value is the structure value address unless this is
1046 passed as an "invisible" first argument. */
1047 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1048 size
+= GET_MODE_SIZE (Pmode
);
1050 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1051 if (FUNCTION_ARG_REGNO_P (regno
))
1053 mode
= reg_raw_mode
[regno
];
1055 if (mode
== VOIDmode
)
1058 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1059 if (size
% align
!= 0)
1060 size
= CEIL (size
, align
) * align
;
1061 apply_args_reg_offset
[regno
] = size
;
1062 size
+= GET_MODE_SIZE (mode
);
1063 apply_args_mode
[regno
] = mode
;
1067 apply_args_mode
[regno
] = VOIDmode
;
1068 apply_args_reg_offset
[regno
] = 0;
1074 /* Return the size required for the block returned by __builtin_apply,
1075 and initialize apply_result_mode. */
1078 apply_result_size (void)
1080 static int size
= -1;
1082 enum machine_mode mode
;
1084 /* The values computed by this function never change. */
1089 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1090 if (FUNCTION_VALUE_REGNO_P (regno
))
1092 mode
= reg_raw_mode
[regno
];
1094 if (mode
== VOIDmode
)
1097 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1098 if (size
% align
!= 0)
1099 size
= CEIL (size
, align
) * align
;
1100 size
+= GET_MODE_SIZE (mode
);
1101 apply_result_mode
[regno
] = mode
;
1104 apply_result_mode
[regno
] = VOIDmode
;
1106 /* Allow targets that use untyped_call and untyped_return to override
1107 the size so that machine-specific information can be stored here. */
1108 #ifdef APPLY_RESULT_SIZE
1109 size
= APPLY_RESULT_SIZE
;
1115 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1116 /* Create a vector describing the result block RESULT. If SAVEP is true,
1117 the result block is used to save the values; otherwise it is used to
1118 restore the values. */
1121 result_vector (int savep
, rtx result
)
1123 int regno
, size
, align
, nelts
;
1124 enum machine_mode mode
;
1126 rtx
*savevec
= alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1129 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1130 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1132 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1133 if (size
% align
!= 0)
1134 size
= CEIL (size
, align
) * align
;
1135 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1136 mem
= adjust_address (result
, mode
, size
);
1137 savevec
[nelts
++] = (savep
1138 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1139 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1140 size
+= GET_MODE_SIZE (mode
);
1142 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1144 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1146 /* Save the state required to perform an untyped call with the same
1147 arguments as were passed to the current function. */
1150 expand_builtin_apply_args_1 (void)
1153 int size
, align
, regno
;
1154 enum machine_mode mode
;
1155 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1157 /* Create a block where the arg-pointer, structure value address,
1158 and argument registers can be saved. */
1159 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1161 /* Walk past the arg-pointer and structure value address. */
1162 size
= GET_MODE_SIZE (Pmode
);
1163 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1164 size
+= GET_MODE_SIZE (Pmode
);
1166 /* Save each register used in calling a function to the block. */
1167 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1168 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1170 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1171 if (size
% align
!= 0)
1172 size
= CEIL (size
, align
) * align
;
1174 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1176 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1177 size
+= GET_MODE_SIZE (mode
);
1180 /* Save the arg pointer to the block. */
1181 tem
= copy_to_reg (virtual_incoming_args_rtx
);
1182 #ifdef STACK_GROWS_DOWNWARD
1183 /* We need the pointer as the caller actually passed them to us, not
1184 as we might have pretended they were passed. Make sure it's a valid
1185 operand, as emit_move_insn isn't expected to handle a PLUS. */
1187 = force_operand (plus_constant (tem
, current_function_pretend_args_size
),
1190 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1192 size
= GET_MODE_SIZE (Pmode
);
1194 /* Save the structure value address unless this is passed as an
1195 "invisible" first argument. */
1196 if (struct_incoming_value
)
1198 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1199 copy_to_reg (struct_incoming_value
));
1200 size
+= GET_MODE_SIZE (Pmode
);
1203 /* Return the address of the block. */
1204 return copy_addr_to_reg (XEXP (registers
, 0));
1207 /* __builtin_apply_args returns block of memory allocated on
1208 the stack into which is stored the arg pointer, structure
1209 value address, static chain, and all the registers that might
1210 possibly be used in performing a function call. The code is
1211 moved to the start of the function so the incoming values are
1215 expand_builtin_apply_args (void)
1217 /* Don't do __builtin_apply_args more than once in a function.
1218 Save the result of the first call and reuse it. */
1219 if (apply_args_value
!= 0)
1220 return apply_args_value
;
1222 /* When this function is called, it means that registers must be
1223 saved on entry to this function. So we migrate the
1224 call to the first insn of this function. */
1229 temp
= expand_builtin_apply_args_1 ();
1233 apply_args_value
= temp
;
1235 /* Put the insns after the NOTE that starts the function.
1236 If this is inside a start_sequence, make the outer-level insn
1237 chain current, so the code is placed at the start of the
1239 push_topmost_sequence ();
1240 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1241 pop_topmost_sequence ();
1246 /* Perform an untyped call and save the state required to perform an
1247 untyped return of whatever value was returned by the given function. */
1250 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1252 int size
, align
, regno
;
1253 enum machine_mode mode
;
1254 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1255 rtx old_stack_level
= 0;
1256 rtx call_fusage
= 0;
1257 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1259 arguments
= convert_memory_address (Pmode
, arguments
);
1261 /* Create a block where the return registers can be saved. */
1262 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1264 /* Fetch the arg pointer from the ARGUMENTS block. */
1265 incoming_args
= gen_reg_rtx (Pmode
);
1266 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1267 #ifndef STACK_GROWS_DOWNWARD
1268 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1269 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1272 /* Push a new argument block and copy the arguments. Do not allow
1273 the (potential) memcpy call below to interfere with our stack
1275 do_pending_stack_adjust ();
1278 /* Save the stack with nonlocal if available. */
1279 #ifdef HAVE_save_stack_nonlocal
1280 if (HAVE_save_stack_nonlocal
)
1281 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1284 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1286 /* Allocate a block of memory onto the stack and copy the memory
1287 arguments to the outgoing arguments address. */
1288 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1289 dest
= virtual_outgoing_args_rtx
;
1290 #ifndef STACK_GROWS_DOWNWARD
1291 if (GET_CODE (argsize
) == CONST_INT
)
1292 dest
= plus_constant (dest
, -INTVAL (argsize
));
1294 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1296 dest
= gen_rtx_MEM (BLKmode
, dest
);
1297 set_mem_align (dest
, PARM_BOUNDARY
);
1298 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1299 set_mem_align (src
, PARM_BOUNDARY
);
1300 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1302 /* Refer to the argument block. */
1304 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1305 set_mem_align (arguments
, PARM_BOUNDARY
);
1307 /* Walk past the arg-pointer and structure value address. */
1308 size
= GET_MODE_SIZE (Pmode
);
1310 size
+= GET_MODE_SIZE (Pmode
);
1312 /* Restore each of the registers previously saved. Make USE insns
1313 for each of these registers for use in making the call. */
1314 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1315 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1317 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1318 if (size
% align
!= 0)
1319 size
= CEIL (size
, align
) * align
;
1320 reg
= gen_rtx_REG (mode
, regno
);
1321 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1322 use_reg (&call_fusage
, reg
);
1323 size
+= GET_MODE_SIZE (mode
);
1326 /* Restore the structure value address unless this is passed as an
1327 "invisible" first argument. */
1328 size
= GET_MODE_SIZE (Pmode
);
1331 rtx value
= gen_reg_rtx (Pmode
);
1332 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1333 emit_move_insn (struct_value
, value
);
1334 if (REG_P (struct_value
))
1335 use_reg (&call_fusage
, struct_value
);
1336 size
+= GET_MODE_SIZE (Pmode
);
1339 /* All arguments and registers used for the call are set up by now! */
1340 function
= prepare_call_address (function
, NULL
, &call_fusage
, 0, 0);
1342 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1343 and we don't want to load it into a register as an optimization,
1344 because prepare_call_address already did it if it should be done. */
1345 if (GET_CODE (function
) != SYMBOL_REF
)
1346 function
= memory_address (FUNCTION_MODE
, function
);
1348 /* Generate the actual call instruction and save the return value. */
1349 #ifdef HAVE_untyped_call
1350 if (HAVE_untyped_call
)
1351 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1352 result
, result_vector (1, result
)));
1355 #ifdef HAVE_call_value
1356 if (HAVE_call_value
)
1360 /* Locate the unique return register. It is not possible to
1361 express a call that sets more than one return register using
1362 call_value; use untyped_call for that. In fact, untyped_call
1363 only needs to save the return registers in the given block. */
1364 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1365 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1368 abort (); /* HAVE_untyped_call required. */
1369 valreg
= gen_rtx_REG (mode
, regno
);
1372 emit_call_insn (GEN_CALL_VALUE (valreg
,
1373 gen_rtx_MEM (FUNCTION_MODE
, function
),
1374 const0_rtx
, NULL_RTX
, const0_rtx
));
1376 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1382 /* Find the CALL insn we just emitted, and attach the register usage
1384 call_insn
= last_call_insn ();
1385 add_function_usage_to (call_insn
, call_fusage
);
1387 /* Restore the stack. */
1388 #ifdef HAVE_save_stack_nonlocal
1389 if (HAVE_save_stack_nonlocal
)
1390 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1393 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1397 /* Return the address of the result block. */
1398 result
= copy_addr_to_reg (XEXP (result
, 0));
1399 return convert_memory_address (ptr_mode
, result
);
1402 /* Perform an untyped return. */
1405 expand_builtin_return (rtx result
)
1407 int size
, align
, regno
;
1408 enum machine_mode mode
;
1410 rtx call_fusage
= 0;
1412 result
= convert_memory_address (Pmode
, result
);
1414 apply_result_size ();
1415 result
= gen_rtx_MEM (BLKmode
, result
);
1417 #ifdef HAVE_untyped_return
1418 if (HAVE_untyped_return
)
1420 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1426 /* Restore the return value and note that each value is used. */
1428 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1429 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1431 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1432 if (size
% align
!= 0)
1433 size
= CEIL (size
, align
) * align
;
1434 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1435 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1437 push_to_sequence (call_fusage
);
1438 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1439 call_fusage
= get_insns ();
1441 size
+= GET_MODE_SIZE (mode
);
1444 /* Put the USE insns before the return. */
1445 emit_insn (call_fusage
);
1447 /* Return whatever values was restored by jumping directly to the end
1449 expand_naked_return ();
1452 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1454 static enum type_class
1455 type_to_class (tree type
)
1457 switch (TREE_CODE (type
))
1459 case VOID_TYPE
: return void_type_class
;
1460 case INTEGER_TYPE
: return integer_type_class
;
1461 case CHAR_TYPE
: return char_type_class
;
1462 case ENUMERAL_TYPE
: return enumeral_type_class
;
1463 case BOOLEAN_TYPE
: return boolean_type_class
;
1464 case POINTER_TYPE
: return pointer_type_class
;
1465 case REFERENCE_TYPE
: return reference_type_class
;
1466 case OFFSET_TYPE
: return offset_type_class
;
1467 case REAL_TYPE
: return real_type_class
;
1468 case COMPLEX_TYPE
: return complex_type_class
;
1469 case FUNCTION_TYPE
: return function_type_class
;
1470 case METHOD_TYPE
: return method_type_class
;
1471 case RECORD_TYPE
: return record_type_class
;
1473 case QUAL_UNION_TYPE
: return union_type_class
;
1474 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1475 ? string_type_class
: array_type_class
);
1476 case SET_TYPE
: return set_type_class
;
1477 case FILE_TYPE
: return file_type_class
;
1478 case LANG_TYPE
: return lang_type_class
;
1479 default: return no_type_class
;
1483 /* Expand a call to __builtin_classify_type with arguments found in
1487 expand_builtin_classify_type (tree arglist
)
1490 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1491 return GEN_INT (no_type_class
);
1494 /* This helper macro, meant to be used in mathfn_built_in below,
1495 determines which among a set of three builtin math functions is
1496 appropriate for a given type mode. The `F' and `L' cases are
1497 automatically generated from the `double' case. */
1498 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1499 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1500 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1501 fcodel = BUILT_IN_MATHFN##L ; break;
1503 /* Return mathematic function equivalent to FN but operating directly
1504 on TYPE, if available. If we can't do the conversion, return zero. */
1506 mathfn_built_in (tree type
, enum built_in_function fn
)
1508 enum built_in_function fcode
, fcodef
, fcodel
;
1512 CASE_MATHFN (BUILT_IN_ACOS
)
1513 CASE_MATHFN (BUILT_IN_ACOSH
)
1514 CASE_MATHFN (BUILT_IN_ASIN
)
1515 CASE_MATHFN (BUILT_IN_ASINH
)
1516 CASE_MATHFN (BUILT_IN_ATAN
)
1517 CASE_MATHFN (BUILT_IN_ATAN2
)
1518 CASE_MATHFN (BUILT_IN_ATANH
)
1519 CASE_MATHFN (BUILT_IN_CBRT
)
1520 CASE_MATHFN (BUILT_IN_CEIL
)
1521 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1522 CASE_MATHFN (BUILT_IN_COS
)
1523 CASE_MATHFN (BUILT_IN_COSH
)
1524 CASE_MATHFN (BUILT_IN_DREM
)
1525 CASE_MATHFN (BUILT_IN_ERF
)
1526 CASE_MATHFN (BUILT_IN_ERFC
)
1527 CASE_MATHFN (BUILT_IN_EXP
)
1528 CASE_MATHFN (BUILT_IN_EXP10
)
1529 CASE_MATHFN (BUILT_IN_EXP2
)
1530 CASE_MATHFN (BUILT_IN_EXPM1
)
1531 CASE_MATHFN (BUILT_IN_FABS
)
1532 CASE_MATHFN (BUILT_IN_FDIM
)
1533 CASE_MATHFN (BUILT_IN_FLOOR
)
1534 CASE_MATHFN (BUILT_IN_FMA
)
1535 CASE_MATHFN (BUILT_IN_FMAX
)
1536 CASE_MATHFN (BUILT_IN_FMIN
)
1537 CASE_MATHFN (BUILT_IN_FMOD
)
1538 CASE_MATHFN (BUILT_IN_FREXP
)
1539 CASE_MATHFN (BUILT_IN_GAMMA
)
1540 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1541 CASE_MATHFN (BUILT_IN_HYPOT
)
1542 CASE_MATHFN (BUILT_IN_ILOGB
)
1543 CASE_MATHFN (BUILT_IN_INF
)
1544 CASE_MATHFN (BUILT_IN_J0
)
1545 CASE_MATHFN (BUILT_IN_J1
)
1546 CASE_MATHFN (BUILT_IN_JN
)
1547 CASE_MATHFN (BUILT_IN_LDEXP
)
1548 CASE_MATHFN (BUILT_IN_LGAMMA
)
1549 CASE_MATHFN (BUILT_IN_LLRINT
)
1550 CASE_MATHFN (BUILT_IN_LLROUND
)
1551 CASE_MATHFN (BUILT_IN_LOG
)
1552 CASE_MATHFN (BUILT_IN_LOG10
)
1553 CASE_MATHFN (BUILT_IN_LOG1P
)
1554 CASE_MATHFN (BUILT_IN_LOG2
)
1555 CASE_MATHFN (BUILT_IN_LOGB
)
1556 CASE_MATHFN (BUILT_IN_LRINT
)
1557 CASE_MATHFN (BUILT_IN_LROUND
)
1558 CASE_MATHFN (BUILT_IN_MODF
)
1559 CASE_MATHFN (BUILT_IN_NAN
)
1560 CASE_MATHFN (BUILT_IN_NANS
)
1561 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1562 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1563 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1564 CASE_MATHFN (BUILT_IN_POW
)
1565 CASE_MATHFN (BUILT_IN_POW10
)
1566 CASE_MATHFN (BUILT_IN_REMAINDER
)
1567 CASE_MATHFN (BUILT_IN_REMQUO
)
1568 CASE_MATHFN (BUILT_IN_RINT
)
1569 CASE_MATHFN (BUILT_IN_ROUND
)
1570 CASE_MATHFN (BUILT_IN_SCALB
)
1571 CASE_MATHFN (BUILT_IN_SCALBLN
)
1572 CASE_MATHFN (BUILT_IN_SCALBN
)
1573 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1574 CASE_MATHFN (BUILT_IN_SIN
)
1575 CASE_MATHFN (BUILT_IN_SINCOS
)
1576 CASE_MATHFN (BUILT_IN_SINH
)
1577 CASE_MATHFN (BUILT_IN_SQRT
)
1578 CASE_MATHFN (BUILT_IN_TAN
)
1579 CASE_MATHFN (BUILT_IN_TANH
)
1580 CASE_MATHFN (BUILT_IN_TGAMMA
)
1581 CASE_MATHFN (BUILT_IN_TRUNC
)
1582 CASE_MATHFN (BUILT_IN_Y0
)
1583 CASE_MATHFN (BUILT_IN_Y1
)
1584 CASE_MATHFN (BUILT_IN_YN
)
1590 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1591 return implicit_built_in_decls
[fcode
];
1592 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1593 return implicit_built_in_decls
[fcodef
];
1594 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1595 return implicit_built_in_decls
[fcodel
];
1600 /* If errno must be maintained, expand the RTL to check if the result,
1601 TARGET, of a built-in function call, EXP, is NaN, and if so set
1605 expand_errno_check (tree exp
, rtx target
)
1607 rtx lab
= gen_label_rtx ();
1609 /* Test the result; if it is NaN, set errno=EDOM because
1610 the argument was not in the domain. */
1611 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1615 /* If this built-in doesn't throw an exception, set errno directly. */
1616 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
1618 #ifdef GEN_ERRNO_RTX
1619 rtx errno_rtx
= GEN_ERRNO_RTX
;
1622 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1624 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1630 /* We can't set errno=EDOM directly; let the library call do it.
1631 Pop the arguments right away in case the call gets deleted. */
1633 expand_call (exp
, target
, 0);
1639 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1640 Return 0 if a normal call should be emitted rather than expanding the
1641 function in-line. EXP is the expression that is a call to the builtin
1642 function; if convenient, the result should be placed in TARGET.
1643 SUBTARGET may be used as the target for computing one of EXP's operands. */
1646 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1648 optab builtin_optab
;
1649 rtx op0
, insns
, before_call
;
1650 tree fndecl
= get_callee_fndecl (exp
);
1651 tree arglist
= TREE_OPERAND (exp
, 1);
1652 enum machine_mode mode
;
1653 bool errno_set
= false;
1656 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1659 arg
= TREE_VALUE (arglist
);
1661 switch (DECL_FUNCTION_CODE (fndecl
))
1664 case BUILT_IN_SQRTF
:
1665 case BUILT_IN_SQRTL
:
1666 errno_set
= ! tree_expr_nonnegative_p (arg
);
1667 builtin_optab
= sqrt_optab
;
1672 errno_set
= true; builtin_optab
= exp_optab
; break;
1673 case BUILT_IN_EXP10
:
1674 case BUILT_IN_EXP10F
:
1675 case BUILT_IN_EXP10L
:
1676 case BUILT_IN_POW10
:
1677 case BUILT_IN_POW10F
:
1678 case BUILT_IN_POW10L
:
1679 errno_set
= true; builtin_optab
= exp10_optab
; break;
1681 case BUILT_IN_EXP2F
:
1682 case BUILT_IN_EXP2L
:
1683 errno_set
= true; builtin_optab
= exp2_optab
; break;
1684 case BUILT_IN_EXPM1
:
1685 case BUILT_IN_EXPM1F
:
1686 case BUILT_IN_EXPM1L
:
1687 errno_set
= true; builtin_optab
= expm1_optab
; break;
1689 case BUILT_IN_LOGBF
:
1690 case BUILT_IN_LOGBL
:
1691 errno_set
= true; builtin_optab
= logb_optab
; break;
1692 case BUILT_IN_ILOGB
:
1693 case BUILT_IN_ILOGBF
:
1694 case BUILT_IN_ILOGBL
:
1695 errno_set
= true; builtin_optab
= ilogb_optab
; break;
1699 errno_set
= true; builtin_optab
= log_optab
; break;
1700 case BUILT_IN_LOG10
:
1701 case BUILT_IN_LOG10F
:
1702 case BUILT_IN_LOG10L
:
1703 errno_set
= true; builtin_optab
= log10_optab
; break;
1705 case BUILT_IN_LOG2F
:
1706 case BUILT_IN_LOG2L
:
1707 errno_set
= true; builtin_optab
= log2_optab
; break;
1708 case BUILT_IN_LOG1P
:
1709 case BUILT_IN_LOG1PF
:
1710 case BUILT_IN_LOG1PL
:
1711 errno_set
= true; builtin_optab
= log1p_optab
; break;
1713 case BUILT_IN_ASINF
:
1714 case BUILT_IN_ASINL
:
1715 builtin_optab
= asin_optab
; break;
1717 case BUILT_IN_ACOSF
:
1718 case BUILT_IN_ACOSL
:
1719 builtin_optab
= acos_optab
; break;
1723 builtin_optab
= tan_optab
; break;
1725 case BUILT_IN_ATANF
:
1726 case BUILT_IN_ATANL
:
1727 builtin_optab
= atan_optab
; break;
1728 case BUILT_IN_FLOOR
:
1729 case BUILT_IN_FLOORF
:
1730 case BUILT_IN_FLOORL
:
1731 builtin_optab
= floor_optab
; break;
1733 case BUILT_IN_CEILF
:
1734 case BUILT_IN_CEILL
:
1735 builtin_optab
= ceil_optab
; break;
1736 case BUILT_IN_TRUNC
:
1737 case BUILT_IN_TRUNCF
:
1738 case BUILT_IN_TRUNCL
:
1739 builtin_optab
= btrunc_optab
; break;
1740 case BUILT_IN_ROUND
:
1741 case BUILT_IN_ROUNDF
:
1742 case BUILT_IN_ROUNDL
:
1743 builtin_optab
= round_optab
; break;
1744 case BUILT_IN_NEARBYINT
:
1745 case BUILT_IN_NEARBYINTF
:
1746 case BUILT_IN_NEARBYINTL
:
1747 builtin_optab
= nearbyint_optab
; break;
1752 /* Make a suitable register to place result in. */
1753 mode
= TYPE_MODE (TREE_TYPE (exp
));
1755 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1758 /* Before working hard, check whether the instruction is available. */
1759 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1761 target
= gen_reg_rtx (mode
);
1763 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1764 need to expand the argument again. This way, we will not perform
1765 side-effects more the once. */
1766 narg
= builtin_save_expr (arg
);
1769 arglist
= build_tree_list (NULL_TREE
, arg
);
1770 exp
= build_function_call_expr (fndecl
, arglist
);
1773 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
1777 /* Compute into TARGET.
1778 Set TARGET to wherever the result comes back. */
1779 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
1784 expand_errno_check (exp
, target
);
1786 /* Output the entire sequence. */
1787 insns
= get_insns ();
1793 /* If we were unable to expand via the builtin, stop the sequence
1794 (without outputting the insns) and call to the library function
1795 with the stabilized argument list. */
1799 before_call
= get_last_insn ();
1801 target
= expand_call (exp
, target
, target
== const0_rtx
);
1803 /* If this is a sqrt operation and we don't care about errno, try to
1804 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1805 This allows the semantics of the libcall to be visible to the RTL
1807 if (builtin_optab
== sqrt_optab
&& !errno_set
)
1809 /* Search backwards through the insns emitted by expand_call looking
1810 for the instruction with the REG_RETVAL note. */
1811 rtx last
= get_last_insn ();
1812 while (last
!= before_call
)
1814 if (find_reg_note (last
, REG_RETVAL
, NULL
))
1816 rtx note
= find_reg_note (last
, REG_EQUAL
, NULL
);
1817 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1818 two elements, i.e. symbol_ref(sqrt) and the operand. */
1820 && GET_CODE (note
) == EXPR_LIST
1821 && GET_CODE (XEXP (note
, 0)) == EXPR_LIST
1822 && XEXP (XEXP (note
, 0), 1) != NULL_RTX
1823 && XEXP (XEXP (XEXP (note
, 0), 1), 1) == NULL_RTX
)
1825 rtx operand
= XEXP (XEXP (XEXP (note
, 0), 1), 0);
1826 /* Check operand is a register with expected mode. */
1829 && GET_MODE (operand
) == mode
)
1831 /* Replace the REG_EQUAL note with a SQRT rtx. */
1832 rtx equiv
= gen_rtx_SQRT (mode
, operand
);
1833 set_unique_reg_note (last
, REG_EQUAL
, equiv
);
1838 last
= PREV_INSN (last
);
1845 /* Expand a call to the builtin binary math functions (pow and atan2).
1846 Return 0 if a normal call should be emitted rather than expanding the
1847 function in-line. EXP is the expression that is a call to the builtin
1848 function; if convenient, the result should be placed in TARGET.
1849 SUBTARGET may be used as the target for computing one of EXP's
1853 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
1855 optab builtin_optab
;
1856 rtx op0
, op1
, insns
;
1857 tree fndecl
= get_callee_fndecl (exp
);
1858 tree arglist
= TREE_OPERAND (exp
, 1);
1859 tree arg0
, arg1
, temp
, narg
;
1860 enum machine_mode mode
;
1861 bool errno_set
= true;
1864 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
1867 arg0
= TREE_VALUE (arglist
);
1868 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
1870 switch (DECL_FUNCTION_CODE (fndecl
))
1875 builtin_optab
= pow_optab
; break;
1876 case BUILT_IN_ATAN2
:
1877 case BUILT_IN_ATAN2F
:
1878 case BUILT_IN_ATAN2L
:
1879 builtin_optab
= atan2_optab
; break;
1881 case BUILT_IN_FMODF
:
1882 case BUILT_IN_FMODL
:
1883 builtin_optab
= fmod_optab
; break;
1885 case BUILT_IN_DREMF
:
1886 case BUILT_IN_DREML
:
1887 builtin_optab
= drem_optab
; break;
1892 /* Make a suitable register to place result in. */
1893 mode
= TYPE_MODE (TREE_TYPE (exp
));
1895 /* Before working hard, check whether the instruction is available. */
1896 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
1899 target
= gen_reg_rtx (mode
);
1901 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1904 /* Always stabilize the argument list. */
1905 narg
= builtin_save_expr (arg1
);
1908 temp
= build_tree_list (NULL_TREE
, narg
);
1912 temp
= TREE_CHAIN (arglist
);
1914 narg
= builtin_save_expr (arg0
);
1917 arglist
= tree_cons (NULL_TREE
, narg
, temp
);
1921 arglist
= tree_cons (NULL_TREE
, arg0
, temp
);
1924 exp
= build_function_call_expr (fndecl
, arglist
);
1926 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
1927 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
1931 /* Compute into TARGET.
1932 Set TARGET to wherever the result comes back. */
1933 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
1934 target
, 0, OPTAB_DIRECT
);
1936 /* If we were unable to expand via the builtin, stop the sequence
1937 (without outputting the insns) and call to the library function
1938 with the stabilized argument list. */
1942 return expand_call (exp
, target
, target
== const0_rtx
);
1946 expand_errno_check (exp
, target
);
1948 /* Output the entire sequence. */
1949 insns
= get_insns ();
1956 /* Expand a call to the builtin sin and cos math functions.
1957 Return 0 if a normal call should be emitted rather than expanding the
1958 function in-line. EXP is the expression that is a call to the builtin
1959 function; if convenient, the result should be placed in TARGET.
1960 SUBTARGET may be used as the target for computing one of EXP's
1964 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
1966 optab builtin_optab
;
1967 rtx op0
, insns
, before_call
;
1968 tree fndecl
= get_callee_fndecl (exp
);
1969 tree arglist
= TREE_OPERAND (exp
, 1);
1970 enum machine_mode mode
;
1971 bool errno_set
= false;
1974 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1977 arg
= TREE_VALUE (arglist
);
1979 switch (DECL_FUNCTION_CODE (fndecl
))
1987 builtin_optab
= sincos_optab
; break;
1992 /* Make a suitable register to place result in. */
1993 mode
= TYPE_MODE (TREE_TYPE (exp
));
1995 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1998 /* Check if sincos insn is available, otherwise fallback
1999 to sin or cos insn. */
2000 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
) {
2001 switch (DECL_FUNCTION_CODE (fndecl
))
2006 builtin_optab
= sin_optab
; break;
2010 builtin_optab
= cos_optab
; break;
2016 /* Before working hard, check whether the instruction is available. */
2017 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2019 target
= gen_reg_rtx (mode
);
2021 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2022 need to expand the argument again. This way, we will not perform
2023 side-effects more the once. */
2024 narg
= save_expr (arg
);
2027 arglist
= build_tree_list (NULL_TREE
, arg
);
2028 exp
= build_function_call_expr (fndecl
, arglist
);
2031 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2035 /* Compute into TARGET.
2036 Set TARGET to wherever the result comes back. */
2037 if (builtin_optab
== sincos_optab
)
2039 switch (DECL_FUNCTION_CODE (fndecl
))
2044 if (!expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0))
2050 if (!expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0))
2059 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2065 expand_errno_check (exp
, target
);
2067 /* Output the entire sequence. */
2068 insns
= get_insns ();
2074 /* If we were unable to expand via the builtin, stop the sequence
2075 (without outputting the insns) and call to the library function
2076 with the stabilized argument list. */
2080 before_call
= get_last_insn ();
2082 target
= expand_call (exp
, target
, target
== const0_rtx
);
2087 /* To evaluate powi(x,n), the floating point value x raised to the
2088 constant integer exponent n, we use a hybrid algorithm that
2089 combines the "window method" with look-up tables. For an
2090 introduction to exponentiation algorithms and "addition chains",
2091 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2092 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2093 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2094 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2096 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2097 multiplications to inline before calling the system library's pow
2098 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2099 so this default never requires calling pow, powf or powl. */
2101 #ifndef POWI_MAX_MULTS
2102 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2105 /* The size of the "optimal power tree" lookup table. All
2106 exponents less than this value are simply looked up in the
2107 powi_table below. This threshold is also used to size the
2108 cache of pseudo registers that hold intermediate results. */
2109 #define POWI_TABLE_SIZE 256
2111 /* The size, in bits of the window, used in the "window method"
2112 exponentiation algorithm. This is equivalent to a radix of
2113 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2114 #define POWI_WINDOW_SIZE 3
2116 /* The following table is an efficient representation of an
2117 "optimal power tree". For each value, i, the corresponding
2118 value, j, in the table states than an optimal evaluation
2119 sequence for calculating pow(x,i) can be found by evaluating
2120 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2121 100 integers is given in Knuth's "Seminumerical algorithms". */
2123 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2125 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2126 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2127 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2128 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2129 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2130 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2131 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2132 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2133 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2134 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2135 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2136 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2137 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2138 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2139 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2140 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2141 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2142 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2143 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2144 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2145 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2146 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2147 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2148 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2149 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2150 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2151 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2152 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2153 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2154 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2155 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2156 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2160 /* Return the number of multiplications required to calculate
2161 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2162 subroutine of powi_cost. CACHE is an array indicating
2163 which exponents have already been calculated. */
2166 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2168 /* If we've already calculated this exponent, then this evaluation
2169 doesn't require any additional multiplications. */
2174 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2175 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2178 /* Return the number of multiplications required to calculate
2179 powi(x,n) for an arbitrary x, given the exponent N. This
2180 function needs to be kept in sync with expand_powi below. */
2183 powi_cost (HOST_WIDE_INT n
)
2185 bool cache
[POWI_TABLE_SIZE
];
2186 unsigned HOST_WIDE_INT digit
;
2187 unsigned HOST_WIDE_INT val
;
2193 /* Ignore the reciprocal when calculating the cost. */
2194 val
= (n
< 0) ? -n
: n
;
2196 /* Initialize the exponent cache. */
2197 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2202 while (val
>= POWI_TABLE_SIZE
)
2206 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2207 result
+= powi_lookup_cost (digit
, cache
)
2208 + POWI_WINDOW_SIZE
+ 1;
2209 val
>>= POWI_WINDOW_SIZE
;
2218 return result
+ powi_lookup_cost (val
, cache
);
2221 /* Recursive subroutine of expand_powi. This function takes the array,
2222 CACHE, of already calculated exponents and an exponent N and returns
2223 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2226 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2228 unsigned HOST_WIDE_INT digit
;
2232 if (n
< POWI_TABLE_SIZE
)
2237 target
= gen_reg_rtx (mode
);
2240 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2241 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2245 target
= gen_reg_rtx (mode
);
2246 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2247 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2248 op1
= expand_powi_1 (mode
, digit
, cache
);
2252 target
= gen_reg_rtx (mode
);
2253 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2257 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2258 if (result
!= target
)
2259 emit_move_insn (target
, result
);
2263 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2264 floating point operand in mode MODE, and N is the exponent. This
2265 function needs to be kept in sync with powi_cost above. */
2268 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2270 unsigned HOST_WIDE_INT val
;
2271 rtx cache
[POWI_TABLE_SIZE
];
2275 return CONST1_RTX (mode
);
2277 val
= (n
< 0) ? -n
: n
;
2279 memset (cache
, 0, sizeof (cache
));
2282 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2284 /* If the original exponent was negative, reciprocate the result. */
2286 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2287 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2292 /* Expand a call to the pow built-in mathematical function. Return 0 if
2293 a normal call should be emitted rather than expanding the function
2294 in-line. EXP is the expression that is a call to the builtin
2295 function; if convenient, the result should be placed in TARGET. */
2298 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
2300 tree arglist
= TREE_OPERAND (exp
, 1);
2303 if (! validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2306 arg0
= TREE_VALUE (arglist
);
2307 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2309 if (TREE_CODE (arg1
) == REAL_CST
2310 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2312 REAL_VALUE_TYPE cint
;
2316 c
= TREE_REAL_CST (arg1
);
2317 n
= real_to_integer (&c
);
2318 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
2319 if (real_identical (&c
, &cint
))
2321 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2322 Otherwise, check the number of multiplications required.
2323 Note that pow never sets errno for an integer exponent. */
2324 if ((n
>= -1 && n
<= 2)
2325 || (flag_unsafe_math_optimizations
2327 && powi_cost (n
) <= POWI_MAX_MULTS
))
2329 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2330 rtx op
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2331 op
= force_reg (mode
, op
);
2332 return expand_powi (op
, mode
, n
);
2337 if (! flag_unsafe_math_optimizations
)
2339 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
2342 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2343 if we failed the caller should emit a normal call, otherwise
2344 try to get the result in TARGET, if convenient. */
2347 expand_builtin_strlen (tree arglist
, rtx target
,
2348 enum machine_mode target_mode
)
2350 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
2355 tree len
, src
= TREE_VALUE (arglist
);
2356 rtx result
, src_reg
, char_rtx
, before_strlen
;
2357 enum machine_mode insn_mode
= target_mode
, char_mode
;
2358 enum insn_code icode
= CODE_FOR_nothing
;
2361 /* If the length can be computed at compile-time, return it. */
2362 len
= c_strlen (src
, 0);
2364 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2366 /* If the length can be computed at compile-time and is constant
2367 integer, but there are side-effects in src, evaluate
2368 src for side-effects, then return len.
2369 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2370 can be optimized into: i++; x = 3; */
2371 len
= c_strlen (src
, 1);
2372 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
2374 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2375 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2378 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2380 /* If SRC is not a pointer type, don't do this operation inline. */
2384 /* Bail out if we can't compute strlen in the right mode. */
2385 while (insn_mode
!= VOIDmode
)
2387 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
2388 if (icode
!= CODE_FOR_nothing
)
2391 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
2393 if (insn_mode
== VOIDmode
)
2396 /* Make a place to write the result of the instruction. */
2400 && GET_MODE (result
) == insn_mode
2401 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2402 result
= gen_reg_rtx (insn_mode
);
2404 /* Make a place to hold the source address. We will not expand
2405 the actual source until we are sure that the expansion will
2406 not fail -- there are trees that cannot be expanded twice. */
2407 src_reg
= gen_reg_rtx (Pmode
);
2409 /* Mark the beginning of the strlen sequence so we can emit the
2410 source operand later. */
2411 before_strlen
= get_last_insn ();
2413 char_rtx
= const0_rtx
;
2414 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
2415 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
2417 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
2419 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
2420 char_rtx
, GEN_INT (align
));
2425 /* Now that we are assured of success, expand the source. */
2427 pat
= memory_address (BLKmode
,
2428 expand_expr (src
, src_reg
, ptr_mode
, EXPAND_SUM
));
2430 emit_move_insn (src_reg
, pat
);
2435 emit_insn_after (pat
, before_strlen
);
2437 emit_insn_before (pat
, get_insns ());
2439 /* Return the value in the proper mode for this function. */
2440 if (GET_MODE (result
) == target_mode
)
2442 else if (target
!= 0)
2443 convert_move (target
, result
, 0);
2445 target
= convert_to_mode (target_mode
, result
, 0);
2451 /* Expand a call to the strstr builtin. Return 0 if we failed the
2452 caller should emit a normal call, otherwise try to get the result
2453 in TARGET, if convenient (and in mode MODE if that's convenient). */
2456 expand_builtin_strstr (tree arglist
, rtx target
, enum machine_mode mode
)
2458 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2462 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2464 const char *p1
, *p2
;
2473 const char *r
= strstr (p1
, p2
);
2478 /* Return an offset into the constant string argument. */
2479 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2480 fold_convert (TREE_TYPE (s1
),
2481 ssize_int (r
- p1
))));
2482 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2486 return expand_expr (s1
, target
, mode
, EXPAND_NORMAL
);
2491 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2495 /* New argument list transforming strstr(s1, s2) to
2496 strchr(s1, s2[0]). */
2498 build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
2499 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
2500 return expand_expr (build_function_call_expr (fn
, arglist
),
2501 target
, mode
, EXPAND_NORMAL
);
2505 /* Expand a call to the strchr builtin. Return 0 if we failed the
2506 caller should emit a normal call, otherwise try to get the result
2507 in TARGET, if convenient (and in mode MODE if that's convenient). */
2510 expand_builtin_strchr (tree arglist
, rtx target
, enum machine_mode mode
)
2512 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2516 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2519 if (TREE_CODE (s2
) != INTEGER_CST
)
2529 if (target_char_cast (s2
, &c
))
2537 /* Return an offset into the constant string argument. */
2538 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2539 fold_convert (TREE_TYPE (s1
),
2540 ssize_int (r
- p1
))));
2541 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2544 /* FIXME: Should use here strchrM optab so that ports can optimize
2550 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2551 caller should emit a normal call, otherwise try to get the result
2552 in TARGET, if convenient (and in mode MODE if that's convenient). */
2555 expand_builtin_strrchr (tree arglist
, rtx target
, enum machine_mode mode
)
2557 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2561 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2565 if (TREE_CODE (s2
) != INTEGER_CST
)
2574 if (target_char_cast (s2
, &c
))
2577 r
= strrchr (p1
, c
);
2582 /* Return an offset into the constant string argument. */
2583 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2584 fold_convert (TREE_TYPE (s1
),
2585 ssize_int (r
- p1
))));
2586 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2589 if (! integer_zerop (s2
))
2592 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2596 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
2597 return expand_expr (build_function_call_expr (fn
, arglist
),
2598 target
, mode
, EXPAND_NORMAL
);
2602 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2603 caller should emit a normal call, otherwise try to get the result
2604 in TARGET, if convenient (and in mode MODE if that's convenient). */
2607 expand_builtin_strpbrk (tree arglist
, rtx target
, enum machine_mode mode
)
2609 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2613 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2615 const char *p1
, *p2
;
2624 const char *r
= strpbrk (p1
, p2
);
2629 /* Return an offset into the constant string argument. */
2630 tmp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
), s1
,
2631 fold_convert (TREE_TYPE (s1
),
2632 ssize_int (r
- p1
))));
2633 return expand_expr (tmp
, target
, mode
, EXPAND_NORMAL
);
2638 /* strpbrk(x, "") == NULL.
2639 Evaluate and ignore the arguments in case they had
2641 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2646 return 0; /* Really call strpbrk. */
2648 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
2652 /* New argument list transforming strpbrk(s1, s2) to
2653 strchr(s1, s2[0]). */
2655 build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
2656 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
2657 return expand_expr (build_function_call_expr (fn
, arglist
),
2658 target
, mode
, EXPAND_NORMAL
);
2662 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2663 bytes from constant string DATA + OFFSET and return it as target
2667 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
2668 enum machine_mode mode
)
2670 const char *str
= (const char *) data
;
2673 || ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
2674 > strlen (str
) + 1))
2675 abort (); /* Attempt to read past the end of constant string. */
2677 return c_readstr (str
+ offset
, mode
);
2680 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2681 Return 0 if we failed, the caller should emit a normal call,
2682 otherwise try to get the result in TARGET, if convenient (and in
2683 mode MODE if that's convenient). */
2685 expand_builtin_memcpy (tree arglist
, rtx target
, enum machine_mode mode
)
2687 if (!validate_arglist (arglist
,
2688 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2692 tree dest
= TREE_VALUE (arglist
);
2693 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2694 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2695 const char *src_str
;
2696 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2697 unsigned int dest_align
2698 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2699 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
2701 /* If DEST is not a pointer type, call the normal function. */
2702 if (dest_align
== 0)
2705 /* If the LEN parameter is zero, return DEST. */
2706 if (integer_zerop (len
))
2708 /* Evaluate and ignore SRC in case it has side-effects. */
2709 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2710 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2713 /* If SRC and DEST are the same (and not volatile), return DEST. */
2714 if (operand_equal_p (src
, dest
, 0))
2716 /* Evaluate and ignore LEN in case it has side-effects. */
2717 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2718 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2721 /* If either SRC is not a pointer type, don't do this
2722 operation in-line. */
2726 dest_mem
= get_memory_rtx (dest
);
2727 set_mem_align (dest_mem
, dest_align
);
2728 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2729 src_str
= c_getstr (src
);
2731 /* If SRC is a string constant and block move would be done
2732 by pieces, we can avoid loading the string from memory
2733 and only stored the computed constants. */
2735 && GET_CODE (len_rtx
) == CONST_INT
2736 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2737 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2738 (void *) src_str
, dest_align
))
2740 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2741 builtin_memcpy_read_str
,
2742 (void *) src_str
, dest_align
, 0);
2743 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2744 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2748 src_mem
= get_memory_rtx (src
);
2749 set_mem_align (src_mem
, src_align
);
2751 /* Copy word part most expediently. */
2752 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
,
2757 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2758 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
2764 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2765 Return 0 if we failed the caller should emit a normal call,
2766 otherwise try to get the result in TARGET, if convenient (and in
2767 mode MODE if that's convenient). If ENDP is 0 return the
2768 destination pointer, if ENDP is 1 return the end pointer ala
2769 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2773 expand_builtin_mempcpy (tree arglist
, rtx target
, enum machine_mode mode
,
2776 if (!validate_arglist (arglist
,
2777 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2779 /* If return value is ignored, transform mempcpy into memcpy. */
2780 else if (target
== const0_rtx
)
2782 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2787 return expand_expr (build_function_call_expr (fn
, arglist
),
2788 target
, mode
, EXPAND_NORMAL
);
2792 tree dest
= TREE_VALUE (arglist
);
2793 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2794 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2795 const char *src_str
;
2796 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2797 unsigned int dest_align
2798 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2799 rtx dest_mem
, src_mem
, len_rtx
;
2801 /* If DEST is not a pointer type, call the normal function. */
2802 if (dest_align
== 0)
2805 /* If SRC and DEST are the same (and not volatile), do nothing. */
2806 if (operand_equal_p (src
, dest
, 0))
2812 /* Evaluate and ignore LEN in case it has side-effects. */
2813 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2814 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2818 len
= fold (build2 (MINUS_EXPR
, TREE_TYPE (len
), len
,
2820 len
= fold_convert (TREE_TYPE (dest
), len
);
2821 expr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
));
2822 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
2825 /* If LEN is not constant, call the normal function. */
2826 if (! host_integerp (len
, 1))
2829 /* If the LEN parameter is zero, return DEST. */
2830 if (tree_low_cst (len
, 1) == 0)
2832 /* Evaluate and ignore SRC in case it has side-effects. */
2833 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2834 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2837 /* If either SRC is not a pointer type, don't do this
2838 operation in-line. */
2842 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2843 src_str
= c_getstr (src
);
2845 /* If SRC is a string constant and block move would be done
2846 by pieces, we can avoid loading the string from memory
2847 and only stored the computed constants. */
2849 && GET_CODE (len_rtx
) == CONST_INT
2850 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2851 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2852 (void *) src_str
, dest_align
))
2854 dest_mem
= get_memory_rtx (dest
);
2855 set_mem_align (dest_mem
, dest_align
);
2856 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2857 builtin_memcpy_read_str
,
2858 (void *) src_str
, dest_align
, endp
);
2859 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2860 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2864 if (GET_CODE (len_rtx
) == CONST_INT
2865 && can_move_by_pieces (INTVAL (len_rtx
),
2866 MIN (dest_align
, src_align
)))
2868 dest_mem
= get_memory_rtx (dest
);
2869 set_mem_align (dest_mem
, dest_align
);
2870 src_mem
= get_memory_rtx (src
);
2871 set_mem_align (src_mem
, src_align
);
2872 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
2873 MIN (dest_align
, src_align
), endp
);
2874 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2875 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2883 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2884 if we failed the caller should emit a normal call. */
2887 expand_builtin_memmove (tree arglist
, rtx target
, enum machine_mode mode
)
2889 if (!validate_arglist (arglist
,
2890 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2894 tree dest
= TREE_VALUE (arglist
);
2895 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2896 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2898 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2899 unsigned int dest_align
2900 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2902 /* If DEST is not a pointer type, call the normal function. */
2903 if (dest_align
== 0)
2906 /* If the LEN parameter is zero, return DEST. */
2907 if (integer_zerop (len
))
2909 /* Evaluate and ignore SRC in case it has side-effects. */
2910 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2911 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2914 /* If SRC and DEST are the same (and not volatile), return DEST. */
2915 if (operand_equal_p (src
, dest
, 0))
2917 /* Evaluate and ignore LEN in case it has side-effects. */
2918 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2919 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2922 /* If either SRC is not a pointer type, don't do this
2923 operation in-line. */
2927 /* If src is categorized for a readonly section we can use
2929 if (readonly_data_expr (src
))
2931 tree
const fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2934 return expand_expr (build_function_call_expr (fn
, arglist
),
2935 target
, mode
, EXPAND_NORMAL
);
2938 /* Otherwise, call the normal function. */
2943 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
2944 if we failed the caller should emit a normal call. */
2947 expand_builtin_bcopy (tree arglist
)
2949 tree src
, dest
, size
, newarglist
;
2951 if (!validate_arglist (arglist
,
2952 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2955 src
= TREE_VALUE (arglist
);
2956 dest
= TREE_VALUE (TREE_CHAIN (arglist
));
2957 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2959 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
2960 memmove(ptr y, ptr x, size_t z). This is done this way
2961 so that if it isn't expanded inline, we fallback to
2962 calling bcopy instead of memmove. */
2964 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
2965 newarglist
= tree_cons (NULL_TREE
, src
, newarglist
);
2966 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
2968 return expand_builtin_memmove (newarglist
, const0_rtx
, VOIDmode
);
2972 # define HAVE_movstr 0
2973 # define CODE_FOR_movstr CODE_FOR_nothing
2976 /* Expand into a movstr instruction, if one is available. Return 0 if
2977 we failed, the caller should emit a normal call, otherwise try to
2978 get the result in TARGET, if convenient. If ENDP is 0 return the
2979 destination pointer, if ENDP is 1 return the end pointer ala
2980 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2984 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
2990 const struct insn_data
* data
;
2995 dest_mem
= get_memory_rtx (dest
);
2996 src_mem
= get_memory_rtx (src
);
2999 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3000 dest_mem
= replace_equiv_address (dest_mem
, target
);
3001 end
= gen_reg_rtx (Pmode
);
3005 if (target
== 0 || target
== const0_rtx
)
3007 end
= gen_reg_rtx (Pmode
);
3015 data
= insn_data
+ CODE_FOR_movstr
;
3017 if (data
->operand
[0].mode
!= VOIDmode
)
3018 end
= gen_lowpart (data
->operand
[0].mode
, end
);
3020 insn
= data
->genfun (end
, dest_mem
, src_mem
);
3027 /* movstr is supposed to set end to the address of the NUL
3028 terminator. If the caller requested a mempcpy-like return value,
3030 if (endp
== 1 && target
!= const0_rtx
)
3031 emit_move_insn (target
, plus_constant (gen_lowpart (GET_MODE (target
),
3037 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
3038 if we failed the caller should emit a normal call, otherwise try to get
3039 the result in TARGET, if convenient (and in mode MODE if that's
3043 expand_builtin_strcpy (tree arglist
, rtx target
, enum machine_mode mode
)
3045 tree fn
, len
, src
, dst
;
3047 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3050 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3051 dst
= TREE_VALUE (arglist
);
3053 /* If SRC and DST are equal (and not volatile), return DST. */
3054 if (operand_equal_p (src
, dst
, 0))
3055 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3057 len
= c_strlen (src
, 1);
3058 if (len
== 0 || TREE_SIDE_EFFECTS (len
))
3059 return expand_movstr (TREE_VALUE (arglist
),
3060 TREE_VALUE (TREE_CHAIN (arglist
)),
3061 target
, /*endp=*/0);
3063 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3067 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3068 arglist
= build_tree_list (NULL_TREE
, len
);
3069 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
3070 arglist
= tree_cons (NULL_TREE
, dst
, arglist
);
3071 return expand_expr (build_function_call_expr (fn
, arglist
),
3072 target
, mode
, EXPAND_NORMAL
);
3075 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3076 Return 0 if we failed the caller should emit a normal call,
3077 otherwise try to get the result in TARGET, if convenient (and in
3078 mode MODE if that's convenient). */
3081 expand_builtin_stpcpy (tree arglist
, rtx target
, enum machine_mode mode
)
3083 /* If return value is ignored, transform stpcpy into strcpy. */
3084 if (target
== const0_rtx
)
3086 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
3090 return expand_expr (build_function_call_expr (fn
, arglist
),
3091 target
, mode
, EXPAND_NORMAL
);
3094 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3098 tree dst
, src
, len
, lenp1
;
3102 /* Ensure we get an actual string whose length can be evaluated at
3103 compile-time, not an expression containing a string. This is
3104 because the latter will potentially produce pessimized code
3105 when used to produce the return value. */
3106 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3107 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3108 return expand_movstr (TREE_VALUE (arglist
),
3109 TREE_VALUE (TREE_CHAIN (arglist
)),
3110 target
, /*endp=*/2);
3112 dst
= TREE_VALUE (arglist
);
3113 lenp1
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3114 narglist
= build_tree_list (NULL_TREE
, lenp1
);
3115 narglist
= tree_cons (NULL_TREE
, src
, narglist
);
3116 narglist
= tree_cons (NULL_TREE
, dst
, narglist
);
3117 ret
= expand_builtin_mempcpy (narglist
, target
, mode
, /*endp=*/2);
3122 if (TREE_CODE (len
) == INTEGER_CST
)
3124 rtx len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3126 if (GET_CODE (len_rtx
) == CONST_INT
)
3128 ret
= expand_builtin_strcpy (arglist
, target
, mode
);
3133 target
= gen_reg_rtx (mode
);
3134 if (GET_MODE (target
) != GET_MODE (ret
))
3135 ret
= gen_lowpart (GET_MODE (target
), ret
);
3137 ret
= emit_move_insn (target
,
3148 return expand_movstr (TREE_VALUE (arglist
),
3149 TREE_VALUE (TREE_CHAIN (arglist
)),
3150 target
, /*endp=*/2);
3154 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3155 bytes from constant string DATA + OFFSET and return it as target
3159 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3160 enum machine_mode mode
)
3162 const char *str
= (const char *) data
;
3164 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3167 return c_readstr (str
+ offset
, mode
);
3170 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3171 if we failed the caller should emit a normal call. */
3174 expand_builtin_strncpy (tree arglist
, rtx target
, enum machine_mode mode
)
3176 if (!validate_arglist (arglist
,
3177 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3181 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)), 1);
3182 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3185 /* We must be passed a constant len parameter. */
3186 if (TREE_CODE (len
) != INTEGER_CST
)
3189 /* If the len parameter is zero, return the dst parameter. */
3190 if (integer_zerop (len
))
3192 /* Evaluate and ignore the src argument in case it has
3194 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
3195 VOIDmode
, EXPAND_NORMAL
);
3196 /* Return the dst parameter. */
3197 return expand_expr (TREE_VALUE (arglist
), target
, mode
,
3201 /* Now, we must be passed a constant src ptr parameter. */
3202 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
3205 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
3207 /* We're required to pad with trailing zeros if the requested
3208 len is greater than strlen(s2)+1. In that case try to
3209 use store_by_pieces, if it fails, punt. */
3210 if (tree_int_cst_lt (slen
, len
))
3212 tree dest
= TREE_VALUE (arglist
);
3213 unsigned int dest_align
3214 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3215 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
3218 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3219 || !can_store_by_pieces (tree_low_cst (len
, 1),
3220 builtin_strncpy_read_str
,
3221 (void *) p
, dest_align
))
3224 dest_mem
= get_memory_rtx (dest
);
3225 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3226 builtin_strncpy_read_str
,
3227 (void *) p
, dest_align
, 0);
3228 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3229 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3233 /* OK transform into builtin memcpy. */
3234 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3237 return expand_expr (build_function_call_expr (fn
, arglist
),
3238 target
, mode
, EXPAND_NORMAL
);
3242 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3243 bytes from constant string DATA + OFFSET and return it as target
3247 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3248 enum machine_mode mode
)
3250 const char *c
= (const char *) data
;
3251 char *p
= alloca (GET_MODE_SIZE (mode
));
3253 memset (p
, *c
, GET_MODE_SIZE (mode
));
3255 return c_readstr (p
, mode
);
3258 /* Callback routine for store_by_pieces. Return the RTL of a register
3259 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3260 char value given in the RTL register data. For example, if mode is
3261 4 bytes wide, return the RTL for 0x01010101*data. */
3264 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3265 enum machine_mode mode
)
3271 size
= GET_MODE_SIZE (mode
);
3276 memset (p
, 1, size
);
3277 coeff
= c_readstr (p
, mode
);
3279 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3280 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3281 return force_reg (mode
, target
);
3284 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3285 if we failed the caller should emit a normal call, otherwise try to get
3286 the result in TARGET, if convenient (and in mode MODE if that's
3290 expand_builtin_memset (tree arglist
, rtx target
, enum machine_mode mode
)
3292 if (!validate_arglist (arglist
,
3293 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3297 tree dest
= TREE_VALUE (arglist
);
3298 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
3299 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3302 unsigned int dest_align
3303 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3304 rtx dest_mem
, dest_addr
, len_rtx
;
3306 /* If DEST is not a pointer type, don't do this
3307 operation in-line. */
3308 if (dest_align
== 0)
3311 /* If the LEN parameter is zero, return DEST. */
3312 if (integer_zerop (len
))
3314 /* Evaluate and ignore VAL in case it has side-effects. */
3315 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3316 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3319 if (TREE_CODE (val
) != INTEGER_CST
)
3323 if (!host_integerp (len
, 1))
3326 if (optimize_size
&& tree_low_cst (len
, 1) > 1)
3329 /* Assume that we can memset by pieces if we can store the
3330 * the coefficients by pieces (in the required modes).
3331 * We can't pass builtin_memset_gen_str as that emits RTL. */
3333 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3334 builtin_memset_read_str
,
3338 val
= fold (build1 (CONVERT_EXPR
, unsigned_char_type_node
, val
));
3339 val_rtx
= expand_expr (val
, NULL_RTX
, VOIDmode
, 0);
3340 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3342 dest_mem
= get_memory_rtx (dest
);
3343 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3344 builtin_memset_gen_str
,
3345 val_rtx
, dest_align
, 0);
3346 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3347 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3351 if (target_char_cast (val
, &c
))
3356 if (!host_integerp (len
, 1))
3358 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3359 builtin_memset_read_str
, &c
,
3363 dest_mem
= get_memory_rtx (dest
);
3364 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3365 builtin_memset_read_str
,
3367 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3368 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3372 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3374 dest_mem
= get_memory_rtx (dest
);
3375 set_mem_align (dest_mem
, dest_align
);
3376 dest_addr
= clear_storage (dest_mem
, len_rtx
);
3380 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3381 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3388 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3389 if we failed the caller should emit a normal call. */
3392 expand_builtin_bzero (tree arglist
)
3394 tree dest
, size
, newarglist
;
3396 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3399 dest
= TREE_VALUE (arglist
);
3400 size
= TREE_VALUE (TREE_CHAIN (arglist
));
3402 /* New argument list transforming bzero(ptr x, int y) to
3403 memset(ptr x, int 0, size_t y). This is done this way
3404 so that if it isn't expanded inline, we fallback to
3405 calling bzero instead of memset. */
3407 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3408 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
3409 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3411 return expand_builtin_memset (newarglist
, const0_rtx
, VOIDmode
);
3414 /* Expand expression EXP, which is a call to the memcmp built-in function.
3415 ARGLIST is the argument list for this call. Return 0 if we failed and the
3416 caller should emit a normal call, otherwise try to get the result in
3417 TARGET, if convenient (and in mode MODE, if that's convenient). */
3420 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED
, tree arglist
, rtx target
,
3421 enum machine_mode mode
)
3423 tree arg1
, arg2
, len
;
3424 const char *p1
, *p2
;
3426 if (!validate_arglist (arglist
,
3427 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3430 arg1
= TREE_VALUE (arglist
);
3431 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3432 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3434 /* If the len parameter is zero, return zero. */
3435 if (integer_zerop (len
))
3437 /* Evaluate and ignore arg1 and arg2 in case they have
3439 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3440 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3444 /* If both arguments are equal (and not volatile), return zero. */
3445 if (operand_equal_p (arg1
, arg2
, 0))
3447 /* Evaluate and ignore len in case it has side-effects. */
3448 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3452 p1
= c_getstr (arg1
);
3453 p2
= c_getstr (arg2
);
3455 /* If all arguments are constant, and the value of len is not greater
3456 than the lengths of arg1 and arg2, evaluate at compile-time. */
3457 if (host_integerp (len
, 1) && p1
&& p2
3458 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
3459 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
3461 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
3463 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
3466 /* If len parameter is one, return an expression corresponding to
3467 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3468 if (integer_onep (len
))
3470 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3471 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3473 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3474 build1 (INDIRECT_REF
, cst_uchar_node
,
3475 fold_convert (cst_uchar_ptr_node
, arg1
))));
3477 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3478 build1 (INDIRECT_REF
, cst_uchar_node
,
3479 fold_convert (cst_uchar_ptr_node
, arg2
))));
3480 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3481 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3484 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
3486 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3491 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3493 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3494 enum machine_mode insn_mode
;
3496 #ifdef HAVE_cmpmemsi
3498 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3501 #ifdef HAVE_cmpstrsi
3503 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3508 /* If we don't have POINTER_TYPE, call the function. */
3509 if (arg1_align
== 0 || arg2_align
== 0)
3512 /* Make a place to write the result of the instruction. */
3515 && REG_P (result
) && GET_MODE (result
) == insn_mode
3516 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3517 result
= gen_reg_rtx (insn_mode
);
3519 arg1_rtx
= get_memory_rtx (arg1
);
3520 arg2_rtx
= get_memory_rtx (arg2
);
3521 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3522 #ifdef HAVE_cmpmemsi
3524 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3525 GEN_INT (MIN (arg1_align
, arg2_align
)));
3528 #ifdef HAVE_cmpstrsi
3530 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3531 GEN_INT (MIN (arg1_align
, arg2_align
)));
3539 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
3540 TYPE_MODE (integer_type_node
), 3,
3541 XEXP (arg1_rtx
, 0), Pmode
,
3542 XEXP (arg2_rtx
, 0), Pmode
,
3543 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3544 TYPE_UNSIGNED (sizetype
)),
3545 TYPE_MODE (sizetype
));
3547 /* Return the value in the proper mode for this function. */
3548 mode
= TYPE_MODE (TREE_TYPE (exp
));
3549 if (GET_MODE (result
) == mode
)
3551 else if (target
!= 0)
3553 convert_move (target
, result
, 0);
3557 return convert_to_mode (mode
, result
, 0);
3564 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3565 if we failed the caller should emit a normal call, otherwise try to get
3566 the result in TARGET, if convenient. */
3569 expand_builtin_strcmp (tree exp
, rtx target
, enum machine_mode mode
)
3571 tree arglist
= TREE_OPERAND (exp
, 1);
3573 const char *p1
, *p2
;
3575 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3578 arg1
= TREE_VALUE (arglist
);
3579 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3581 /* If both arguments are equal (and not volatile), return zero. */
3582 if (operand_equal_p (arg1
, arg2
, 0))
3585 p1
= c_getstr (arg1
);
3586 p2
= c_getstr (arg2
);
3590 const int i
= strcmp (p1
, p2
);
3591 return (i
< 0 ? constm1_rtx
: (i
> 0 ? const1_rtx
: const0_rtx
));
3594 /* If either arg is "", return an expression corresponding to
3595 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3596 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
3598 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3599 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3601 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3602 build1 (INDIRECT_REF
, cst_uchar_node
,
3603 fold_convert (cst_uchar_ptr_node
, arg1
))));
3605 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3606 build1 (INDIRECT_REF
, cst_uchar_node
,
3607 fold_convert (cst_uchar_ptr_node
, arg2
))));
3608 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3609 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3612 #ifdef HAVE_cmpstrsi
3615 tree len
, len1
, len2
;
3616 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3621 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3623 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3624 enum machine_mode insn_mode
3625 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3627 len1
= c_strlen (arg1
, 1);
3628 len2
= c_strlen (arg2
, 1);
3631 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3633 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3635 /* If we don't have a constant length for the first, use the length
3636 of the second, if we know it. We don't require a constant for
3637 this case; some cost analysis could be done if both are available
3638 but neither is constant. For now, assume they're equally cheap,
3639 unless one has side effects. If both strings have constant lengths,
3646 else if (TREE_SIDE_EFFECTS (len1
))
3648 else if (TREE_SIDE_EFFECTS (len2
))
3650 else if (TREE_CODE (len1
) != INTEGER_CST
)
3652 else if (TREE_CODE (len2
) != INTEGER_CST
)
3654 else if (tree_int_cst_lt (len1
, len2
))
3659 /* If both arguments have side effects, we cannot optimize. */
3660 if (!len
|| TREE_SIDE_EFFECTS (len
))
3663 /* If we don't have POINTER_TYPE, call the function. */
3664 if (arg1_align
== 0 || arg2_align
== 0)
3667 /* Make a place to write the result of the instruction. */
3670 && REG_P (result
) && GET_MODE (result
) == insn_mode
3671 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3672 result
= gen_reg_rtx (insn_mode
);
3674 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3675 arg1
= builtin_save_expr (arg1
);
3676 arg2
= builtin_save_expr (arg2
);
3678 arg1_rtx
= get_memory_rtx (arg1
);
3679 arg2_rtx
= get_memory_rtx (arg2
);
3680 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3681 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3682 GEN_INT (MIN (arg1_align
, arg2_align
)));
3687 /* Return the value in the proper mode for this function. */
3688 mode
= TYPE_MODE (TREE_TYPE (exp
));
3689 if (GET_MODE (result
) == mode
)
3692 return convert_to_mode (mode
, result
, 0);
3693 convert_move (target
, result
, 0);
3697 /* Expand the library call ourselves using a stabilized argument
3698 list to avoid re-evaluating the function's arguments twice. */
3699 arglist
= build_tree_list (NULL_TREE
, arg2
);
3700 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3701 fndecl
= get_callee_fndecl (exp
);
3702 exp
= build_function_call_expr (fndecl
, arglist
);
3703 return expand_call (exp
, target
, target
== const0_rtx
);
3709 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3710 if we failed the caller should emit a normal call, otherwise try to get
3711 the result in TARGET, if convenient. */
3714 expand_builtin_strncmp (tree exp
, rtx target
, enum machine_mode mode
)
3716 tree arglist
= TREE_OPERAND (exp
, 1);
3717 tree arg1
, arg2
, arg3
;
3718 const char *p1
, *p2
;
3720 if (!validate_arglist (arglist
,
3721 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3724 arg1
= TREE_VALUE (arglist
);
3725 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3726 arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3728 /* If the len parameter is zero, return zero. */
3729 if (integer_zerop (arg3
))
3731 /* Evaluate and ignore arg1 and arg2 in case they have
3733 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3734 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3738 /* If arg1 and arg2 are equal (and not volatile), return zero. */
3739 if (operand_equal_p (arg1
, arg2
, 0))
3741 /* Evaluate and ignore arg3 in case it has side-effects. */
3742 expand_expr (arg3
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3746 p1
= c_getstr (arg1
);
3747 p2
= c_getstr (arg2
);
3749 /* If all arguments are constant, evaluate at compile-time. */
3750 if (host_integerp (arg3
, 1) && p1
&& p2
)
3752 const int r
= strncmp (p1
, p2
, tree_low_cst (arg3
, 1));
3753 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
3756 /* If len == 1 or (either string parameter is "" and (len >= 1)),
3757 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
3758 if (host_integerp (arg3
, 1)
3759 && (tree_low_cst (arg3
, 1) == 1
3760 || (tree_low_cst (arg3
, 1) > 1
3761 && ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0')))))
3763 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
3764 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
3766 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3767 build1 (INDIRECT_REF
, cst_uchar_node
,
3768 fold_convert (cst_uchar_ptr_node
, arg1
))));
3770 fold (build1 (CONVERT_EXPR
, integer_type_node
,
3771 build1 (INDIRECT_REF
, cst_uchar_node
,
3772 fold_convert (cst_uchar_ptr_node
, arg2
))));
3773 tree result
= fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
3774 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3777 /* If c_strlen can determine an expression for one of the string
3778 lengths, and it doesn't have side effects, then emit cmpstrsi
3779 using length MIN(strlen(string)+1, arg3). */
3780 #ifdef HAVE_cmpstrsi
3783 tree len
, len1
, len2
;
3784 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3789 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3791 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3792 enum machine_mode insn_mode
3793 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3795 len1
= c_strlen (arg1
, 1);
3796 len2
= c_strlen (arg2
, 1);
3799 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3801 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3803 /* If we don't have a constant length for the first, use the length
3804 of the second, if we know it. We don't require a constant for
3805 this case; some cost analysis could be done if both are available
3806 but neither is constant. For now, assume they're equally cheap,
3807 unless one has side effects. If both strings have constant lengths,
3814 else if (TREE_SIDE_EFFECTS (len1
))
3816 else if (TREE_SIDE_EFFECTS (len2
))
3818 else if (TREE_CODE (len1
) != INTEGER_CST
)
3820 else if (TREE_CODE (len2
) != INTEGER_CST
)
3822 else if (tree_int_cst_lt (len1
, len2
))
3827 /* If both arguments have side effects, we cannot optimize. */
3828 if (!len
|| TREE_SIDE_EFFECTS (len
))
3831 /* The actual new length parameter is MIN(len,arg3). */
3832 len
= fold (build2 (MIN_EXPR
, TREE_TYPE (len
), len
, arg3
));
3834 /* If we don't have POINTER_TYPE, call the function. */
3835 if (arg1_align
== 0 || arg2_align
== 0)
3838 /* Make a place to write the result of the instruction. */
3841 && REG_P (result
) && GET_MODE (result
) == insn_mode
3842 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3843 result
= gen_reg_rtx (insn_mode
);
3845 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3846 arg1
= builtin_save_expr (arg1
);
3847 arg2
= builtin_save_expr (arg2
);
3848 len
= builtin_save_expr (len
);
3850 arg1_rtx
= get_memory_rtx (arg1
);
3851 arg2_rtx
= get_memory_rtx (arg2
);
3852 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3853 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3854 GEN_INT (MIN (arg1_align
, arg2_align
)));
3859 /* Return the value in the proper mode for this function. */
3860 mode
= TYPE_MODE (TREE_TYPE (exp
));
3861 if (GET_MODE (result
) == mode
)
3864 return convert_to_mode (mode
, result
, 0);
3865 convert_move (target
, result
, 0);
3869 /* Expand the library call ourselves using a stabilized argument
3870 list to avoid re-evaluating the function's arguments twice. */
3871 arglist
= build_tree_list (NULL_TREE
, len
);
3872 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3873 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3874 fndecl
= get_callee_fndecl (exp
);
3875 exp
= build_function_call_expr (fndecl
, arglist
);
3876 return expand_call (exp
, target
, target
== const0_rtx
);
3882 /* Expand expression EXP, which is a call to the strcat builtin.
3883 Return 0 if we failed the caller should emit a normal call,
3884 otherwise try to get the result in TARGET, if convenient. */
3887 expand_builtin_strcat (tree arglist
, rtx target
, enum machine_mode mode
)
3889 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3893 tree dst
= TREE_VALUE (arglist
),
3894 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3895 const char *p
= c_getstr (src
);
3899 /* If the string length is zero, return the dst parameter. */
3901 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3902 else if (!optimize_size
)
3904 /* Otherwise if !optimize_size, see if we can store by
3905 pieces into (dst + strlen(dst)). */
3906 tree newdst
, arglist
,
3907 strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
3909 /* This is the length argument. */
3910 arglist
= build_tree_list (NULL_TREE
,
3911 fold (size_binop (PLUS_EXPR
,
3914 /* Prepend src argument. */
3915 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
3917 /* We're going to use dst more than once. */
3918 dst
= builtin_save_expr (dst
);
3920 /* Create strlen (dst). */
3922 fold (build_function_call_expr (strlen_fn
,
3923 build_tree_list (NULL_TREE
,
3925 /* Create (dst + strlen (dst)). */
3926 newdst
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dst
), dst
, newdst
));
3928 /* Prepend the new dst argument. */
3929 arglist
= tree_cons (NULL_TREE
, newdst
, arglist
);
3931 /* We don't want to get turned into a memcpy if the
3932 target is const0_rtx, i.e. when the return value
3933 isn't used. That would produce pessimized code so
3934 pass in a target of zero, it should never actually be
3935 used. If this was successful return the original
3936 dst, not the result of mempcpy. */
3937 if (expand_builtin_mempcpy (arglist
, /*target=*/0, mode
, /*endp=*/0))
3938 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3948 /* Expand expression EXP, which is a call to the strncat builtin.
3949 Return 0 if we failed the caller should emit a normal call,
3950 otherwise try to get the result in TARGET, if convenient. */
3953 expand_builtin_strncat (tree arglist
, rtx target
, enum machine_mode mode
)
3955 if (!validate_arglist (arglist
,
3956 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3960 tree dst
= TREE_VALUE (arglist
),
3961 src
= TREE_VALUE (TREE_CHAIN (arglist
)),
3962 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3963 const char *p
= c_getstr (src
);
3965 /* If the requested length is zero, or the src parameter string
3966 length is zero, return the dst parameter. */
3967 if (integer_zerop (len
) || (p
&& *p
== '\0'))
3969 /* Evaluate and ignore the src and len parameters in case
3970 they have side-effects. */
3971 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3972 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3973 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3976 /* If the requested len is greater than or equal to the string
3977 length, call strcat. */
3978 if (TREE_CODE (len
) == INTEGER_CST
&& p
3979 && compare_tree_int (len
, strlen (p
)) >= 0)
3982 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
3983 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
3985 /* If the replacement _DECL isn't initialized, don't do the
3990 return expand_expr (build_function_call_expr (fn
, newarglist
),
3991 target
, mode
, EXPAND_NORMAL
);
3997 /* Expand expression EXP, which is a call to the strspn builtin.
3998 Return 0 if we failed the caller should emit a normal call,
3999 otherwise try to get the result in TARGET, if convenient. */
4002 expand_builtin_strspn (tree arglist
, rtx target
, enum machine_mode mode
)
4004 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4008 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
4009 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
4011 /* If both arguments are constants, evaluate at compile-time. */
4014 const size_t r
= strspn (p1
, p2
);
4015 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
4018 /* If either argument is "", return 0. */
4019 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
4021 /* Evaluate and ignore both arguments in case either one has
4023 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4024 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4031 /* Expand expression EXP, which is a call to the strcspn builtin.
4032 Return 0 if we failed the caller should emit a normal call,
4033 otherwise try to get the result in TARGET, if convenient. */
4036 expand_builtin_strcspn (tree arglist
, rtx target
, enum machine_mode mode
)
4038 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4042 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
4043 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
4045 /* If both arguments are constants, evaluate at compile-time. */
4048 const size_t r
= strcspn (p1
, p2
);
4049 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
4052 /* If the first argument is "", return 0. */
4053 if (p1
&& *p1
== '\0')
4055 /* Evaluate and ignore argument s2 in case it has
4057 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4061 /* If the second argument is "", return __builtin_strlen(s1). */
4062 if (p2
&& *p2
== '\0')
4064 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
4065 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
4067 /* If the replacement _DECL isn't initialized, don't do the
4072 return expand_expr (build_function_call_expr (fn
, newarglist
),
4073 target
, mode
, EXPAND_NORMAL
);
4079 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4080 if that's convenient. */
4083 expand_builtin_saveregs (void)
4087 /* Don't do __builtin_saveregs more than once in a function.
4088 Save the result of the first call and reuse it. */
4089 if (saveregs_value
!= 0)
4090 return saveregs_value
;
4092 /* When this function is called, it means that registers must be
4093 saved on entry to this function. So we migrate the call to the
4094 first insn of this function. */
4098 /* Do whatever the machine needs done in this case. */
4099 val
= targetm
.calls
.expand_builtin_saveregs ();
4104 saveregs_value
= val
;
4106 /* Put the insns after the NOTE that starts the function. If this
4107 is inside a start_sequence, make the outer-level insn chain current, so
4108 the code is placed at the start of the function. */
4109 push_topmost_sequence ();
4110 emit_insn_after (seq
, entry_of_function ());
4111 pop_topmost_sequence ();
4116 /* __builtin_args_info (N) returns word N of the arg space info
4117 for the current function. The number and meanings of words
4118 is controlled by the definition of CUMULATIVE_ARGS. */
4121 expand_builtin_args_info (tree arglist
)
4123 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4124 int *word_ptr
= (int *) ¤t_function_args_info
;
4126 if (sizeof (CUMULATIVE_ARGS
) % sizeof (int) != 0)
4131 if (!host_integerp (TREE_VALUE (arglist
), 0))
4132 error ("argument of `__builtin_args_info' must be constant");
4135 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
4137 if (wordnum
< 0 || wordnum
>= nwords
)
4138 error ("argument of `__builtin_args_info' out of range");
4140 return GEN_INT (word_ptr
[wordnum
]);
4144 error ("missing argument in `__builtin_args_info'");
4149 /* Expand ARGLIST, from a call to __builtin_next_arg. */
4152 expand_builtin_next_arg (tree arglist
)
4154 tree fntype
= TREE_TYPE (current_function_decl
);
4156 if (TYPE_ARG_TYPES (fntype
) == 0
4157 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
4160 error ("`va_start' used in function with fixed args");
4166 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
4167 tree arg
= TREE_VALUE (arglist
);
4169 /* Strip off all nops for the sake of the comparison. This
4170 is not quite the same as STRIP_NOPS. It does more.
4171 We must also strip off INDIRECT_EXPR for C++ reference
4173 while (TREE_CODE (arg
) == NOP_EXPR
4174 || TREE_CODE (arg
) == CONVERT_EXPR
4175 || TREE_CODE (arg
) == NON_LVALUE_EXPR
4176 || TREE_CODE (arg
) == INDIRECT_REF
)
4177 arg
= TREE_OPERAND (arg
, 0);
4178 if (arg
!= last_parm
)
4179 warning ("second parameter of `va_start' not last named argument");
4182 /* Evidently an out of date version of <stdarg.h>; can't validate
4183 va_start's second argument, but can still work as intended. */
4184 warning ("`__builtin_next_arg' called without an argument");
4186 return expand_binop (Pmode
, add_optab
,
4187 current_function_internal_arg_pointer
,
4188 current_function_arg_offset_rtx
,
4189 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4192 /* Make it easier for the backends by protecting the valist argument
4193 from multiple evaluations. */
4196 stabilize_va_list (tree valist
, int needs_lvalue
)
4198 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4200 if (TREE_SIDE_EFFECTS (valist
))
4201 valist
= save_expr (valist
);
4203 /* For this case, the backends will be expecting a pointer to
4204 TREE_TYPE (va_list_type_node), but it's possible we've
4205 actually been given an array (an actual va_list_type_node).
4207 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4209 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4210 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4219 if (! TREE_SIDE_EFFECTS (valist
))
4222 pt
= build_pointer_type (va_list_type_node
);
4223 valist
= fold (build1 (ADDR_EXPR
, pt
, valist
));
4224 TREE_SIDE_EFFECTS (valist
) = 1;
4227 if (TREE_SIDE_EFFECTS (valist
))
4228 valist
= save_expr (valist
);
4229 valist
= build_fold_indirect_ref (valist
);
4235 /* The "standard" definition of va_list is void*. */
4238 std_build_builtin_va_list (void)
4240 return ptr_type_node
;
4243 /* The "standard" implementation of va_start: just assign `nextarg' to
4247 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4251 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4252 make_tree (ptr_type_node
, nextarg
));
4253 TREE_SIDE_EFFECTS (t
) = 1;
4255 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4258 /* Expand ARGLIST, from a call to __builtin_va_start. */
4261 expand_builtin_va_start (tree arglist
)
4266 chain
= TREE_CHAIN (arglist
);
4268 if (TREE_CHAIN (chain
))
4269 error ("too many arguments to function `va_start'");
4271 nextarg
= expand_builtin_next_arg (chain
);
4272 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
4274 #ifdef EXPAND_BUILTIN_VA_START
4275 EXPAND_BUILTIN_VA_START (valist
, nextarg
);
4277 std_expand_builtin_va_start (valist
, nextarg
);
4283 /* The "standard" implementation of va_arg: read the value from the
4284 current (padded) address and increment by the (padded) size. */
4287 std_expand_builtin_va_arg (tree valist
, tree type
)
4289 tree addr_tree
, t
, type_size
= NULL
;
4290 tree align
, alignm1
;
4293 HOST_WIDE_INT boundary
;
4295 /* Compute the rounded size of the type. */
4296 align
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
);
4297 alignm1
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
- 1);
4298 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
);
4300 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4301 requires greater alignment, we must perform dynamic alignment. */
4303 if (boundary
> PARM_BOUNDARY
)
4305 if (!PAD_VARARGS_DOWN
)
4307 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4308 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
4309 build_int_2 (boundary
/ BITS_PER_UNIT
- 1, 0)));
4310 TREE_SIDE_EFFECTS (t
) = 1;
4311 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4313 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4314 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist
,
4315 build_int_2 (~(boundary
/ BITS_PER_UNIT
- 1), -1)));
4316 TREE_SIDE_EFFECTS (t
) = 1;
4317 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4319 if (type
== error_mark_node
4320 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
4321 || TREE_OVERFLOW (type_size
))
4322 rounded_size
= size_zero_node
;
4325 rounded_size
= fold (build2 (PLUS_EXPR
, sizetype
, type_size
, alignm1
));
4326 rounded_size
= fold (build2 (TRUNC_DIV_EXPR
, sizetype
,
4327 rounded_size
, align
));
4328 rounded_size
= fold (build2 (MULT_EXPR
, sizetype
,
4329 rounded_size
, align
));
4334 if (PAD_VARARGS_DOWN
&& ! integer_zerop (rounded_size
))
4336 /* Small args are padded downward. */
4337 addr_tree
= fold (build2 (PLUS_EXPR
, TREE_TYPE (addr_tree
), addr_tree
,
4338 fold (build3 (COND_EXPR
, sizetype
,
4339 fold (build2 (GT_EXPR
, sizetype
,
4343 fold (build2 (MINUS_EXPR
,
4349 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4350 addr
= copy_to_reg (addr
);
4352 /* Compute new value for AP. */
4353 if (! integer_zerop (rounded_size
))
4355 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4356 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
4358 TREE_SIDE_EFFECTS (t
) = 1;
4359 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4365 /* Expand __builtin_va_arg, which is not really a builtin function, but
4366 a very special sort of operator. */
4369 expand_builtin_va_arg (tree valist
, tree type
)
4372 tree promoted_type
, want_va_type
, have_va_type
;
4374 /* Verify that valist is of the proper type. */
4376 want_va_type
= va_list_type_node
;
4377 have_va_type
= TREE_TYPE (valist
);
4378 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4380 /* If va_list is an array type, the argument may have decayed
4381 to a pointer type, e.g. by being passed to another function.
4382 In that case, unwrap both types so that we can compare the
4383 underlying records. */
4384 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4385 || TREE_CODE (have_va_type
) == POINTER_TYPE
)
4387 want_va_type
= TREE_TYPE (want_va_type
);
4388 have_va_type
= TREE_TYPE (have_va_type
);
4391 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4393 error ("first argument to `va_arg' not of type `va_list'");
4397 /* Generate a diagnostic for requesting data of a type that cannot
4398 be passed through `...' due to type promotion at the call site. */
4399 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4402 const char *name
= "<anonymous type>", *pname
= 0;
4403 static bool gave_help
;
4405 if (TYPE_NAME (type
))
4407 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
4408 name
= IDENTIFIER_POINTER (TYPE_NAME (type
));
4409 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
4410 && DECL_NAME (TYPE_NAME (type
)))
4411 name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
4413 if (TYPE_NAME (promoted_type
))
4415 if (TREE_CODE (TYPE_NAME (promoted_type
)) == IDENTIFIER_NODE
)
4416 pname
= IDENTIFIER_POINTER (TYPE_NAME (promoted_type
));
4417 else if (TREE_CODE (TYPE_NAME (promoted_type
)) == TYPE_DECL
4418 && DECL_NAME (TYPE_NAME (promoted_type
)))
4419 pname
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type
)));
4422 /* Unfortunately, this is merely undefined, rather than a constraint
4423 violation, so we cannot make this an error. If this call is never
4424 executed, the program is still strictly conforming. */
4425 warning ("`%s' is promoted to `%s' when passed through `...'",
4430 warning ("(so you should pass `%s' not `%s' to `va_arg')",
4434 /* We can, however, treat "undefined" any way we please.
4435 Call abort to encourage the user to fix the program. */
4436 inform ("if this code is reached, the program will abort");
4437 expand_builtin_trap ();
4439 /* This is dead code, but go ahead and finish so that the
4440 mode of the result comes out right. */
4445 /* Make it easier for the backends by protecting the valist argument
4446 from multiple evaluations. */
4447 valist
= stabilize_va_list (valist
, 0);
4449 #ifdef EXPAND_BUILTIN_VA_ARG
4450 addr
= EXPAND_BUILTIN_VA_ARG (valist
, type
);
4452 addr
= std_expand_builtin_va_arg (valist
, type
);
4456 addr
= convert_memory_address (Pmode
, addr
);
4458 result
= gen_rtx_MEM (TYPE_MODE (type
), addr
);
4459 set_mem_alias_set (result
, get_varargs_alias_set ());
4464 /* Like std_expand_builtin_va_arg, but gimplify instead of expanding. */
4467 std_gimplify_va_arg_expr (tree valist
, tree type
, tree
*pre_p
, tree
*post_p
)
4469 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
4470 unsigned HOST_WIDE_INT align
, boundary
;
4473 #ifdef ARGS_GROW_DOWNWARD
4474 /* All of the alignment and movement below is for args-grow-up machines.
4475 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4476 implement their own specialized gimplify_va_arg_expr routines. */
4480 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
4482 type
= build_pointer_type (type
);
4484 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
4485 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
) / BITS_PER_UNIT
;
4487 /* Hoist the valist value into a temporary for the moment. */
4488 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
4490 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4491 requires greater alignment, we must perform dynamic alignment. */
4492 if (boundary
> align
)
4494 t
= fold_convert (TREE_TYPE (valist
), size_int (boundary
- 1));
4495 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4496 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4497 gimplify_and_add (t
, pre_p
);
4499 t
= fold_convert (TREE_TYPE (valist
), size_int (-boundary
));
4500 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4501 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4502 gimplify_and_add (t
, pre_p
);
4505 /* Compute the rounded size of the type. */
4506 type_size
= size_in_bytes (type
);
4507 rounded_size
= round_up (type_size
, align
);
4509 /* Reduce rounded_size so it's sharable with the postqueue. */
4510 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4514 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
4516 /* Small args are padded downward. */
4517 t
= fold (build2 (GT_EXPR
, sizetype
, rounded_size
, size_int (align
)));
4518 t
= fold (build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4519 size_binop (MINUS_EXPR
, rounded_size
, type_size
)));
4520 t
= fold_convert (TREE_TYPE (addr
), t
);
4521 addr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (addr
), addr
, t
));
4524 /* Compute new value for AP. */
4525 t
= fold_convert (TREE_TYPE (valist
), rounded_size
);
4526 t
= build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
);
4527 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4528 gimplify_and_add (t
, pre_p
);
4530 addr
= fold_convert (build_pointer_type (type
), addr
);
4533 addr
= build_fold_indirect_ref (addr
);
4535 return build_fold_indirect_ref (addr
);
4538 /* Return a dummy expression of type TYPE in order to keep going after an
4542 dummy_object (tree type
)
4544 tree t
= convert (build_pointer_type (type
), null_pointer_node
);
4545 return build1 (INDIRECT_REF
, type
, t
);
4548 /* Like expand_builtin_va_arg, but gimplify instead of expanding. */
4550 enum gimplify_status
4551 gimplify_va_arg_expr (tree
*expr_p
, tree
*pre_p
, tree
*post_p
)
4553 tree promoted_type
, want_va_type
, have_va_type
;
4554 tree valist
= TREE_OPERAND (*expr_p
, 0);
4555 tree type
= TREE_TYPE (*expr_p
);
4558 /* Verify that valist is of the proper type. */
4559 want_va_type
= va_list_type_node
;
4560 have_va_type
= TREE_TYPE (valist
);
4562 if (have_va_type
== error_mark_node
)
4565 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4567 /* If va_list is an array type, the argument may have decayed
4568 to a pointer type, e.g. by being passed to another function.
4569 In that case, unwrap both types so that we can compare the
4570 underlying records. */
4571 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4572 || TREE_CODE (have_va_type
) == POINTER_TYPE
)
4574 want_va_type
= TREE_TYPE (want_va_type
);
4575 have_va_type
= TREE_TYPE (have_va_type
);
4579 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4581 error ("first argument to `va_arg' not of type `va_list'");
4585 /* Generate a diagnostic for requesting data of a type that cannot
4586 be passed through `...' due to type promotion at the call site. */
4587 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4590 static bool gave_help
;
4592 /* Unfortunately, this is merely undefined, rather than a constraint
4593 violation, so we cannot make this an error. If this call is never
4594 executed, the program is still strictly conforming. */
4595 warning ("`%T' is promoted to `%T' when passed through `...'",
4596 type
, promoted_type
);
4600 warning ("(so you should pass `%T' not `%T' to `va_arg')",
4601 promoted_type
, type
);
4604 /* We can, however, treat "undefined" any way we please.
4605 Call abort to encourage the user to fix the program. */
4606 inform ("if this code is reached, the program will abort");
4607 t
= build_function_call_expr (implicit_built_in_decls
[BUILT_IN_TRAP
],
4609 append_to_statement_list (t
, pre_p
);
4611 /* This is dead code, but go ahead and finish so that the
4612 mode of the result comes out right. */
4613 *expr_p
= dummy_object (type
);
4618 /* Make it easier for the backends by protecting the valist argument
4619 from multiple evaluations. */
4620 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4622 /* For this case, the backends will be expecting a pointer to
4623 TREE_TYPE (va_list_type_node), but it's possible we've
4624 actually been given an array (an actual va_list_type_node).
4626 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4628 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4629 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4631 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4634 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4636 if (!targetm
.gimplify_va_arg_expr
)
4637 /* Once most targets are converted this should abort. */
4640 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4645 /* Expand ARGLIST, from a call to __builtin_va_end. */
4648 expand_builtin_va_end (tree arglist
)
4650 tree valist
= TREE_VALUE (arglist
);
4652 /* Evaluate for side effects, if needed. I hate macros that don't
4654 if (TREE_SIDE_EFFECTS (valist
))
4655 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4660 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4661 builtin rather than just as an assignment in stdarg.h because of the
4662 nastiness of array-type va_list types. */
4665 expand_builtin_va_copy (tree arglist
)
4669 dst
= TREE_VALUE (arglist
);
4670 src
= TREE_VALUE (TREE_CHAIN (arglist
));
4672 dst
= stabilize_va_list (dst
, 1);
4673 src
= stabilize_va_list (src
, 0);
4675 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
4677 t
= build2 (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
4678 TREE_SIDE_EFFECTS (t
) = 1;
4679 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4683 rtx dstb
, srcb
, size
;
4685 /* Evaluate to pointers. */
4686 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4687 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4688 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
4689 VOIDmode
, EXPAND_NORMAL
);
4691 dstb
= convert_memory_address (Pmode
, dstb
);
4692 srcb
= convert_memory_address (Pmode
, srcb
);
4694 /* "Dereference" to BLKmode memories. */
4695 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4696 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4697 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
4698 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4699 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4700 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
4703 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4709 /* Expand a call to one of the builtin functions __builtin_frame_address or
4710 __builtin_return_address. */
4713 expand_builtin_frame_address (tree fndecl
, tree arglist
)
4715 /* The argument must be a nonnegative integer constant.
4716 It counts the number of frames to scan up the stack.
4717 The value is the return address saved in that frame. */
4719 /* Warning about missing arg was already issued. */
4721 else if (! host_integerp (TREE_VALUE (arglist
), 1))
4723 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4724 error ("invalid arg to `__builtin_frame_address'");
4726 error ("invalid arg to `__builtin_return_address'");
4732 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4733 tree_low_cst (TREE_VALUE (arglist
), 1),
4734 hard_frame_pointer_rtx
);
4736 /* Some ports cannot access arbitrary stack frames. */
4739 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4740 warning ("unsupported arg to `__builtin_frame_address'");
4742 warning ("unsupported arg to `__builtin_return_address'");
4746 /* For __builtin_frame_address, return what we've got. */
4747 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4751 && ! CONSTANT_P (tem
))
4752 tem
= copy_to_mode_reg (Pmode
, tem
);
4757 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4758 we failed and the caller should emit a normal call, otherwise try to get
4759 the result in TARGET, if convenient. */
4762 expand_builtin_alloca (tree arglist
, rtx target
)
4767 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4768 should always expand to function calls. These can be intercepted
4773 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4776 /* Compute the argument. */
4777 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4779 /* Allocate the desired space. */
4780 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
4781 result
= convert_memory_address (ptr_mode
, result
);
4786 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4787 Return 0 if a normal call should be emitted rather than expanding the
4788 function in-line. If convenient, the result should be placed in TARGET.
4789 SUBTARGET may be used as the target for computing one of EXP's operands. */
4792 expand_builtin_unop (enum machine_mode target_mode
, tree arglist
, rtx target
,
4793 rtx subtarget
, optab op_optab
)
4796 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4799 /* Compute the argument. */
4800 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4801 /* Compute op, into TARGET if possible.
4802 Set TARGET to wherever the result comes back. */
4803 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4804 op_optab
, op0
, target
, 1);
4808 return convert_to_mode (target_mode
, target
, 0);
4811 /* If the string passed to fputs is a constant and is one character
4812 long, we attempt to transform this call into __builtin_fputc(). */
4815 expand_builtin_fputs (tree arglist
, rtx target
, bool unlocked
)
4818 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
4819 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4820 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
4821 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
4823 /* If the return value is used, or the replacement _DECL isn't
4824 initialized, don't do the transformation. */
4825 if (target
!= const0_rtx
|| !fn_fputc
|| !fn_fwrite
)
4828 /* Verify the arguments in the original call. */
4829 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4832 /* Get the length of the string passed to fputs. If the length
4833 can't be determined, punt. */
4834 if (!(len
= c_strlen (TREE_VALUE (arglist
), 1))
4835 || TREE_CODE (len
) != INTEGER_CST
)
4838 switch (compare_tree_int (len
, 1))
4840 case -1: /* length is 0, delete the call entirely . */
4842 /* Evaluate and ignore the argument in case it has
4844 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
4845 VOIDmode
, EXPAND_NORMAL
);
4848 case 0: /* length is 1, call fputc. */
4850 const char *p
= c_getstr (TREE_VALUE (arglist
));
4854 /* New argument list transforming fputs(string, stream) to
4855 fputc(string[0], stream). */
4857 build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
4859 tree_cons (NULL_TREE
, build_int_2 (p
[0], 0), arglist
);
4865 case 1: /* length is greater than 1, call fwrite. */
4869 /* If optimizing for size keep fputs. */
4872 string_arg
= TREE_VALUE (arglist
);
4873 /* New argument list transforming fputs(string, stream) to
4874 fwrite(string, 1, len, stream). */
4875 arglist
= build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
4876 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
4877 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
4878 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
4886 return expand_expr (build_function_call_expr (fn
, arglist
),
4887 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4890 /* Expand a call to __builtin_expect. We return our argument and emit a
4891 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4892 a non-jump context. */
4895 expand_builtin_expect (tree arglist
, rtx target
)
4900 if (arglist
== NULL_TREE
4901 || TREE_CHAIN (arglist
) == NULL_TREE
)
4903 exp
= TREE_VALUE (arglist
);
4904 c
= TREE_VALUE (TREE_CHAIN (arglist
));
4906 if (TREE_CODE (c
) != INTEGER_CST
)
4908 error ("second arg to `__builtin_expect' must be a constant");
4909 c
= integer_zero_node
;
4912 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
4914 /* Don't bother with expected value notes for integral constants. */
4915 if (flag_guess_branch_prob
&& GET_CODE (target
) != CONST_INT
)
4917 /* We do need to force this into a register so that we can be
4918 moderately sure to be able to correctly interpret the branch
4920 target
= force_reg (GET_MODE (target
), target
);
4922 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
4924 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
4925 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
4931 /* Like expand_builtin_expect, except do this in a jump context. This is
4932 called from do_jump if the conditional is a __builtin_expect. Return either
4933 a list of insns to emit the jump or NULL if we cannot optimize
4934 __builtin_expect. We need to optimize this at jump time so that machines
4935 like the PowerPC don't turn the test into a SCC operation, and then jump
4936 based on the test being 0/1. */
4939 expand_builtin_expect_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
4941 tree arglist
= TREE_OPERAND (exp
, 1);
4942 tree arg0
= TREE_VALUE (arglist
);
4943 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
4946 /* Only handle __builtin_expect (test, 0) and
4947 __builtin_expect (test, 1). */
4948 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
4949 && (integer_zerop (arg1
) || integer_onep (arg1
)))
4951 rtx insn
, drop_through_label
, temp
;
4953 /* Expand the jump insns. */
4955 do_jump (arg0
, if_false_label
, if_true_label
);
4958 drop_through_label
= get_last_insn ();
4959 if (drop_through_label
&& NOTE_P (drop_through_label
))
4960 drop_through_label
= prev_nonnote_insn (drop_through_label
);
4961 if (drop_through_label
&& !LABEL_P (drop_through_label
))
4962 drop_through_label
= NULL_RTX
;
4965 if (! if_true_label
)
4966 if_true_label
= drop_through_label
;
4967 if (! if_false_label
)
4968 if_false_label
= drop_through_label
;
4970 /* Go through and add the expect's to each of the conditional jumps. */
4972 while (insn
!= NULL_RTX
)
4974 rtx next
= NEXT_INSN (insn
);
4976 if (JUMP_P (insn
) && any_condjump_p (insn
))
4978 rtx ifelse
= SET_SRC (pc_set (insn
));
4979 rtx then_dest
= XEXP (ifelse
, 1);
4980 rtx else_dest
= XEXP (ifelse
, 2);
4983 /* First check if we recognize any of the labels. */
4984 if (GET_CODE (then_dest
) == LABEL_REF
4985 && XEXP (then_dest
, 0) == if_true_label
)
4987 else if (GET_CODE (then_dest
) == LABEL_REF
4988 && XEXP (then_dest
, 0) == if_false_label
)
4990 else if (GET_CODE (else_dest
) == LABEL_REF
4991 && XEXP (else_dest
, 0) == if_false_label
)
4993 else if (GET_CODE (else_dest
) == LABEL_REF
4994 && XEXP (else_dest
, 0) == if_true_label
)
4996 /* Otherwise check where we drop through. */
4997 else if (else_dest
== pc_rtx
)
4999 if (next
&& NOTE_P (next
))
5000 next
= next_nonnote_insn (next
);
5002 if (next
&& JUMP_P (next
)
5003 && any_uncondjump_p (next
))
5004 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
5008 /* TEMP is either a CODE_LABEL, NULL_RTX or something
5009 else that can't possibly match either target label. */
5010 if (temp
== if_false_label
)
5012 else if (temp
== if_true_label
)
5015 else if (then_dest
== pc_rtx
)
5017 if (next
&& NOTE_P (next
))
5018 next
= next_nonnote_insn (next
);
5020 if (next
&& JUMP_P (next
)
5021 && any_uncondjump_p (next
))
5022 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
5026 if (temp
== if_false_label
)
5028 else if (temp
== if_true_label
)
5034 /* If the test is expected to fail, reverse the
5036 if (integer_zerop (arg1
))
5038 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
5050 expand_builtin_trap (void)
5054 emit_insn (gen_trap ());
5057 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
5061 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
5062 Return 0 if a normal call should be emitted rather than expanding
5063 the function inline. If convenient, the result should be placed
5064 in TARGET. SUBTARGET may be used as the target for computing
5068 expand_builtin_fabs (tree arglist
, rtx target
, rtx subtarget
)
5070 enum machine_mode mode
;
5074 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
5077 arg
= TREE_VALUE (arglist
);
5078 mode
= TYPE_MODE (TREE_TYPE (arg
));
5079 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
5080 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
5083 /* Expand a call to cabs, cabsf or cabsl with arguments ARGLIST.
5084 Return 0 if a normal call should be emitted rather than expanding
5085 the function inline. If convenient, the result should be placed
5089 expand_builtin_cabs (tree arglist
, rtx target
)
5091 enum machine_mode mode
;
5095 if (arglist
== 0 || TREE_CHAIN (arglist
))
5097 arg
= TREE_VALUE (arglist
);
5098 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
5099 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
5102 mode
= TYPE_MODE (TREE_TYPE (arg
));
5103 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5104 return expand_complex_abs (mode
, op0
, target
, 0);
5107 /* Create a new constant string literal and return a char* pointer to it.
5108 The STRING_CST value is the LEN characters at STR. */
5110 build_string_literal (int len
, const char *str
)
5112 tree t
, elem
, index
, type
;
5114 t
= build_string (len
, str
);
5115 elem
= build_type_variant (char_type_node
, 1, 0);
5116 index
= build_index_type (build_int_2 (len
- 1, 0));
5117 type
= build_array_type (elem
, index
);
5118 TREE_TYPE (t
) = type
;
5119 TREE_CONSTANT (t
) = 1;
5120 TREE_INVARIANT (t
) = 1;
5121 TREE_READONLY (t
) = 1;
5122 TREE_STATIC (t
) = 1;
5124 type
= build_pointer_type (type
);
5125 t
= build1 (ADDR_EXPR
, type
, t
);
5127 type
= build_pointer_type (elem
);
5128 t
= build1 (NOP_EXPR
, type
, t
);
5132 /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
5133 Return 0 if a normal call should be emitted rather than transforming
5134 the function inline. If convenient, the result should be placed in
5135 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
5138 expand_builtin_printf (tree arglist
, rtx target
, enum machine_mode mode
,
5141 tree fn_putchar
= unlocked
5142 ? implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
]
5143 : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
5144 tree fn_puts
= unlocked
? implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
]
5145 : implicit_built_in_decls
[BUILT_IN_PUTS
];
5146 const char *fmt_str
;
5149 /* If the return value is used, don't do the transformation. */
5150 if (target
!= const0_rtx
)
5153 /* Verify the required arguments in the original call. */
5156 fmt
= TREE_VALUE (arglist
);
5157 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
5159 arglist
= TREE_CHAIN (arglist
);
5161 /* Check whether the format is a literal string constant. */
5162 fmt_str
= c_getstr (fmt
);
5163 if (fmt_str
== NULL
)
5166 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
5167 if (strcmp (fmt_str
, "%s\n") == 0)
5170 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5171 || TREE_CHAIN (arglist
))
5175 /* If the format specifier was "%c", call __builtin_putchar(arg). */
5176 else if (strcmp (fmt_str
, "%c") == 0)
5179 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
5180 || TREE_CHAIN (arglist
))
5186 /* We can't handle anything else with % args or %% ... yet. */
5187 if (strchr (fmt_str
, '%'))
5193 /* If the format specifier was "", printf does nothing. */
5194 if (fmt_str
[0] == '\0')
5196 /* If the format specifier has length of 1, call putchar. */
5197 if (fmt_str
[1] == '\0')
5199 /* Given printf("c"), (where c is any one character,)
5200 convert "c"[0] to an int and pass that to the replacement
5202 arg
= build_int_2 (fmt_str
[0], 0);
5203 arglist
= build_tree_list (NULL_TREE
, arg
);
5208 /* If the format specifier was "string\n", call puts("string"). */
5209 size_t len
= strlen (fmt_str
);
5210 if (fmt_str
[len
- 1] == '\n')
5212 /* Create a NUL-terminated string that's one char shorter
5213 than the original, stripping off the trailing '\n'. */
5214 char *newstr
= alloca (len
);
5215 memcpy (newstr
, fmt_str
, len
- 1);
5216 newstr
[len
- 1] = 0;
5218 arg
= build_string_literal (len
, newstr
);
5219 arglist
= build_tree_list (NULL_TREE
, arg
);
5223 /* We'd like to arrange to call fputs(string,stdout) here,
5224 but we need stdout and don't have a way to get it yet. */
5231 return expand_expr (build_function_call_expr (fn
, arglist
),
5232 target
, mode
, EXPAND_NORMAL
);
5235 /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
5236 Return 0 if a normal call should be emitted rather than transforming
5237 the function inline. If convenient, the result should be placed in
5238 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5241 expand_builtin_fprintf (tree arglist
, rtx target
, enum machine_mode mode
,
5244 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
5245 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
5246 tree fn_fputs
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
]
5247 : implicit_built_in_decls
[BUILT_IN_FPUTS
];
5248 const char *fmt_str
;
5249 tree fn
, fmt
, fp
, arg
;
5251 /* If the return value is used, don't do the transformation. */
5252 if (target
!= const0_rtx
)
5255 /* Verify the required arguments in the original call. */
5258 fp
= TREE_VALUE (arglist
);
5259 if (TREE_CODE (TREE_TYPE (fp
)) != POINTER_TYPE
)
5261 arglist
= TREE_CHAIN (arglist
);
5264 fmt
= TREE_VALUE (arglist
);
5265 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
5267 arglist
= TREE_CHAIN (arglist
);
5269 /* Check whether the format is a literal string constant. */
5270 fmt_str
= c_getstr (fmt
);
5271 if (fmt_str
== NULL
)
5274 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5275 if (strcmp (fmt_str
, "%s") == 0)
5278 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5279 || TREE_CHAIN (arglist
))
5281 arg
= TREE_VALUE (arglist
);
5282 arglist
= build_tree_list (NULL_TREE
, fp
);
5283 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
5286 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5287 else if (strcmp (fmt_str
, "%c") == 0)
5290 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
5291 || TREE_CHAIN (arglist
))
5293 arg
= TREE_VALUE (arglist
);
5294 arglist
= build_tree_list (NULL_TREE
, fp
);
5295 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
5300 /* We can't handle anything else with % args or %% ... yet. */
5301 if (strchr (fmt_str
, '%'))
5307 /* If the format specifier was "", fprintf does nothing. */
5308 if (fmt_str
[0] == '\0')
5310 /* Evaluate and ignore FILE* argument for side-effects. */
5311 expand_expr (fp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5315 /* When "string" doesn't contain %, replace all cases of
5316 fprintf(stream,string) with fputs(string,stream). The fputs
5317 builtin will take care of special cases like length == 1. */
5318 arglist
= build_tree_list (NULL_TREE
, fp
);
5319 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
5325 return expand_expr (build_function_call_expr (fn
, arglist
),
5326 target
, mode
, EXPAND_NORMAL
);
5329 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
5330 a normal call should be emitted rather than expanding the function
5331 inline. If convenient, the result should be placed in TARGET with
5335 expand_builtin_sprintf (tree arglist
, rtx target
, enum machine_mode mode
)
5337 tree orig_arglist
, dest
, fmt
;
5338 const char *fmt_str
;
5340 orig_arglist
= arglist
;
5342 /* Verify the required arguments in the original call. */
5345 dest
= TREE_VALUE (arglist
);
5346 if (TREE_CODE (TREE_TYPE (dest
)) != POINTER_TYPE
)
5348 arglist
= TREE_CHAIN (arglist
);
5351 fmt
= TREE_VALUE (arglist
);
5352 if (TREE_CODE (TREE_TYPE (fmt
)) != POINTER_TYPE
)
5354 arglist
= TREE_CHAIN (arglist
);
5356 /* Check whether the format is a literal string constant. */
5357 fmt_str
= c_getstr (fmt
);
5358 if (fmt_str
== NULL
)
5361 /* If the format doesn't contain % args or %%, use strcpy. */
5362 if (strchr (fmt_str
, '%') == 0)
5364 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5367 if (arglist
|| ! fn
)
5369 expand_expr (build_function_call_expr (fn
, orig_arglist
),
5370 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5371 if (target
== const0_rtx
)
5373 exp
= build_int_2 (strlen (fmt_str
), 0);
5374 exp
= fold_convert (integer_type_node
, exp
);
5375 return expand_expr (exp
, target
, mode
, EXPAND_NORMAL
);
5377 /* If the format is "%s", use strcpy if the result isn't used. */
5378 else if (strcmp (fmt_str
, "%s") == 0)
5381 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5386 if (! arglist
|| TREE_CHAIN (arglist
))
5388 arg
= TREE_VALUE (arglist
);
5389 if (TREE_CODE (TREE_TYPE (arg
)) != POINTER_TYPE
)
5392 if (target
!= const0_rtx
)
5394 len
= c_strlen (arg
, 1);
5395 if (! len
|| TREE_CODE (len
) != INTEGER_CST
)
5401 arglist
= build_tree_list (NULL_TREE
, arg
);
5402 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
5403 expand_expr (build_function_call_expr (fn
, arglist
),
5404 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5406 if (target
== const0_rtx
)
5408 return expand_expr (len
, target
, mode
, EXPAND_NORMAL
);
5414 /* Expand a call to either the entry or exit function profiler. */
5417 expand_builtin_profile_func (bool exitp
)
5421 this = DECL_RTL (current_function_decl
);
5423 this = XEXP (this, 0);
5428 which
= profile_function_exit_libfunc
;
5430 which
= profile_function_entry_libfunc
;
5432 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this, Pmode
,
5433 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
5434 0, hard_frame_pointer_rtx
),
5440 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5443 round_trampoline_addr (rtx tramp
)
5445 rtx temp
, addend
, mask
;
5447 /* If we don't need too much alignment, we'll have been guaranteed
5448 proper alignment by get_trampoline_type. */
5449 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
5452 /* Round address up to desired boundary. */
5453 temp
= gen_reg_rtx (Pmode
);
5454 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
5455 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
5457 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
5458 temp
, 0, OPTAB_LIB_WIDEN
);
5459 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
5460 temp
, 0, OPTAB_LIB_WIDEN
);
5466 expand_builtin_init_trampoline (tree arglist
)
5468 tree t_tramp
, t_func
, t_chain
;
5469 rtx r_tramp
, r_func
, r_chain
;
5470 #ifdef TRAMPOLINE_TEMPLATE
5474 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
,
5475 POINTER_TYPE
, VOID_TYPE
))
5478 t_tramp
= TREE_VALUE (arglist
);
5479 arglist
= TREE_CHAIN (arglist
);
5480 t_func
= TREE_VALUE (arglist
);
5481 arglist
= TREE_CHAIN (arglist
);
5482 t_chain
= TREE_VALUE (arglist
);
5484 r_tramp
= expand_expr (t_tramp
, NULL_RTX
, VOIDmode
, 0);
5485 r_func
= expand_expr (t_func
, NULL_RTX
, VOIDmode
, 0);
5486 r_chain
= expand_expr (t_chain
, NULL_RTX
, VOIDmode
, 0);
5488 /* Generate insns to initialize the trampoline. */
5489 r_tramp
= round_trampoline_addr (r_tramp
);
5490 #ifdef TRAMPOLINE_TEMPLATE
5491 blktramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
5492 set_mem_align (blktramp
, TRAMPOLINE_ALIGNMENT
);
5493 emit_block_move (blktramp
, assemble_trampoline_template (),
5494 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
5496 trampolines_created
= 1;
5497 INITIALIZE_TRAMPOLINE (r_tramp
, r_func
, r_chain
);
5503 expand_builtin_adjust_trampoline (tree arglist
)
5507 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5510 tramp
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5511 tramp
= round_trampoline_addr (tramp
);
5512 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5513 TRAMPOLINE_ADJUST_ADDRESS (tramp
);
5519 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5520 Return NULL_RTX if a normal call should be emitted rather than expanding
5521 the function in-line. EXP is the expression that is a call to the builtin
5522 function; if convenient, the result should be placed in TARGET. */
5525 expand_builtin_signbit (tree exp
, rtx target
)
5527 const struct real_format
*fmt
;
5528 enum machine_mode fmode
, imode
, rmode
;
5529 HOST_WIDE_INT hi
, lo
;
5534 arglist
= TREE_OPERAND (exp
, 1);
5535 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
5538 arg
= TREE_VALUE (arglist
);
5539 fmode
= TYPE_MODE (TREE_TYPE (arg
));
5540 rmode
= TYPE_MODE (TREE_TYPE (exp
));
5541 fmt
= REAL_MODE_FORMAT (fmode
);
5543 /* For floating point formats without a sign bit, implement signbit
5545 if (fmt
->signbit
< 0)
5547 /* But we can't do this if the format supports signed zero. */
5548 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5551 arg
= fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
5552 build_real (TREE_TYPE (arg
), dconst0
)));
5553 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5556 imode
= int_mode_for_mode (fmode
);
5557 if (imode
== BLKmode
)
5560 bitpos
= fmt
->signbit
;
5561 /* Handle targets with different FP word orders. */
5562 if (FLOAT_WORDS_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
5564 int nwords
= GET_MODE_BITSIZE (fmode
) / BITS_PER_WORD
;
5565 int word
= nwords
- (bitpos
/ BITS_PER_WORD
) - 1;
5566 bitpos
= word
* BITS_PER_WORD
+ bitpos
% BITS_PER_WORD
;
5569 /* If the sign bit is not in the lowpart and the floating point format
5570 is wider than an integer, check that is twice the size of an integer
5571 so that we can use gen_highpart below. */
5572 if (bitpos
>= GET_MODE_BITSIZE (rmode
)
5573 && GET_MODE_BITSIZE (imode
) != 2 * GET_MODE_BITSIZE (rmode
))
5576 temp
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5577 temp
= gen_lowpart (imode
, temp
);
5579 if (GET_MODE_BITSIZE (imode
) > GET_MODE_BITSIZE (rmode
))
5581 if (BYTES_BIG_ENDIAN
)
5582 bitpos
= GET_MODE_BITSIZE (imode
) - 1 - bitpos
;
5583 temp
= copy_to_mode_reg (imode
, temp
);
5584 temp
= extract_bit_field (temp
, 1, bitpos
, 1,
5585 NULL_RTX
, rmode
, rmode
);
5589 if (GET_MODE_BITSIZE (imode
) < GET_MODE_BITSIZE (rmode
))
5590 temp
= gen_lowpart (rmode
, temp
);
5591 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5594 lo
= (HOST_WIDE_INT
) 1 << bitpos
;
5598 hi
= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5602 temp
= force_reg (rmode
, temp
);
5603 temp
= expand_binop (rmode
, and_optab
, temp
,
5604 immed_double_const (lo
, hi
, rmode
),
5605 target
, 1, OPTAB_LIB_WIDEN
);
5610 /* Expand fork or exec calls. TARGET is the desired target of the
5611 call. ARGLIST is the list of arguments of the call. FN is the
5612 identificator of the actual function. IGNORE is nonzero if the
5613 value is to be ignored. */
5616 expand_builtin_fork_or_exec (tree fn
, tree arglist
, rtx target
, int ignore
)
5621 /* If we are not profiling, just call the function. */
5622 if (!profile_arc_flag
)
5625 /* Otherwise call the wrapper. This should be equivalent for the rest of
5626 compiler, so the code does not diverge, and the wrapper may run the
5627 code necessary for keeping the profiling sane. */
5629 switch (DECL_FUNCTION_CODE (fn
))
5632 id
= get_identifier ("__gcov_fork");
5635 case BUILT_IN_EXECL
:
5636 id
= get_identifier ("__gcov_execl");
5639 case BUILT_IN_EXECV
:
5640 id
= get_identifier ("__gcov_execv");
5643 case BUILT_IN_EXECLP
:
5644 id
= get_identifier ("__gcov_execlp");
5647 case BUILT_IN_EXECLE
:
5648 id
= get_identifier ("__gcov_execle");
5651 case BUILT_IN_EXECVP
:
5652 id
= get_identifier ("__gcov_execvp");
5655 case BUILT_IN_EXECVE
:
5656 id
= get_identifier ("__gcov_execve");
5663 decl
= build_decl (FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5664 DECL_EXTERNAL (decl
) = 1;
5665 TREE_PUBLIC (decl
) = 1;
5666 DECL_ARTIFICIAL (decl
) = 1;
5667 TREE_NOTHROW (decl
) = 1;
5668 call
= build_function_call_expr (decl
, arglist
);
5670 return expand_call (call
, target
, ignore
);
5673 /* Expand an expression EXP that calls a built-in function,
5674 with result going to TARGET if that's convenient
5675 (and in mode MODE if that's convenient).
5676 SUBTARGET may be used as the target for computing one of EXP's operands.
5677 IGNORE is nonzero if the value is to be ignored. */
5680 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5683 tree fndecl
= get_callee_fndecl (exp
);
5684 tree arglist
= TREE_OPERAND (exp
, 1);
5685 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5686 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5688 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5689 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5691 /* When not optimizing, generate calls to library functions for a certain
5694 && !CALLED_AS_BUILT_IN (fndecl
)
5695 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5696 && fcode
!= BUILT_IN_ALLOCA
)
5697 return expand_call (exp
, target
, ignore
);
5699 /* The built-in function expanders test for target == const0_rtx
5700 to determine whether the function's result will be ignored. */
5702 target
= const0_rtx
;
5704 /* If the result of a pure or const built-in function is ignored, and
5705 none of its arguments are volatile, we can avoid expanding the
5706 built-in call and just evaluate the arguments for side-effects. */
5707 if (target
== const0_rtx
5708 && (DECL_IS_PURE (fndecl
) || TREE_READONLY (fndecl
)))
5710 bool volatilep
= false;
5713 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5714 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
5722 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5723 expand_expr (TREE_VALUE (arg
), const0_rtx
,
5724 VOIDmode
, EXPAND_NORMAL
);
5732 case BUILT_IN_FABSF
:
5733 case BUILT_IN_FABSL
:
5734 target
= expand_builtin_fabs (arglist
, target
, subtarget
);
5740 case BUILT_IN_CABSF
:
5741 case BUILT_IN_CABSL
:
5742 if (flag_unsafe_math_optimizations
)
5744 target
= expand_builtin_cabs (arglist
, target
);
5753 case BUILT_IN_EXP10
:
5754 case BUILT_IN_EXP10F
:
5755 case BUILT_IN_EXP10L
:
5756 case BUILT_IN_POW10
:
5757 case BUILT_IN_POW10F
:
5758 case BUILT_IN_POW10L
:
5760 case BUILT_IN_EXP2F
:
5761 case BUILT_IN_EXP2L
:
5762 case BUILT_IN_EXPM1
:
5763 case BUILT_IN_EXPM1F
:
5764 case BUILT_IN_EXPM1L
:
5766 case BUILT_IN_LOGBF
:
5767 case BUILT_IN_LOGBL
:
5768 case BUILT_IN_ILOGB
:
5769 case BUILT_IN_ILOGBF
:
5770 case BUILT_IN_ILOGBL
:
5774 case BUILT_IN_LOG10
:
5775 case BUILT_IN_LOG10F
:
5776 case BUILT_IN_LOG10L
:
5778 case BUILT_IN_LOG2F
:
5779 case BUILT_IN_LOG2L
:
5780 case BUILT_IN_LOG1P
:
5781 case BUILT_IN_LOG1PF
:
5782 case BUILT_IN_LOG1PL
:
5787 case BUILT_IN_ASINF
:
5788 case BUILT_IN_ASINL
:
5790 case BUILT_IN_ACOSF
:
5791 case BUILT_IN_ACOSL
:
5793 case BUILT_IN_ATANF
:
5794 case BUILT_IN_ATANL
:
5795 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5796 because of possible accuracy problems. */
5797 if (! flag_unsafe_math_optimizations
)
5800 case BUILT_IN_SQRTF
:
5801 case BUILT_IN_SQRTL
:
5802 case BUILT_IN_FLOOR
:
5803 case BUILT_IN_FLOORF
:
5804 case BUILT_IN_FLOORL
:
5806 case BUILT_IN_CEILF
:
5807 case BUILT_IN_CEILL
:
5808 case BUILT_IN_TRUNC
:
5809 case BUILT_IN_TRUNCF
:
5810 case BUILT_IN_TRUNCL
:
5811 case BUILT_IN_ROUND
:
5812 case BUILT_IN_ROUNDF
:
5813 case BUILT_IN_ROUNDL
:
5814 case BUILT_IN_NEARBYINT
:
5815 case BUILT_IN_NEARBYINTF
:
5816 case BUILT_IN_NEARBYINTL
:
5817 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5825 target
= expand_builtin_pow (exp
, target
, subtarget
);
5830 case BUILT_IN_ATAN2
:
5831 case BUILT_IN_ATAN2F
:
5832 case BUILT_IN_ATAN2L
:
5834 case BUILT_IN_FMODF
:
5835 case BUILT_IN_FMODL
:
5837 case BUILT_IN_DREMF
:
5838 case BUILT_IN_DREML
:
5839 if (! flag_unsafe_math_optimizations
)
5841 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5852 if (! flag_unsafe_math_optimizations
)
5854 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5859 case BUILT_IN_APPLY_ARGS
:
5860 return expand_builtin_apply_args ();
5862 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5863 FUNCTION with a copy of the parameters described by
5864 ARGUMENTS, and ARGSIZE. It returns a block of memory
5865 allocated on the stack into which is stored all the registers
5866 that might possibly be used for returning the result of a
5867 function. ARGUMENTS is the value returned by
5868 __builtin_apply_args. ARGSIZE is the number of bytes of
5869 arguments that must be copied. ??? How should this value be
5870 computed? We'll also need a safe worst case value for varargs
5872 case BUILT_IN_APPLY
:
5873 if (!validate_arglist (arglist
, POINTER_TYPE
,
5874 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5875 && !validate_arglist (arglist
, REFERENCE_TYPE
,
5876 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5884 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
5885 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
5887 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5890 /* __builtin_return (RESULT) causes the function to return the
5891 value described by RESULT. RESULT is address of the block of
5892 memory returned by __builtin_apply. */
5893 case BUILT_IN_RETURN
:
5894 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5895 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
5896 NULL_RTX
, VOIDmode
, 0));
5899 case BUILT_IN_SAVEREGS
:
5900 return expand_builtin_saveregs ();
5902 case BUILT_IN_ARGS_INFO
:
5903 return expand_builtin_args_info (arglist
);
5905 /* Return the address of the first anonymous stack arg. */
5906 case BUILT_IN_NEXT_ARG
:
5907 simplify_builtin_next_arg (arglist
);
5908 return expand_builtin_next_arg (arglist
);
5910 case BUILT_IN_CLASSIFY_TYPE
:
5911 return expand_builtin_classify_type (arglist
);
5913 case BUILT_IN_CONSTANT_P
:
5916 case BUILT_IN_FRAME_ADDRESS
:
5917 case BUILT_IN_RETURN_ADDRESS
:
5918 return expand_builtin_frame_address (fndecl
, arglist
);
5920 /* Returns the address of the area where the structure is returned.
5922 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
5924 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
5925 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
5928 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
5930 case BUILT_IN_ALLOCA
:
5931 target
= expand_builtin_alloca (arglist
, target
);
5936 case BUILT_IN_STACK_ALLOC
:
5937 expand_stack_alloc (TREE_VALUE (arglist
),
5938 TREE_VALUE (TREE_CHAIN (arglist
)));
5941 case BUILT_IN_STACK_SAVE
:
5942 return expand_stack_save ();
5944 case BUILT_IN_STACK_RESTORE
:
5945 expand_stack_restore (TREE_VALUE (arglist
));
5950 case BUILT_IN_FFSLL
:
5951 case BUILT_IN_FFSIMAX
:
5952 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5953 subtarget
, ffs_optab
);
5960 case BUILT_IN_CLZLL
:
5961 case BUILT_IN_CLZIMAX
:
5962 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5963 subtarget
, clz_optab
);
5970 case BUILT_IN_CTZLL
:
5971 case BUILT_IN_CTZIMAX
:
5972 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5973 subtarget
, ctz_optab
);
5978 case BUILT_IN_POPCOUNT
:
5979 case BUILT_IN_POPCOUNTL
:
5980 case BUILT_IN_POPCOUNTLL
:
5981 case BUILT_IN_POPCOUNTIMAX
:
5982 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5983 subtarget
, popcount_optab
);
5988 case BUILT_IN_PARITY
:
5989 case BUILT_IN_PARITYL
:
5990 case BUILT_IN_PARITYLL
:
5991 case BUILT_IN_PARITYIMAX
:
5992 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5993 subtarget
, parity_optab
);
5998 case BUILT_IN_STRLEN
:
5999 target
= expand_builtin_strlen (arglist
, target
, target_mode
);
6004 case BUILT_IN_STRCPY
:
6005 target
= expand_builtin_strcpy (arglist
, target
, mode
);
6010 case BUILT_IN_STRNCPY
:
6011 target
= expand_builtin_strncpy (arglist
, target
, mode
);
6016 case BUILT_IN_STPCPY
:
6017 target
= expand_builtin_stpcpy (arglist
, target
, mode
);
6022 case BUILT_IN_STRCAT
:
6023 target
= expand_builtin_strcat (arglist
, target
, mode
);
6028 case BUILT_IN_STRNCAT
:
6029 target
= expand_builtin_strncat (arglist
, target
, mode
);
6034 case BUILT_IN_STRSPN
:
6035 target
= expand_builtin_strspn (arglist
, target
, mode
);
6040 case BUILT_IN_STRCSPN
:
6041 target
= expand_builtin_strcspn (arglist
, target
, mode
);
6046 case BUILT_IN_STRSTR
:
6047 target
= expand_builtin_strstr (arglist
, target
, mode
);
6052 case BUILT_IN_STRPBRK
:
6053 target
= expand_builtin_strpbrk (arglist
, target
, mode
);
6058 case BUILT_IN_INDEX
:
6059 case BUILT_IN_STRCHR
:
6060 target
= expand_builtin_strchr (arglist
, target
, mode
);
6065 case BUILT_IN_RINDEX
:
6066 case BUILT_IN_STRRCHR
:
6067 target
= expand_builtin_strrchr (arglist
, target
, mode
);
6072 case BUILT_IN_MEMCPY
:
6073 target
= expand_builtin_memcpy (arglist
, target
, mode
);
6078 case BUILT_IN_MEMPCPY
:
6079 target
= expand_builtin_mempcpy (arglist
, target
, mode
, /*endp=*/ 1);
6084 case BUILT_IN_MEMMOVE
:
6085 target
= expand_builtin_memmove (arglist
, target
, mode
);
6090 case BUILT_IN_BCOPY
:
6091 target
= expand_builtin_bcopy (arglist
);
6096 case BUILT_IN_MEMSET
:
6097 target
= expand_builtin_memset (arglist
, target
, mode
);
6102 case BUILT_IN_BZERO
:
6103 target
= expand_builtin_bzero (arglist
);
6108 case BUILT_IN_STRCMP
:
6109 target
= expand_builtin_strcmp (exp
, target
, mode
);
6114 case BUILT_IN_STRNCMP
:
6115 target
= expand_builtin_strncmp (exp
, target
, mode
);
6121 case BUILT_IN_MEMCMP
:
6122 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
6127 case BUILT_IN_SETJMP
:
6128 target
= expand_builtin_setjmp (arglist
, target
);
6133 /* __builtin_longjmp is passed a pointer to an array of five words.
6134 It's similar to the C library longjmp function but works with
6135 __builtin_setjmp above. */
6136 case BUILT_IN_LONGJMP
:
6137 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6141 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
6143 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
6144 NULL_RTX
, VOIDmode
, 0);
6146 if (value
!= const1_rtx
)
6148 error ("__builtin_longjmp second argument must be 1");
6152 expand_builtin_longjmp (buf_addr
, value
);
6156 case BUILT_IN_NONLOCAL_GOTO
:
6157 target
= expand_builtin_nonlocal_goto (arglist
);
6162 /* This updates the setjmp buffer that is its argument with the value
6163 of the current stack pointer. */
6164 case BUILT_IN_UPDATE_SETJMP_BUF
:
6165 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6168 = expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
6170 expand_builtin_update_setjmp_buf (buf_addr
);
6176 expand_builtin_trap ();
6179 case BUILT_IN_PRINTF
:
6180 target
= expand_builtin_printf (arglist
, target
, mode
, false);
6185 case BUILT_IN_PRINTF_UNLOCKED
:
6186 target
= expand_builtin_printf (arglist
, target
, mode
, true);
6191 case BUILT_IN_FPUTS
:
6192 target
= expand_builtin_fputs (arglist
, target
, false);
6196 case BUILT_IN_FPUTS_UNLOCKED
:
6197 target
= expand_builtin_fputs (arglist
, target
, true);
6202 case BUILT_IN_FPRINTF
:
6203 target
= expand_builtin_fprintf (arglist
, target
, mode
, false);
6208 case BUILT_IN_FPRINTF_UNLOCKED
:
6209 target
= expand_builtin_fprintf (arglist
, target
, mode
, true);
6214 case BUILT_IN_SPRINTF
:
6215 target
= expand_builtin_sprintf (arglist
, target
, mode
);
6220 case BUILT_IN_SIGNBIT
:
6221 case BUILT_IN_SIGNBITF
:
6222 case BUILT_IN_SIGNBITL
:
6223 target
= expand_builtin_signbit (exp
, target
);
6228 /* Various hooks for the DWARF 2 __throw routine. */
6229 case BUILT_IN_UNWIND_INIT
:
6230 expand_builtin_unwind_init ();
6232 case BUILT_IN_DWARF_CFA
:
6233 return virtual_cfa_rtx
;
6234 #ifdef DWARF2_UNWIND_INFO
6235 case BUILT_IN_DWARF_SP_COLUMN
:
6236 return expand_builtin_dwarf_sp_column ();
6237 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6238 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
6241 case BUILT_IN_FROB_RETURN_ADDR
:
6242 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
6243 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6244 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
6245 case BUILT_IN_EH_RETURN
:
6246 expand_builtin_eh_return (TREE_VALUE (arglist
),
6247 TREE_VALUE (TREE_CHAIN (arglist
)));
6249 #ifdef EH_RETURN_DATA_REGNO
6250 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6251 return expand_builtin_eh_return_data_regno (arglist
);
6253 case BUILT_IN_EXTEND_POINTER
:
6254 return expand_builtin_extend_pointer (TREE_VALUE (arglist
));
6256 case BUILT_IN_VA_START
:
6257 case BUILT_IN_STDARG_START
:
6258 return expand_builtin_va_start (arglist
);
6259 case BUILT_IN_VA_END
:
6260 return expand_builtin_va_end (arglist
);
6261 case BUILT_IN_VA_COPY
:
6262 return expand_builtin_va_copy (arglist
);
6263 case BUILT_IN_EXPECT
:
6264 return expand_builtin_expect (arglist
, target
);
6265 case BUILT_IN_PREFETCH
:
6266 expand_builtin_prefetch (arglist
);
6269 case BUILT_IN_PROFILE_FUNC_ENTER
:
6270 return expand_builtin_profile_func (false);
6271 case BUILT_IN_PROFILE_FUNC_EXIT
:
6272 return expand_builtin_profile_func (true);
6274 case BUILT_IN_INIT_TRAMPOLINE
:
6275 return expand_builtin_init_trampoline (arglist
);
6276 case BUILT_IN_ADJUST_TRAMPOLINE
:
6277 return expand_builtin_adjust_trampoline (arglist
);
6280 case BUILT_IN_EXECL
:
6281 case BUILT_IN_EXECV
:
6282 case BUILT_IN_EXECLP
:
6283 case BUILT_IN_EXECLE
:
6284 case BUILT_IN_EXECVP
:
6285 case BUILT_IN_EXECVE
:
6286 target
= expand_builtin_fork_or_exec (fndecl
, arglist
, target
, ignore
);
6291 default: /* just do library call, if unknown builtin */
6295 /* The switch statement above can drop through to cause the function
6296 to be called normally. */
6297 return expand_call (exp
, target
, ignore
);
6300 /* Determine whether a tree node represents a call to a built-in
6301 function. If the tree T is a call to a built-in function with
6302 the right number of arguments of the appropriate types, return
6303 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6304 Otherwise the return value is END_BUILTINS. */
6306 enum built_in_function
6307 builtin_mathfn_code (tree t
)
6309 tree fndecl
, arglist
, parmlist
;
6310 tree argtype
, parmtype
;
6312 if (TREE_CODE (t
) != CALL_EXPR
6313 || TREE_CODE (TREE_OPERAND (t
, 0)) != ADDR_EXPR
)
6314 return END_BUILTINS
;
6316 fndecl
= get_callee_fndecl (t
);
6317 if (fndecl
== NULL_TREE
6318 || TREE_CODE (fndecl
) != FUNCTION_DECL
6319 || ! DECL_BUILT_IN (fndecl
)
6320 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6321 return END_BUILTINS
;
6323 arglist
= TREE_OPERAND (t
, 1);
6324 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6325 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6327 /* If a function doesn't take a variable number of arguments,
6328 the last element in the list will have type `void'. */
6329 parmtype
= TREE_VALUE (parmlist
);
6330 if (VOID_TYPE_P (parmtype
))
6333 return END_BUILTINS
;
6334 return DECL_FUNCTION_CODE (fndecl
);
6338 return END_BUILTINS
;
6340 argtype
= TREE_TYPE (TREE_VALUE (arglist
));
6342 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6344 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6345 return END_BUILTINS
;
6347 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6349 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6350 return END_BUILTINS
;
6352 else if (POINTER_TYPE_P (parmtype
))
6354 if (! POINTER_TYPE_P (argtype
))
6355 return END_BUILTINS
;
6357 else if (INTEGRAL_TYPE_P (parmtype
))
6359 if (! INTEGRAL_TYPE_P (argtype
))
6360 return END_BUILTINS
;
6363 return END_BUILTINS
;
6365 arglist
= TREE_CHAIN (arglist
);
6368 /* Variable-length argument list. */
6369 return DECL_FUNCTION_CODE (fndecl
);
6372 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6373 constant. ARGLIST is the argument list of the call. */
6376 fold_builtin_constant_p (tree arglist
)
6381 arglist
= TREE_VALUE (arglist
);
6383 /* We return 1 for a numeric type that's known to be a constant
6384 value at compile-time or for an aggregate type that's a
6385 literal constant. */
6386 STRIP_NOPS (arglist
);
6388 /* If we know this is a constant, emit the constant of one. */
6389 if (TREE_CODE_CLASS (TREE_CODE (arglist
)) == 'c'
6390 || (TREE_CODE (arglist
) == CONSTRUCTOR
6391 && TREE_CONSTANT (arglist
))
6392 || (TREE_CODE (arglist
) == ADDR_EXPR
6393 && TREE_CODE (TREE_OPERAND (arglist
, 0)) == STRING_CST
))
6394 return integer_one_node
;
6396 /* If this expression has side effects, show we don't know it to be a
6397 constant. Likewise if it's a pointer or aggregate type since in
6398 those case we only want literals, since those are only optimized
6399 when generating RTL, not later.
6400 And finally, if we are compiling an initializer, not code, we
6401 need to return a definite result now; there's not going to be any
6402 more optimization done. */
6403 if (TREE_SIDE_EFFECTS (arglist
)
6404 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
6405 || POINTER_TYPE_P (TREE_TYPE (arglist
))
6407 return integer_zero_node
;
6412 /* Fold a call to __builtin_expect, if we expect that a comparison against
6413 the argument will fold to a constant. In practice, this means a true
6414 constant or the address of a non-weak symbol. ARGLIST is the argument
6415 list of the call. */
6418 fold_builtin_expect (tree arglist
)
6425 arg
= TREE_VALUE (arglist
);
6427 /* If the argument isn't invariant, then there's nothing we can do. */
6428 if (!TREE_INVARIANT (arg
))
6431 /* If we're looking at an address of a weak decl, then do not fold. */
6434 if (TREE_CODE (inner
) == ADDR_EXPR
)
6438 inner
= TREE_OPERAND (inner
, 0);
6440 while (TREE_CODE (inner
) == COMPONENT_REF
6441 || TREE_CODE (inner
) == ARRAY_REF
);
6442 if (DECL_P (inner
) && DECL_WEAK (inner
))
6446 /* Otherwise, ARG already has the proper type for the return value. */
6450 /* Fold a call to __builtin_classify_type. */
6453 fold_builtin_classify_type (tree arglist
)
6456 return build_int_2 (no_type_class
, 0);
6458 return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))), 0);
6461 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6464 fold_builtin_inf (tree type
, int warn
)
6466 REAL_VALUE_TYPE real
;
6468 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
6469 warning ("target format does not support infinity");
6472 return build_real (type
, real
);
6475 /* Fold a call to __builtin_nan or __builtin_nans. */
6478 fold_builtin_nan (tree arglist
, tree type
, int quiet
)
6480 REAL_VALUE_TYPE real
;
6483 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6485 str
= c_getstr (TREE_VALUE (arglist
));
6489 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
6492 return build_real (type
, real
);
6495 /* Return true if the floating point expression T has an integer value.
6496 We also allow +Inf, -Inf and NaN to be considered integer values. */
6499 integer_valued_real_p (tree t
)
6501 switch (TREE_CODE (t
))
6508 case NON_LVALUE_EXPR
:
6509 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6514 return integer_valued_real_p (TREE_OPERAND (t
, 1));
6521 return integer_valued_real_p (TREE_OPERAND (t
, 0))
6522 && integer_valued_real_p (TREE_OPERAND (t
, 1));
6525 return integer_valued_real_p (TREE_OPERAND (t
, 1))
6526 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6529 if (! TREE_CONSTANT_OVERFLOW (t
))
6531 REAL_VALUE_TYPE c
, cint
;
6533 c
= TREE_REAL_CST (t
);
6534 real_trunc (&cint
, TYPE_MODE (TREE_TYPE (t
)), &c
);
6535 return real_identical (&c
, &cint
);
6540 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6541 if (TREE_CODE (type
) == INTEGER_TYPE
)
6543 if (TREE_CODE (type
) == REAL_TYPE
)
6544 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6549 switch (builtin_mathfn_code (t
))
6552 case BUILT_IN_CEILF
:
6553 case BUILT_IN_CEILL
:
6554 case BUILT_IN_FLOOR
:
6555 case BUILT_IN_FLOORF
:
6556 case BUILT_IN_FLOORL
:
6557 case BUILT_IN_NEARBYINT
:
6558 case BUILT_IN_NEARBYINTF
:
6559 case BUILT_IN_NEARBYINTL
:
6561 case BUILT_IN_RINTF
:
6562 case BUILT_IN_RINTL
:
6563 case BUILT_IN_ROUND
:
6564 case BUILT_IN_ROUNDF
:
6565 case BUILT_IN_ROUNDL
:
6566 case BUILT_IN_TRUNC
:
6567 case BUILT_IN_TRUNCF
:
6568 case BUILT_IN_TRUNCL
:
6582 /* EXP is assumed to be builtin call where truncation can be propagated
6583 across (for instance floor((double)f) == (double)floorf (f).
6584 Do the transformation. */
6587 fold_trunc_transparent_mathfn (tree exp
)
6589 tree fndecl
= get_callee_fndecl (exp
);
6590 tree arglist
= TREE_OPERAND (exp
, 1);
6591 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6594 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6597 arg
= TREE_VALUE (arglist
);
6598 /* Integer rounding functions are idempotent. */
6599 if (fcode
== builtin_mathfn_code (arg
))
6602 /* If argument is already integer valued, and we don't need to worry
6603 about setting errno, there's no need to perform rounding. */
6604 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6609 tree arg0
= strip_float_extensions (arg
);
6610 tree ftype
= TREE_TYPE (exp
);
6611 tree newtype
= TREE_TYPE (arg0
);
6614 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6615 && (decl
= mathfn_built_in (newtype
, fcode
)))
6618 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6619 return fold_convert (ftype
,
6620 build_function_call_expr (decl
, arglist
));
6626 /* EXP is assumed to be builtin call which can narrow the FP type of
6627 the argument, for instance lround((double)f) -> lroundf (f). */
6630 fold_fixed_mathfn (tree exp
)
6632 tree fndecl
= get_callee_fndecl (exp
);
6633 tree arglist
= TREE_OPERAND (exp
, 1);
6634 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6637 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6640 arg
= TREE_VALUE (arglist
);
6642 /* If argument is already integer valued, and we don't need to worry
6643 about setting errno, there's no need to perform rounding. */
6644 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6645 return fold (build1 (FIX_TRUNC_EXPR
, TREE_TYPE (exp
), arg
));
6649 tree ftype
= TREE_TYPE (arg
);
6650 tree arg0
= strip_float_extensions (arg
);
6651 tree newtype
= TREE_TYPE (arg0
);
6654 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6655 && (decl
= mathfn_built_in (newtype
, fcode
)))
6658 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6659 return build_function_call_expr (decl
, arglist
);
6665 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6666 is the argument list and TYPE is the return type. Return
6667 NULL_TREE if no if no simplification can be made. */
6670 fold_builtin_cabs (tree arglist
, tree type
)
6674 if (!arglist
|| TREE_CHAIN (arglist
))
6677 arg
= TREE_VALUE (arglist
);
6678 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
6679 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
6682 /* Evaluate cabs of a constant at compile-time. */
6683 if (flag_unsafe_math_optimizations
6684 && TREE_CODE (arg
) == COMPLEX_CST
6685 && TREE_CODE (TREE_REALPART (arg
)) == REAL_CST
6686 && TREE_CODE (TREE_IMAGPART (arg
)) == REAL_CST
6687 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg
))
6688 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg
)))
6690 REAL_VALUE_TYPE r
, i
;
6692 r
= TREE_REAL_CST (TREE_REALPART (arg
));
6693 i
= TREE_REAL_CST (TREE_IMAGPART (arg
));
6695 real_arithmetic (&r
, MULT_EXPR
, &r
, &r
);
6696 real_arithmetic (&i
, MULT_EXPR
, &i
, &i
);
6697 real_arithmetic (&r
, PLUS_EXPR
, &r
, &i
);
6698 if (real_sqrt (&r
, TYPE_MODE (type
), &r
)
6699 || ! flag_trapping_math
)
6700 return build_real (type
, r
);
6703 /* If either part is zero, cabs is fabs of the other. */
6704 if (TREE_CODE (arg
) == COMPLEX_EXPR
6705 && real_zerop (TREE_OPERAND (arg
, 0)))
6706 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 1)));
6707 if (TREE_CODE (arg
) == COMPLEX_EXPR
6708 && real_zerop (TREE_OPERAND (arg
, 1)))
6709 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 0)));
6711 if (flag_unsafe_math_optimizations
)
6713 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6715 if (sqrtfn
!= NULL_TREE
)
6717 tree rpart
, ipart
, result
, arglist
;
6719 arg
= builtin_save_expr (arg
);
6721 rpart
= fold (build1 (REALPART_EXPR
, type
, arg
));
6722 ipart
= fold (build1 (IMAGPART_EXPR
, type
, arg
));
6724 rpart
= builtin_save_expr (rpart
);
6725 ipart
= builtin_save_expr (ipart
);
6727 result
= fold (build2 (PLUS_EXPR
, type
,
6728 fold (build2 (MULT_EXPR
, type
,
6730 fold (build2 (MULT_EXPR
, type
,
6733 arglist
= build_tree_list (NULL_TREE
, result
);
6734 return build_function_call_expr (sqrtfn
, arglist
);
6741 /* Fold function call to builtin trunc, truncf or truncl. Return
6742 NULL_TREE if no simplification can be made. */
6745 fold_builtin_trunc (tree exp
)
6747 tree arglist
= TREE_OPERAND (exp
, 1);
6750 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6753 /* Optimize trunc of constant value. */
6754 arg
= TREE_VALUE (arglist
);
6755 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6757 REAL_VALUE_TYPE r
, x
;
6758 tree type
= TREE_TYPE (exp
);
6760 x
= TREE_REAL_CST (arg
);
6761 real_trunc (&r
, TYPE_MODE (type
), &x
);
6762 return build_real (type
, r
);
6765 return fold_trunc_transparent_mathfn (exp
);
6768 /* Fold function call to builtin floor, floorf or floorl. Return
6769 NULL_TREE if no simplification can be made. */
6772 fold_builtin_floor (tree exp
)
6774 tree arglist
= TREE_OPERAND (exp
, 1);
6777 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6780 /* Optimize floor of constant value. */
6781 arg
= TREE_VALUE (arglist
);
6782 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6786 x
= TREE_REAL_CST (arg
);
6787 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6789 tree type
= TREE_TYPE (exp
);
6792 real_floor (&r
, TYPE_MODE (type
), &x
);
6793 return build_real (type
, r
);
6797 return fold_trunc_transparent_mathfn (exp
);
6800 /* Fold function call to builtin ceil, ceilf or ceill. Return
6801 NULL_TREE if no simplification can be made. */
6804 fold_builtin_ceil (tree exp
)
6806 tree arglist
= TREE_OPERAND (exp
, 1);
6809 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6812 /* Optimize ceil of constant value. */
6813 arg
= TREE_VALUE (arglist
);
6814 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6818 x
= TREE_REAL_CST (arg
);
6819 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6821 tree type
= TREE_TYPE (exp
);
6824 real_ceil (&r
, TYPE_MODE (type
), &x
);
6825 return build_real (type
, r
);
6829 return fold_trunc_transparent_mathfn (exp
);
6832 /* Fold function call to builtin round, roundf or roundl. Return
6833 NULL_TREE if no simplification can be made. */
6836 fold_builtin_round (tree exp
)
6838 tree arglist
= TREE_OPERAND (exp
, 1);
6841 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6844 /* Optimize round of constant value. */
6845 arg
= TREE_VALUE (arglist
);
6846 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6850 x
= TREE_REAL_CST (arg
);
6851 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6853 tree type
= TREE_TYPE (exp
);
6856 real_round (&r
, TYPE_MODE (type
), &x
);
6857 return build_real (type
, r
);
6861 return fold_trunc_transparent_mathfn (exp
);
6864 /* Fold function call to builtin lround, lroundf or lroundl (or the
6865 corresponding long long versions). Return NULL_TREE if no
6866 simplification can be made. */
6869 fold_builtin_lround (tree exp
)
6871 tree arglist
= TREE_OPERAND (exp
, 1);
6874 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6877 /* Optimize lround of constant value. */
6878 arg
= TREE_VALUE (arglist
);
6879 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6881 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
6883 if (! REAL_VALUE_ISNAN (x
) && ! REAL_VALUE_ISINF (x
))
6885 tree itype
= TREE_TYPE (exp
), ftype
= TREE_TYPE (arg
), result
;
6886 HOST_WIDE_INT hi
, lo
;
6889 real_round (&r
, TYPE_MODE (ftype
), &x
);
6890 REAL_VALUE_TO_INT (&lo
, &hi
, r
);
6891 result
= build_int_2 (lo
, hi
);
6892 if (int_fits_type_p (result
, itype
))
6893 return fold_convert (itype
, result
);
6897 return fold_fixed_mathfn (exp
);
6900 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
6901 and their long and long long variants (i.e. ffsl and ffsll).
6902 Return NULL_TREE if no simplification can be made. */
6905 fold_builtin_bitop (tree exp
)
6907 tree fndecl
= get_callee_fndecl (exp
);
6908 tree arglist
= TREE_OPERAND (exp
, 1);
6911 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
6914 /* Optimize for constant argument. */
6915 arg
= TREE_VALUE (arglist
);
6916 if (TREE_CODE (arg
) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6918 HOST_WIDE_INT hi
, width
, result
;
6919 unsigned HOST_WIDE_INT lo
;
6922 type
= TREE_TYPE (arg
);
6923 width
= TYPE_PRECISION (type
);
6924 lo
= TREE_INT_CST_LOW (arg
);
6926 /* Clear all the bits that are beyond the type's precision. */
6927 if (width
> HOST_BITS_PER_WIDE_INT
)
6929 hi
= TREE_INT_CST_HIGH (arg
);
6930 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
6931 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
6936 if (width
< HOST_BITS_PER_WIDE_INT
)
6937 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
6940 switch (DECL_FUNCTION_CODE (fndecl
))
6944 case BUILT_IN_FFSLL
:
6946 result
= exact_log2 (lo
& -lo
) + 1;
6948 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
) + 1;
6955 case BUILT_IN_CLZLL
:
6957 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
6959 result
= width
- floor_log2 (lo
) - 1;
6960 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
6966 case BUILT_IN_CTZLL
:
6968 result
= exact_log2 (lo
& -lo
);
6970 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
);
6971 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
6975 case BUILT_IN_POPCOUNT
:
6976 case BUILT_IN_POPCOUNTL
:
6977 case BUILT_IN_POPCOUNTLL
:
6980 result
++, lo
&= lo
- 1;
6982 result
++, hi
&= hi
- 1;
6985 case BUILT_IN_PARITY
:
6986 case BUILT_IN_PARITYL
:
6987 case BUILT_IN_PARITYLL
:
6990 result
++, lo
&= lo
- 1;
6992 result
++, hi
&= hi
- 1;
7000 t
= build_int_2 (result
, 0);
7001 TREE_TYPE (t
) = TREE_TYPE (exp
);
7008 /* Return true if EXPR is the real constant contained in VALUE. */
7011 real_dconstp (tree expr
, const REAL_VALUE_TYPE
*value
)
7015 return ((TREE_CODE (expr
) == REAL_CST
7016 && ! TREE_CONSTANT_OVERFLOW (expr
)
7017 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), *value
))
7018 || (TREE_CODE (expr
) == COMPLEX_CST
7019 && real_dconstp (TREE_REALPART (expr
), value
)
7020 && real_zerop (TREE_IMAGPART (expr
))));
7023 /* A subroutine of fold_builtin to fold the various logarithmic
7024 functions. EXP is the CALL_EXPR of a call to a builtin logN
7025 function. VALUE is the base of the logN function. */
7028 fold_builtin_logarithm (tree exp
, const REAL_VALUE_TYPE
*value
)
7030 tree arglist
= TREE_OPERAND (exp
, 1);
7032 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7034 tree fndecl
= get_callee_fndecl (exp
);
7035 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7036 tree arg
= TREE_VALUE (arglist
);
7037 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7039 /* Optimize logN(1.0) = 0.0. */
7040 if (real_onep (arg
))
7041 return build_real (type
, dconst0
);
7043 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
7044 exactly, then only do this if flag_unsafe_math_optimizations. */
7045 if (exact_real_truncate (TYPE_MODE (type
), value
)
7046 || flag_unsafe_math_optimizations
)
7048 const REAL_VALUE_TYPE value_truncate
=
7049 real_value_truncate (TYPE_MODE (type
), *value
);
7050 if (real_dconstp (arg
, &value_truncate
))
7051 return build_real (type
, dconst1
);
7054 /* Special case, optimize logN(expN(x)) = x. */
7055 if (flag_unsafe_math_optimizations
7056 && ((value
== &dconste
7057 && (fcode
== BUILT_IN_EXP
7058 || fcode
== BUILT_IN_EXPF
7059 || fcode
== BUILT_IN_EXPL
))
7060 || (value
== &dconst2
7061 && (fcode
== BUILT_IN_EXP2
7062 || fcode
== BUILT_IN_EXP2F
7063 || fcode
== BUILT_IN_EXP2L
))
7064 || (value
== &dconst10
&& (BUILTIN_EXP10_P (fcode
)))))
7065 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7067 /* Optimize logN(func()) for various exponential functions. We
7068 want to determine the value "x" and the power "exponent" in
7069 order to transform logN(x**exponent) into exponent*logN(x). */
7070 if (flag_unsafe_math_optimizations
)
7072 tree exponent
= 0, x
= 0;
7079 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7080 x
= build_real (type
,
7081 real_value_truncate (TYPE_MODE (type
), dconste
));
7082 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7085 case BUILT_IN_EXP2F
:
7086 case BUILT_IN_EXP2L
:
7087 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7088 x
= build_real (type
, dconst2
);
7089 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7091 case BUILT_IN_EXP10
:
7092 case BUILT_IN_EXP10F
:
7093 case BUILT_IN_EXP10L
:
7094 case BUILT_IN_POW10
:
7095 case BUILT_IN_POW10F
:
7096 case BUILT_IN_POW10L
:
7097 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7098 x
= build_real (type
, dconst10
);
7099 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7102 case BUILT_IN_SQRTF
:
7103 case BUILT_IN_SQRTL
:
7104 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7105 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7106 exponent
= build_real (type
, dconsthalf
);
7109 case BUILT_IN_CBRTF
:
7110 case BUILT_IN_CBRTL
:
7111 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7112 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7113 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7119 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7120 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7121 exponent
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
7127 /* Now perform the optimization. */
7131 arglist
= build_tree_list (NULL_TREE
, x
);
7132 logfn
= build_function_call_expr (fndecl
, arglist
);
7133 return fold (build2 (MULT_EXPR
, type
, exponent
, logfn
));
7141 /* A subroutine of fold_builtin to fold the various exponent
7142 functions. EXP is the CALL_EXPR of a call to a builtin function.
7143 VALUE is the value which will be raised to a power. */
7146 fold_builtin_exponent (tree exp
, const REAL_VALUE_TYPE
*value
)
7148 tree arglist
= TREE_OPERAND (exp
, 1);
7150 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7152 tree fndecl
= get_callee_fndecl (exp
);
7153 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7154 tree arg
= TREE_VALUE (arglist
);
7156 /* Optimize exp*(0.0) = 1.0. */
7157 if (real_zerop (arg
))
7158 return build_real (type
, dconst1
);
7160 /* Optimize expN(1.0) = N. */
7161 if (real_onep (arg
))
7163 REAL_VALUE_TYPE cst
;
7165 real_convert (&cst
, TYPE_MODE (type
), value
);
7166 return build_real (type
, cst
);
7169 /* Attempt to evaluate expN(integer) at compile-time. */
7170 if (flag_unsafe_math_optimizations
7171 && TREE_CODE (arg
) == REAL_CST
7172 && ! TREE_CONSTANT_OVERFLOW (arg
))
7174 REAL_VALUE_TYPE cint
;
7178 c
= TREE_REAL_CST (arg
);
7179 n
= real_to_integer (&c
);
7180 real_from_integer (&cint
, VOIDmode
, n
,
7182 if (real_identical (&c
, &cint
))
7186 real_powi (&x
, TYPE_MODE (type
), value
, n
);
7187 return build_real (type
, x
);
7191 /* Optimize expN(logN(x)) = x. */
7192 if (flag_unsafe_math_optimizations
)
7194 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7196 if ((value
== &dconste
7197 && (fcode
== BUILT_IN_LOG
7198 || fcode
== BUILT_IN_LOGF
7199 || fcode
== BUILT_IN_LOGL
))
7200 || (value
== &dconst2
7201 && (fcode
== BUILT_IN_LOG2
7202 || fcode
== BUILT_IN_LOG2F
7203 || fcode
== BUILT_IN_LOG2L
))
7204 || (value
== &dconst10
7205 && (fcode
== BUILT_IN_LOG10
7206 || fcode
== BUILT_IN_LOG10F
7207 || fcode
== BUILT_IN_LOG10L
)))
7208 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7215 /* Fold function call to builtin memcpy. Return
7216 NULL_TREE if no simplification can be made. */
7219 fold_builtin_memcpy (tree exp
)
7221 tree arglist
= TREE_OPERAND (exp
, 1);
7222 tree dest
, src
, len
;
7224 if (!validate_arglist (arglist
,
7225 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7228 dest
= TREE_VALUE (arglist
);
7229 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7230 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7232 /* If the LEN parameter is zero, return DEST. */
7233 if (integer_zerop (len
))
7234 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7236 /* If SRC and DEST are the same (and not volatile), return DEST. */
7237 if (operand_equal_p (src
, dest
, 0))
7238 return omit_one_operand (TREE_TYPE (exp
), dest
, len
);
7243 /* Fold function call to builtin mempcpy. Return
7244 NULL_TREE if no simplification can be made. */
7247 fold_builtin_mempcpy (tree exp
)
7249 tree arglist
= TREE_OPERAND (exp
, 1);
7250 tree dest
, src
, len
;
7252 if (!validate_arglist (arglist
,
7253 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7256 dest
= TREE_VALUE (arglist
);
7257 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7258 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7260 /* If the LEN parameter is zero, return DEST. */
7261 if (integer_zerop (len
))
7262 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7264 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
7265 if (operand_equal_p (src
, dest
, 0))
7267 tree temp
= fold_convert (TREE_TYPE (dest
), len
);
7268 temp
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, temp
));
7269 return fold_convert (TREE_TYPE (exp
), temp
);
7275 /* Fold function call to builtin memmove. Return
7276 NULL_TREE if no simplification can be made. */
7279 fold_builtin_memmove (tree exp
)
7281 tree arglist
= TREE_OPERAND (exp
, 1);
7282 tree dest
, src
, len
;
7284 if (!validate_arglist (arglist
,
7285 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7288 dest
= TREE_VALUE (arglist
);
7289 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7290 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7292 /* If the LEN parameter is zero, return DEST. */
7293 if (integer_zerop (len
))
7294 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7296 /* If SRC and DEST are the same (and not volatile), return DEST. */
7297 if (operand_equal_p (src
, dest
, 0))
7298 return omit_one_operand (TREE_TYPE (exp
), dest
, len
);
7303 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
7304 the length of the string to be copied. Return NULL_TREE if no
7305 simplification can be made. */
7308 fold_builtin_strcpy (tree exp
, tree len
)
7310 tree arglist
= TREE_OPERAND (exp
, 1);
7313 if (!validate_arglist (arglist
,
7314 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7317 dest
= TREE_VALUE (arglist
);
7318 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7320 /* If SRC and DEST are the same (and not volatile), return DEST. */
7321 if (operand_equal_p (src
, dest
, 0))
7322 return fold_convert (TREE_TYPE (exp
), dest
);
7327 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7333 len
= c_strlen (src
, 1);
7334 if (! len
|| TREE_SIDE_EFFECTS (len
))
7338 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
7339 arglist
= build_tree_list (NULL_TREE
, len
);
7340 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
7341 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
7342 return fold_convert (TREE_TYPE (exp
),
7343 build_function_call_expr (fn
, arglist
));
7346 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
7347 the length of the source string. Return NULL_TREE if no simplification
7351 fold_builtin_strncpy (tree exp
, tree slen
)
7353 tree arglist
= TREE_OPERAND (exp
, 1);
7354 tree dest
, src
, len
, fn
;
7356 if (!validate_arglist (arglist
,
7357 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7360 dest
= TREE_VALUE (arglist
);
7361 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7362 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7364 /* If the LEN parameter is zero, return DEST. */
7365 if (integer_zerop (len
))
7366 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7368 /* We can't compare slen with len as constants below if len is not a
7370 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
7374 slen
= c_strlen (src
, 1);
7376 /* Now, we must be passed a constant src ptr parameter. */
7377 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
7380 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
7382 /* We do not support simplification of this case, though we do
7383 support it when expanding trees into RTL. */
7384 /* FIXME: generate a call to __builtin_memset. */
7385 if (tree_int_cst_lt (slen
, len
))
7388 /* OK transform into builtin memcpy. */
7389 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7392 return fold_convert (TREE_TYPE (exp
),
7393 build_function_call_expr (fn
, arglist
));
7396 /* Fold function call to builtin strchr and strrchr.
7397 Return NULL_TREE if no simplification can be made. */
7400 fold_builtin_strchr (tree exp
, bool actually_strrchr
)
7402 tree arglist
= TREE_OPERAND (exp
, 1);
7403 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7407 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
7410 if (TREE_CODE (s2
) != INTEGER_CST
)
7419 if (target_char_cast (s2
, &c
))
7422 r
= actually_strrchr
? strrchr (p1
, c
) : strchr (p1
, c
);
7425 return fold_convert (TREE_TYPE (s1
), integer_zero_node
);
7427 /* Return an offset into the constant string argument. */
7428 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
7429 s1
, fold_convert (TREE_TYPE (s1
),
7430 ssize_int (r
- p1
))));
7433 if (actually_strrchr
)
7437 if (!integer_zerop (s2
))
7440 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
7444 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
7445 return build_function_call_expr (fn
, arglist
);
7452 /* Fold function call to builtin memcmp. Return
7453 NULL_TREE if no simplification can be made. */
7456 fold_builtin_memcmp (tree exp
)
7458 tree arglist
= TREE_OPERAND (exp
, 1);
7459 tree arg1
, arg2
, len
;
7461 if (!validate_arglist (arglist
,
7462 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7465 arg1
= TREE_VALUE (arglist
);
7466 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7467 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7469 /* If the LEN parameter is zero, return zero. */
7470 if (integer_zerop (len
))
7472 tree temp
= omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, arg2
);
7473 return omit_one_operand (TREE_TYPE (exp
), temp
, arg1
);
7476 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7477 if (operand_equal_p (arg1
, arg2
, 0))
7478 return omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, len
);
7483 /* Fold function call to builtin strcmp. Return
7484 NULL_TREE if no simplification can be made. */
7487 fold_builtin_strcmp (tree exp
)
7489 tree arglist
= TREE_OPERAND (exp
, 1);
7491 const char *p1
, *p2
;
7493 if (!validate_arglist (arglist
,
7494 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7497 arg1
= TREE_VALUE (arglist
);
7498 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7500 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7501 if (operand_equal_p (arg1
, arg2
, 0))
7502 return fold_convert (TREE_TYPE (exp
), integer_zero_node
);
7504 p1
= c_getstr (arg1
);
7505 p2
= c_getstr (arg2
);
7510 const int i
= strcmp (p1
, p2
);
7512 temp
= integer_minus_one_node
;
7514 temp
= integer_one_node
;
7516 temp
= integer_zero_node
;
7517 return fold_convert (TREE_TYPE (exp
), temp
);
7523 /* Fold function call to builtin strncmp. Return
7524 NULL_TREE if no simplification can be made. */
7527 fold_builtin_strncmp (tree exp
)
7529 tree arglist
= TREE_OPERAND (exp
, 1);
7530 tree arg1
, arg2
, len
;
7531 const char *p1
, *p2
;
7533 if (!validate_arglist (arglist
,
7534 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7537 arg1
= TREE_VALUE (arglist
);
7538 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7539 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7541 /* If the LEN parameter is zero, return zero. */
7542 if (integer_zerop (len
))
7544 tree temp
= omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, arg2
);
7545 return omit_one_operand (TREE_TYPE (exp
), temp
, arg1
);
7548 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7549 if (operand_equal_p (arg1
, arg2
, 0))
7550 return omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, len
);
7552 p1
= c_getstr (arg1
);
7553 p2
= c_getstr (arg2
);
7555 if (host_integerp (len
, 1) && p1
&& p2
)
7558 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
7560 temp
= integer_minus_one_node
;
7562 temp
= integer_one_node
;
7564 temp
= integer_zero_node
;
7565 return fold_convert (TREE_TYPE (exp
), temp
);
7571 /* Fold function call to builtin signbit, signbitf or signbitl. Return
7572 NULL_TREE if no simplification can be made. */
7575 fold_builtin_signbit (tree exp
)
7577 tree arglist
= TREE_OPERAND (exp
, 1);
7580 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7583 arg
= TREE_VALUE (arglist
);
7585 /* If ARG is a compile-time constant, determine the result. */
7586 if (TREE_CODE (arg
) == REAL_CST
7587 && !TREE_CONSTANT_OVERFLOW (arg
))
7591 c
= TREE_REAL_CST (arg
);
7592 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
7593 return fold_convert (TREE_TYPE (exp
), temp
);
7596 /* If ARG is non-negative, the result is always zero. */
7597 if (tree_expr_nonnegative_p (arg
))
7598 return omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, arg
);
7600 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
7601 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
7602 return fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
7603 build_real (TREE_TYPE (arg
), dconst0
)));
7608 /* Fold function call to builtin copysign, copysignf or copysignl.
7609 Return NULL_TREE if no simplification can be made. */
7612 fold_builtin_copysign (tree arglist
, tree type
)
7616 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7619 arg1
= TREE_VALUE (arglist
);
7620 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7622 /* copysign(X,X) is X. */
7623 if (operand_equal_p (arg1
, arg2
, 0))
7624 return fold_convert (type
, arg1
);
7626 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
7627 if (TREE_CODE (arg1
) == REAL_CST
7628 && TREE_CODE (arg2
) == REAL_CST
7629 && !TREE_CONSTANT_OVERFLOW (arg1
)
7630 && !TREE_CONSTANT_OVERFLOW (arg2
))
7632 REAL_VALUE_TYPE c1
, c2
;
7634 c1
= TREE_REAL_CST (arg1
);
7635 c2
= TREE_REAL_CST (arg2
);
7636 real_copysign (&c1
, &c2
);
7637 return build_real (type
, c1
);
7641 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
7642 Remember to evaluate Y for side-effects. */
7643 if (tree_expr_nonnegative_p (arg2
))
7644 return omit_one_operand (type
,
7645 fold (build1 (ABS_EXPR
, type
, arg1
)),
7651 /* Fold a call to builtin isascii. */
7654 fold_builtin_isascii (tree arglist
)
7656 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7660 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
7661 tree arg
= TREE_VALUE (arglist
);
7663 arg
= fold (build2 (EQ_EXPR
, integer_type_node
,
7664 build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7665 build_int_2 (~ (unsigned HOST_WIDE_INT
) 0x7f,
7666 ~ (HOST_WIDE_INT
) 0)),
7667 integer_zero_node
));
7669 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7676 /* Fold a call to builtin toascii. */
7679 fold_builtin_toascii (tree arglist
)
7681 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7685 /* Transform toascii(c) -> (c & 0x7f). */
7686 tree arg
= TREE_VALUE (arglist
);
7688 return fold (build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7689 build_int_2 (0x7f, 0)));
7693 /* Fold a call to builtin isdigit. */
7696 fold_builtin_isdigit (tree arglist
)
7698 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7702 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
7703 /* According to the C standard, isdigit is unaffected by locale. */
7704 tree arg
= TREE_VALUE (arglist
);
7705 arg
= fold_convert (unsigned_type_node
, arg
);
7706 arg
= build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
7707 fold_convert (unsigned_type_node
,
7708 build_int_2 (TARGET_DIGIT0
, 0)));
7709 arg
= build2 (LE_EXPR
, integer_type_node
, arg
,
7710 fold_convert (unsigned_type_node
, build_int_2 (9, 0)));
7712 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7719 /* Fold a call to fabs, fabsf or fabsl. */
7722 fold_builtin_fabs (tree arglist
, tree type
)
7726 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7729 arg
= TREE_VALUE (arglist
);
7730 if (TREE_CODE (arg
) == REAL_CST
)
7731 return fold_abs_const (arg
, type
);
7732 return fold (build1 (ABS_EXPR
, type
, arg
));
7735 /* Fold a call to abs, labs, llabs or imaxabs. */
7738 fold_builtin_abs (tree arglist
, tree type
)
7742 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7745 arg
= TREE_VALUE (arglist
);
7746 if (TREE_CODE (arg
) == INTEGER_CST
)
7747 return fold_abs_const (arg
, type
);
7748 return fold (build1 (ABS_EXPR
, type
, arg
));
7751 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
7752 EXP is the CALL_EXPR for the call. */
7755 fold_builtin_classify (tree exp
, int builtin_index
)
7757 tree fndecl
= get_callee_fndecl (exp
);
7758 tree arglist
= TREE_OPERAND (exp
, 1);
7759 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7763 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7765 /* Check that we have exactly one argument. */
7768 error ("too few arguments to function `%s'",
7769 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7770 return error_mark_node
;
7772 else if (TREE_CHAIN (arglist
) != 0)
7774 error ("too many arguments to function `%s'",
7775 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7776 return error_mark_node
;
7780 error ("non-floating-point argument to function `%s'",
7781 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7782 return error_mark_node
;
7786 arg
= TREE_VALUE (arglist
);
7787 switch (builtin_index
)
7789 case BUILT_IN_ISINF
:
7790 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
7791 return omit_one_operand (type
, integer_zero_node
, arg
);
7793 if (TREE_CODE (arg
) == REAL_CST
)
7795 r
= TREE_REAL_CST (arg
);
7796 if (real_isinf (&r
))
7797 return real_compare (GT_EXPR
, &r
, &dconst0
)
7798 ? integer_one_node
: integer_minus_one_node
;
7800 return integer_zero_node
;
7805 case BUILT_IN_FINITE
:
7806 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
)))
7807 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
7808 return omit_one_operand (type
, integer_zero_node
, arg
);
7810 if (TREE_CODE (arg
) == REAL_CST
)
7812 r
= TREE_REAL_CST (arg
);
7813 return real_isinf (&r
) || real_isnan (&r
)
7814 ? integer_zero_node
: integer_one_node
;
7819 case BUILT_IN_ISNAN
:
7820 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
))))
7821 return omit_one_operand (type
, integer_zero_node
, arg
);
7823 if (TREE_CODE (arg
) == REAL_CST
)
7825 r
= TREE_REAL_CST (arg
);
7826 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
7829 arg
= builtin_save_expr (arg
);
7830 return fold (build2 (UNORDERED_EXPR
, type
, arg
, arg
));
7837 /* Fold a call to an unordered comparison function such as
7838 __builtin_isgreater(). EXP is the CALL_EXPR for the call.
7839 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
7840 the opposite of the desired result. UNORDERED_CODE is used
7841 for modes that can hold NaNs and ORDERED_CODE is used for
7845 fold_builtin_unordered_cmp (tree exp
,
7846 enum tree_code unordered_code
,
7847 enum tree_code ordered_code
)
7849 tree fndecl
= get_callee_fndecl (exp
);
7850 tree arglist
= TREE_OPERAND (exp
, 1);
7851 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7852 enum tree_code code
;
7855 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7857 enum tree_code code0
, code1
;
7861 /* Check that we have exactly two arguments. */
7862 if (arglist
== 0 || TREE_CHAIN (arglist
) == 0)
7864 error ("too few arguments to function `%s'",
7865 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7866 return error_mark_node
;
7868 else if (TREE_CHAIN (TREE_CHAIN (arglist
)) != 0)
7870 error ("too many arguments to function `%s'",
7871 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7872 return error_mark_node
;
7875 arg0
= TREE_VALUE (arglist
);
7876 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7878 type0
= TREE_TYPE (arg0
);
7879 type1
= TREE_TYPE (arg1
);
7881 code0
= TREE_CODE (type0
);
7882 code1
= TREE_CODE (type1
);
7884 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
7885 /* Choose the wider of two real types. */
7886 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
7888 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
7890 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
7894 error ("non-floating-point argument to function `%s'",
7895 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7896 return error_mark_node
;
7899 arg0
= fold_convert (cmp_type
, arg0
);
7900 arg1
= fold_convert (cmp_type
, arg1
);
7904 arg0
= TREE_VALUE (arglist
);
7905 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7908 if (unordered_code
== UNORDERED_EXPR
)
7910 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
7911 return omit_two_operands (type
, integer_zero_node
, arg0
, arg1
);
7912 return fold (build2 (UNORDERED_EXPR
, type
, arg0
, arg1
));
7915 code
= MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
7917 return fold (build1 (TRUTH_NOT_EXPR
, type
,
7918 fold (build2 (code
, type
, arg0
, arg1
))));
7921 /* Used by constant folding to simplify calls to builtin functions. EXP is
7922 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
7923 result of the function call is ignored. This function returns NULL_TREE
7924 if no simplification was possible. */
7927 fold_builtin_1 (tree exp
, bool ignore
)
7929 tree fndecl
= get_callee_fndecl (exp
);
7930 tree arglist
= TREE_OPERAND (exp
, 1);
7931 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7933 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7936 switch (DECL_FUNCTION_CODE (fndecl
))
7938 case BUILT_IN_CONSTANT_P
:
7939 return fold_builtin_constant_p (arglist
);
7941 case BUILT_IN_EXPECT
:
7942 return fold_builtin_expect (arglist
);
7944 case BUILT_IN_CLASSIFY_TYPE
:
7945 return fold_builtin_classify_type (arglist
);
7947 case BUILT_IN_STRLEN
:
7948 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
7950 tree len
= c_strlen (TREE_VALUE (arglist
), 0);
7953 /* Convert from the internal "sizetype" type to "size_t". */
7955 len
= fold_convert (size_type_node
, len
);
7962 case BUILT_IN_FABSF
:
7963 case BUILT_IN_FABSL
:
7964 return fold_builtin_fabs (arglist
, type
);
7968 case BUILT_IN_LLABS
:
7969 case BUILT_IN_IMAXABS
:
7970 return fold_builtin_abs (arglist
, type
);
7973 case BUILT_IN_CONJF
:
7974 case BUILT_IN_CONJL
:
7975 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7976 return fold (build1 (CONJ_EXPR
, type
, TREE_VALUE (arglist
)));
7979 case BUILT_IN_CREAL
:
7980 case BUILT_IN_CREALF
:
7981 case BUILT_IN_CREALL
:
7982 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7983 return non_lvalue (fold (build1 (REALPART_EXPR
, type
,
7984 TREE_VALUE (arglist
))));
7987 case BUILT_IN_CIMAG
:
7988 case BUILT_IN_CIMAGF
:
7989 case BUILT_IN_CIMAGL
:
7990 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7991 return non_lvalue (fold (build1 (IMAGPART_EXPR
, type
,
7992 TREE_VALUE (arglist
))));
7996 case BUILT_IN_CABSF
:
7997 case BUILT_IN_CABSL
:
7998 return fold_builtin_cabs (arglist
, type
);
8001 case BUILT_IN_SQRTF
:
8002 case BUILT_IN_SQRTL
:
8003 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8005 enum built_in_function fcode
;
8006 tree arg
= TREE_VALUE (arglist
);
8008 /* Optimize sqrt of constant value. */
8009 if (TREE_CODE (arg
) == REAL_CST
8010 && ! TREE_CONSTANT_OVERFLOW (arg
))
8012 REAL_VALUE_TYPE r
, x
;
8014 x
= TREE_REAL_CST (arg
);
8015 if (real_sqrt (&r
, TYPE_MODE (type
), &x
)
8016 || (!flag_trapping_math
&& !flag_errno_math
))
8017 return build_real (type
, r
);
8020 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
8021 fcode
= builtin_mathfn_code (arg
);
8022 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
8024 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
8025 arg
= fold (build2 (MULT_EXPR
, type
,
8026 TREE_VALUE (TREE_OPERAND (arg
, 1)),
8027 build_real (type
, dconsthalf
)));
8028 arglist
= build_tree_list (NULL_TREE
, arg
);
8029 return build_function_call_expr (expfn
, arglist
);
8032 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
8033 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
8035 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
8039 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
8041 /* The inner root was either sqrt or cbrt. */
8042 REAL_VALUE_TYPE dconstroot
=
8043 BUILTIN_SQRT_P (fcode
) ? dconsthalf
: dconstthird
;
8045 /* Adjust for the outer root. */
8046 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
8047 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
8048 tree_root
= build_real (type
, dconstroot
);
8049 arglist
= tree_cons (NULL_TREE
, arg0
,
8050 build_tree_list (NULL_TREE
, tree_root
));
8051 return build_function_call_expr (powfn
, arglist
);
8055 /* Optimize sqrt(pow(x,y)) = pow(x,y*0.5). */
8056 if (flag_unsafe_math_optimizations
8057 && (fcode
== BUILT_IN_POW
8058 || fcode
== BUILT_IN_POWF
8059 || fcode
== BUILT_IN_POWL
))
8061 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
8062 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
8063 tree arg1
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
8064 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
8065 build_real (type
, dconsthalf
)));
8066 arglist
= tree_cons (NULL_TREE
, arg0
,
8067 build_tree_list (NULL_TREE
, narg1
));
8068 return build_function_call_expr (powfn
, arglist
);
8074 case BUILT_IN_CBRTF
:
8075 case BUILT_IN_CBRTL
:
8076 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8078 tree arg
= TREE_VALUE (arglist
);
8079 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8081 /* Optimize cbrt of constant value. */
8082 if (real_zerop (arg
) || real_onep (arg
) || real_minus_onep (arg
))
8085 /* Optimize cbrt(expN(x)) -> expN(x/3). */
8086 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
8088 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
8089 const REAL_VALUE_TYPE third_trunc
=
8090 real_value_truncate (TYPE_MODE (type
), dconstthird
);
8091 arg
= fold (build2 (MULT_EXPR
, type
,
8092 TREE_VALUE (TREE_OPERAND (arg
, 1)),
8093 build_real (type
, third_trunc
)));
8094 arglist
= build_tree_list (NULL_TREE
, arg
);
8095 return build_function_call_expr (expfn
, arglist
);
8098 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
8099 /* We don't optimize cbrt(cbrt(x)) -> pow(x,1/9) because if
8100 x is negative pow will error but cbrt won't. */
8101 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
8103 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
8107 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
8109 REAL_VALUE_TYPE dconstroot
= dconstthird
;
8111 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
8112 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
8113 tree_root
= build_real (type
, dconstroot
);
8114 arglist
= tree_cons (NULL_TREE
, arg0
,
8115 build_tree_list (NULL_TREE
, tree_root
));
8116 return build_function_call_expr (powfn
, arglist
);
8126 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8128 tree arg
= TREE_VALUE (arglist
);
8130 /* Optimize sin(0.0) = 0.0. */
8131 if (real_zerop (arg
))
8139 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8141 tree arg
= TREE_VALUE (arglist
);
8143 /* Optimize cos(0.0) = 1.0. */
8144 if (real_zerop (arg
))
8145 return build_real (type
, dconst1
);
8147 /* Optimize cos(-x) into cos(x). */
8148 if (TREE_CODE (arg
) == NEGATE_EXPR
)
8150 tree arglist
= build_tree_list (NULL_TREE
,
8151 TREE_OPERAND (arg
, 0));
8152 return build_function_call_expr (fndecl
, arglist
);
8160 return fold_builtin_exponent (exp
, &dconste
);
8163 case BUILT_IN_EXP2F
:
8164 case BUILT_IN_EXP2L
:
8165 return fold_builtin_exponent (exp
, &dconst2
);
8167 case BUILT_IN_EXP10
:
8168 case BUILT_IN_EXP10F
:
8169 case BUILT_IN_EXP10L
:
8170 case BUILT_IN_POW10
:
8171 case BUILT_IN_POW10F
:
8172 case BUILT_IN_POW10L
:
8173 return fold_builtin_exponent (exp
, &dconst10
);
8178 return fold_builtin_logarithm (exp
, &dconste
);
8181 case BUILT_IN_LOG2F
:
8182 case BUILT_IN_LOG2L
:
8183 return fold_builtin_logarithm (exp
, &dconst2
);
8185 case BUILT_IN_LOG10
:
8186 case BUILT_IN_LOG10F
:
8187 case BUILT_IN_LOG10L
:
8188 return fold_builtin_logarithm (exp
, &dconst10
);
8193 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8195 enum built_in_function fcode
;
8196 tree arg
= TREE_VALUE (arglist
);
8198 /* Optimize tan(0.0) = 0.0. */
8199 if (real_zerop (arg
))
8202 /* Optimize tan(atan(x)) = x. */
8203 fcode
= builtin_mathfn_code (arg
);
8204 if (flag_unsafe_math_optimizations
8205 && (fcode
== BUILT_IN_ATAN
8206 || fcode
== BUILT_IN_ATANF
8207 || fcode
== BUILT_IN_ATANL
))
8208 return TREE_VALUE (TREE_OPERAND (arg
, 1));
8213 case BUILT_IN_ATANF
:
8214 case BUILT_IN_ATANL
:
8215 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8217 tree arg
= TREE_VALUE (arglist
);
8219 /* Optimize atan(0.0) = 0.0. */
8220 if (real_zerop (arg
))
8223 /* Optimize atan(1.0) = pi/4. */
8224 if (real_onep (arg
))
8226 REAL_VALUE_TYPE cst
;
8228 real_convert (&cst
, TYPE_MODE (type
), &dconstpi
);
8229 SET_REAL_EXP (&cst
, REAL_EXP (&cst
) - 2);
8230 return build_real (type
, cst
);
8238 if (validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8240 enum built_in_function fcode
;
8241 tree arg0
= TREE_VALUE (arglist
);
8242 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
8244 /* Optimize pow(1.0,y) = 1.0. */
8245 if (real_onep (arg0
))
8246 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
8248 if (TREE_CODE (arg1
) == REAL_CST
8249 && ! TREE_CONSTANT_OVERFLOW (arg1
))
8252 c
= TREE_REAL_CST (arg1
);
8254 /* Optimize pow(x,0.0) = 1.0. */
8255 if (REAL_VALUES_EQUAL (c
, dconst0
))
8256 return omit_one_operand (type
, build_real (type
, dconst1
),
8259 /* Optimize pow(x,1.0) = x. */
8260 if (REAL_VALUES_EQUAL (c
, dconst1
))
8263 /* Optimize pow(x,-1.0) = 1.0/x. */
8264 if (REAL_VALUES_EQUAL (c
, dconstm1
))
8265 return fold (build2 (RDIV_EXPR
, type
,
8266 build_real (type
, dconst1
), arg0
));
8268 /* Optimize pow(x,0.5) = sqrt(x). */
8269 if (flag_unsafe_math_optimizations
8270 && REAL_VALUES_EQUAL (c
, dconsthalf
))
8272 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
8274 if (sqrtfn
!= NULL_TREE
)
8276 tree arglist
= build_tree_list (NULL_TREE
, arg0
);
8277 return build_function_call_expr (sqrtfn
, arglist
);
8281 /* Attempt to evaluate pow at compile-time. */
8282 if (TREE_CODE (arg0
) == REAL_CST
8283 && ! TREE_CONSTANT_OVERFLOW (arg0
))
8285 REAL_VALUE_TYPE cint
;
8288 n
= real_to_integer (&c
);
8289 real_from_integer (&cint
, VOIDmode
, n
,
8291 if (real_identical (&c
, &cint
))
8296 x
= TREE_REAL_CST (arg0
);
8297 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
8298 if (flag_unsafe_math_optimizations
|| !inexact
)
8299 return build_real (type
, x
);
8304 /* Optimize pow(expN(x),y) = expN(x*y). */
8305 fcode
= builtin_mathfn_code (arg0
);
8306 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
8308 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
8309 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
8310 arg
= fold (build2 (MULT_EXPR
, type
, arg
, arg1
));
8311 arglist
= build_tree_list (NULL_TREE
, arg
);
8312 return build_function_call_expr (expfn
, arglist
);
8315 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8316 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
8318 tree narg0
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
8319 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
8320 build_real (type
, dconsthalf
)));
8322 arglist
= tree_cons (NULL_TREE
, narg0
,
8323 build_tree_list (NULL_TREE
, narg1
));
8324 return build_function_call_expr (fndecl
, arglist
);
8327 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
8328 if (flag_unsafe_math_optimizations
8329 && (fcode
== BUILT_IN_POW
8330 || fcode
== BUILT_IN_POWF
8331 || fcode
== BUILT_IN_POWL
))
8333 tree arg00
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
8334 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0
, 1)));
8335 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg01
, arg1
));
8336 arglist
= tree_cons (NULL_TREE
, arg00
,
8337 build_tree_list (NULL_TREE
, narg1
));
8338 return build_function_call_expr (fndecl
, arglist
);
8346 return fold_builtin_inf (type
, true);
8348 case BUILT_IN_HUGE_VAL
:
8349 case BUILT_IN_HUGE_VALF
:
8350 case BUILT_IN_HUGE_VALL
:
8351 return fold_builtin_inf (type
, false);
8356 return fold_builtin_nan (arglist
, type
, true);
8359 case BUILT_IN_NANSF
:
8360 case BUILT_IN_NANSL
:
8361 return fold_builtin_nan (arglist
, type
, false);
8363 case BUILT_IN_FLOOR
:
8364 case BUILT_IN_FLOORF
:
8365 case BUILT_IN_FLOORL
:
8366 return fold_builtin_floor (exp
);
8369 case BUILT_IN_CEILF
:
8370 case BUILT_IN_CEILL
:
8371 return fold_builtin_ceil (exp
);
8373 case BUILT_IN_TRUNC
:
8374 case BUILT_IN_TRUNCF
:
8375 case BUILT_IN_TRUNCL
:
8376 return fold_builtin_trunc (exp
);
8378 case BUILT_IN_ROUND
:
8379 case BUILT_IN_ROUNDF
:
8380 case BUILT_IN_ROUNDL
:
8381 return fold_builtin_round (exp
);
8383 case BUILT_IN_NEARBYINT
:
8384 case BUILT_IN_NEARBYINTF
:
8385 case BUILT_IN_NEARBYINTL
:
8387 case BUILT_IN_RINTF
:
8388 case BUILT_IN_RINTL
:
8389 return fold_trunc_transparent_mathfn (exp
);
8391 case BUILT_IN_LROUND
:
8392 case BUILT_IN_LROUNDF
:
8393 case BUILT_IN_LROUNDL
:
8394 case BUILT_IN_LLROUND
:
8395 case BUILT_IN_LLROUNDF
:
8396 case BUILT_IN_LLROUNDL
:
8397 return fold_builtin_lround (exp
);
8399 case BUILT_IN_LRINT
:
8400 case BUILT_IN_LRINTF
:
8401 case BUILT_IN_LRINTL
:
8402 case BUILT_IN_LLRINT
:
8403 case BUILT_IN_LLRINTF
:
8404 case BUILT_IN_LLRINTL
:
8405 return fold_fixed_mathfn (exp
);
8409 case BUILT_IN_FFSLL
:
8412 case BUILT_IN_CLZLL
:
8415 case BUILT_IN_CTZLL
:
8416 case BUILT_IN_POPCOUNT
:
8417 case BUILT_IN_POPCOUNTL
:
8418 case BUILT_IN_POPCOUNTLL
:
8419 case BUILT_IN_PARITY
:
8420 case BUILT_IN_PARITYL
:
8421 case BUILT_IN_PARITYLL
:
8422 return fold_builtin_bitop (exp
);
8424 case BUILT_IN_MEMCPY
:
8425 return fold_builtin_memcpy (exp
);
8427 case BUILT_IN_MEMPCPY
:
8428 return fold_builtin_mempcpy (exp
);
8430 case BUILT_IN_MEMMOVE
:
8431 return fold_builtin_memmove (exp
);
8433 case BUILT_IN_STRCPY
:
8434 return fold_builtin_strcpy (exp
, NULL_TREE
);
8436 case BUILT_IN_STRNCPY
:
8437 return fold_builtin_strncpy (exp
, NULL_TREE
);
8439 case BUILT_IN_INDEX
:
8440 case BUILT_IN_STRCHR
:
8441 return fold_builtin_strchr (exp
, false);
8443 case BUILT_IN_RINDEX
:
8444 case BUILT_IN_STRRCHR
:
8445 return fold_builtin_strchr (exp
, true);
8447 case BUILT_IN_MEMCMP
:
8448 return fold_builtin_memcmp (exp
);
8450 case BUILT_IN_STRCMP
:
8451 return fold_builtin_strcmp (exp
);
8453 case BUILT_IN_STRNCMP
:
8454 return fold_builtin_strncmp (exp
);
8456 case BUILT_IN_SIGNBIT
:
8457 case BUILT_IN_SIGNBITF
:
8458 case BUILT_IN_SIGNBITL
:
8459 return fold_builtin_signbit (exp
);
8461 case BUILT_IN_ISASCII
:
8462 return fold_builtin_isascii (arglist
);
8464 case BUILT_IN_TOASCII
:
8465 return fold_builtin_toascii (arglist
);
8467 case BUILT_IN_ISDIGIT
:
8468 return fold_builtin_isdigit (arglist
);
8470 case BUILT_IN_COPYSIGN
:
8471 case BUILT_IN_COPYSIGNF
:
8472 case BUILT_IN_COPYSIGNL
:
8473 return fold_builtin_copysign (arglist
, type
);
8475 case BUILT_IN_FINITE
:
8476 case BUILT_IN_FINITEF
:
8477 case BUILT_IN_FINITEL
:
8478 return fold_builtin_classify (exp
, BUILT_IN_FINITE
);
8480 case BUILT_IN_ISINF
:
8481 case BUILT_IN_ISINFF
:
8482 case BUILT_IN_ISINFL
:
8483 return fold_builtin_classify (exp
, BUILT_IN_ISINF
);
8485 case BUILT_IN_ISNAN
:
8486 case BUILT_IN_ISNANF
:
8487 case BUILT_IN_ISNANL
:
8488 return fold_builtin_classify (exp
, BUILT_IN_ISNAN
);
8490 case BUILT_IN_ISGREATER
:
8491 return fold_builtin_unordered_cmp (exp
, UNLE_EXPR
, LE_EXPR
);
8492 case BUILT_IN_ISGREATEREQUAL
:
8493 return fold_builtin_unordered_cmp (exp
, UNLT_EXPR
, LT_EXPR
);
8494 case BUILT_IN_ISLESS
:
8495 return fold_builtin_unordered_cmp (exp
, UNGE_EXPR
, GE_EXPR
);
8496 case BUILT_IN_ISLESSEQUAL
:
8497 return fold_builtin_unordered_cmp (exp
, UNGT_EXPR
, GT_EXPR
);
8498 case BUILT_IN_ISLESSGREATER
:
8499 return fold_builtin_unordered_cmp (exp
, UNEQ_EXPR
, EQ_EXPR
);
8500 case BUILT_IN_ISUNORDERED
:
8501 return fold_builtin_unordered_cmp (exp
, UNORDERED_EXPR
, NOP_EXPR
);
8503 case BUILT_IN_FPUTS
:
8504 return fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8506 case BUILT_IN_FPUTS_UNLOCKED
:
8507 return fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8516 /* A wrapper function for builtin folding that prevents warnings for
8517 "statement without effect" and the like, caused by removing the
8518 call node earlier than the warning is generated. */
8521 fold_builtin (tree exp
, bool ignore
)
8523 exp
= fold_builtin_1 (exp
, ignore
);
8526 /* ??? Don't clobber shared nodes such as integer_zero_node. */
8527 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
8528 exp
= build1 (NOP_EXPR
, TREE_TYPE (exp
), exp
);
8529 TREE_NO_WARNING (exp
) = 1;
8534 /* Conveniently construct a function call expression. */
8537 build_function_call_expr (tree fn
, tree arglist
)
8541 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
8542 call_expr
= build3 (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
8543 call_expr
, arglist
, NULL_TREE
);
8544 return fold (call_expr
);
8547 /* This function validates the types of a function call argument list
8548 represented as a tree chain of parameters against a specified list
8549 of tree_codes. If the last specifier is a 0, that represents an
8550 ellipses, otherwise the last specifier must be a VOID_TYPE. */
8553 validate_arglist (tree arglist
, ...)
8555 enum tree_code code
;
8559 va_start (ap
, arglist
);
8563 code
= va_arg (ap
, enum tree_code
);
8567 /* This signifies an ellipses, any further arguments are all ok. */
8571 /* This signifies an endlink, if no arguments remain, return
8572 true, otherwise return false. */
8576 /* If no parameters remain or the parameter's code does not
8577 match the specified code, return false. Otherwise continue
8578 checking any remaining arguments. */
8580 || code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
8584 arglist
= TREE_CHAIN (arglist
);
8588 /* We need gotos here since we can only have one VA_CLOSE in a
8596 /* Default target-specific builtin expander that does nothing. */
8599 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
8600 rtx target ATTRIBUTE_UNUSED
,
8601 rtx subtarget ATTRIBUTE_UNUSED
,
8602 enum machine_mode mode ATTRIBUTE_UNUSED
,
8603 int ignore ATTRIBUTE_UNUSED
)
8608 /* Returns true is EXP represents data that would potentially reside
8609 in a readonly section. */
8612 readonly_data_expr (tree exp
)
8616 if (TREE_CODE (exp
) != ADDR_EXPR
)
8619 exp
= get_base_address (TREE_OPERAND (exp
, 0));
8623 /* Make sure we call decl_readonly_section only for trees it
8624 can handle (since it returns true for everything it doesn't
8626 if (TREE_CODE (exp
) == STRING_CST
8627 || TREE_CODE (exp
) == CONSTRUCTOR
8628 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
8629 return decl_readonly_section (exp
, 0);
8634 /* Front-end to the simplify_builtin_XXX routines.
8636 EXP is a call to a builtin function. If possible try to simplify
8637 that into a constant, expression or call to a more efficient
8640 If IGNORE is nonzero, then the result of this builtin function
8643 If simplification is possible, return the simplified tree, otherwise
8644 return NULL_TREE. */
8647 simplify_builtin (tree exp
, int ignore
)
8649 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
8650 tree arglist
= TREE_OPERAND (exp
, 1);
8651 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
8656 case BUILT_IN_FPUTS
:
8657 val
= fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8659 case BUILT_IN_FPUTS_UNLOCKED
:
8660 val
= fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8662 case BUILT_IN_STRSTR
:
8663 val
= simplify_builtin_strstr (arglist
);
8665 case BUILT_IN_STRCAT
:
8666 val
= simplify_builtin_strcat (arglist
);
8668 case BUILT_IN_STRNCAT
:
8669 val
= simplify_builtin_strncat (arglist
);
8671 case BUILT_IN_STRSPN
:
8672 val
= simplify_builtin_strspn (arglist
);
8674 case BUILT_IN_STRCSPN
:
8675 val
= simplify_builtin_strcspn (arglist
);
8677 case BUILT_IN_STRCHR
:
8678 case BUILT_IN_INDEX
:
8679 val
= simplify_builtin_strchr (arglist
);
8681 case BUILT_IN_STRRCHR
:
8682 case BUILT_IN_RINDEX
:
8683 val
= simplify_builtin_strrchr (arglist
);
8685 case BUILT_IN_STRCPY
:
8686 val
= fold_builtin_strcpy (exp
, NULL_TREE
);
8688 case BUILT_IN_STRNCPY
:
8689 val
= fold_builtin_strncpy (exp
, NULL_TREE
);
8691 case BUILT_IN_STRCMP
:
8692 val
= simplify_builtin_strcmp (arglist
);
8694 case BUILT_IN_STRNCMP
:
8695 val
= simplify_builtin_strncmp (arglist
);
8697 case BUILT_IN_STRPBRK
:
8698 val
= simplify_builtin_strpbrk (arglist
);
8701 case BUILT_IN_MEMCMP
:
8702 val
= simplify_builtin_memcmp (arglist
);
8704 case BUILT_IN_VA_START
:
8705 simplify_builtin_va_start (arglist
);
8708 case BUILT_IN_SPRINTF
:
8709 val
= simplify_builtin_sprintf (arglist
, ignore
);
8711 case BUILT_IN_CONSTANT_P
:
8712 val
= fold_builtin_constant_p (arglist
);
8713 /* Gimplification will pull the CALL_EXPR for the builtin out of
8714 an if condition. When not optimizing, we'll not CSE it back.
8715 To avoid link error types of regressions, return false now. */
8716 if (!val
&& !optimize
)
8717 val
= integer_zero_node
;
8725 val
= fold_convert (TREE_TYPE (exp
), val
);
8729 /* Simplify a call to the strstr builtin.
8731 Return 0 if no simplification was possible, otherwise return the
8732 simplified form of the call as a tree.
8734 The simplified form may be a constant or other expression which
8735 computes the same value, but in a more efficient manner (including
8736 calls to other builtin functions).
8738 The call may contain arguments which need to be evaluated, but
8739 which are not useful to determine the result of the call. In
8740 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8741 COMPOUND_EXPR will be an argument which must be evaluated.
8742 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8743 COMPOUND_EXPR in the chain will contain the tree for the simplified
8744 form of the builtin function call. */
8747 simplify_builtin_strstr (tree arglist
)
8749 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8753 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8755 const char *p1
, *p2
;
8764 const char *r
= strstr (p1
, p2
);
8767 return fold_convert (TREE_TYPE (s1
), integer_zero_node
);
8769 /* Return an offset into the constant string argument. */
8770 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8771 s1
, fold_convert (TREE_TYPE (s1
),
8772 ssize_int (r
- p1
))));
8781 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8785 /* New argument list transforming strstr(s1, s2) to
8786 strchr(s1, s2[0]). */
8787 arglist
= build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
8788 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8789 return build_function_call_expr (fn
, arglist
);
8793 /* Simplify a call to the strstr builtin.
8795 Return 0 if no simplification was possible, otherwise return the
8796 simplified form of the call as a tree.
8798 The simplified form may be a constant or other expression which
8799 computes the same value, but in a more efficient manner (including
8800 calls to other builtin functions).
8802 The call may contain arguments which need to be evaluated, but
8803 which are not useful to determine the result of the call. In
8804 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8805 COMPOUND_EXPR will be an argument which must be evaluated.
8806 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8807 COMPOUND_EXPR in the chain will contain the tree for the simplified
8808 form of the builtin function call. */
8811 simplify_builtin_strchr (tree arglist
)
8813 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8817 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8820 if (TREE_CODE (s2
) != INTEGER_CST
)
8829 if (target_char_cast (s2
, &c
))
8835 return fold_convert (TREE_TYPE (s1
), integer_zero_node
);
8837 /* Return an offset into the constant string argument. */
8838 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8839 s1
, fold_convert (TREE_TYPE (s1
),
8840 ssize_int (r
- p1
))));
8843 /* FIXME: Should use here strchrM optab so that ports can optimize
8849 /* Simplify a call to the strrchr builtin.
8851 Return 0 if no simplification was possible, otherwise return the
8852 simplified form of the call as a tree.
8854 The simplified form may be a constant or other expression which
8855 computes the same value, but in a more efficient manner (including
8856 calls to other builtin functions).
8858 The call may contain arguments which need to be evaluated, but
8859 which are not useful to determine the result of the call. In
8860 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8861 COMPOUND_EXPR will be an argument which must be evaluated.
8862 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8863 COMPOUND_EXPR in the chain will contain the tree for the simplified
8864 form of the builtin function call. */
8867 simplify_builtin_strrchr (tree arglist
)
8869 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8873 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8877 if (TREE_CODE (s2
) != INTEGER_CST
)
8886 if (target_char_cast (s2
, &c
))
8889 r
= strrchr (p1
, c
);
8892 return fold_convert (TREE_TYPE (s1
), integer_zero_node
);
8894 /* Return an offset into the constant string argument. */
8895 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8896 s1
, fold_convert (TREE_TYPE (s1
),
8897 ssize_int (r
- p1
))));
8900 if (! integer_zerop (s2
))
8903 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8907 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
8908 return build_function_call_expr (fn
, arglist
);
8912 /* Simplify a call to the strpbrk builtin.
8914 Return 0 if no simplification was possible, otherwise return the
8915 simplified form of the call as a tree.
8917 The simplified form may be a constant or other expression which
8918 computes the same value, but in a more efficient manner (including
8919 calls to other builtin functions).
8921 The call may contain arguments which need to be evaluated, but
8922 which are not useful to determine the result of the call. In
8923 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8924 COMPOUND_EXPR will be an argument which must be evaluated.
8925 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8926 COMPOUND_EXPR in the chain will contain the tree for the simplified
8927 form of the builtin function call. */
8930 simplify_builtin_strpbrk (tree arglist
)
8932 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8936 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8938 const char *p1
, *p2
;
8947 const char *r
= strpbrk (p1
, p2
);
8950 return fold_convert (TREE_TYPE (s1
), integer_zero_node
);
8952 /* Return an offset into the constant string argument. */
8953 return fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8954 s1
, fold_convert (TREE_TYPE (s1
),
8955 ssize_int (r
- p1
))));
8959 /* strpbrk(x, "") == NULL.
8960 Evaluate and ignore s1 in case it had side-effects. */
8961 return omit_one_operand (TREE_TYPE (s1
), integer_zero_node
, s1
);
8964 return 0; /* Really call strpbrk. */
8966 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8970 /* New argument list transforming strpbrk(s1, s2) to
8971 strchr(s1, s2[0]). */
8973 build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
8974 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8975 return build_function_call_expr (fn
, arglist
);
8979 /* Simplify a call to the memcmp builtin.
8981 Return 0 if no simplification was possible, otherwise return the
8982 simplified form of the call as a tree.
8984 The simplified form may be a constant or other expression which
8985 computes the same value, but in a more efficient manner (including
8986 calls to other builtin functions).
8988 The call may contain arguments which need to be evaluated, but
8989 which are not useful to determine the result of the call. In
8990 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8991 COMPOUND_EXPR will be an argument which must be evaluated.
8992 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8993 COMPOUND_EXPR in the chain will contain the tree for the simplified
8994 form of the builtin function call. */
8997 simplify_builtin_memcmp (tree arglist
)
8999 tree arg1
, arg2
, len
;
9000 const char *p1
, *p2
;
9002 if (!validate_arglist (arglist
,
9003 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9006 arg1
= TREE_VALUE (arglist
);
9007 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
9008 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9010 /* If the len parameter is zero, return zero. */
9011 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 0)
9012 /* Evaluate and ignore arg1 and arg2 in case they have side-effects. */
9013 return omit_two_operands (integer_type_node
, integer_zero_node
,
9016 p1
= c_getstr (arg1
);
9017 p2
= c_getstr (arg2
);
9019 /* If all arguments are constant, and the value of len is not greater
9020 than the lengths of arg1 and arg2, evaluate at compile-time. */
9021 if (host_integerp (len
, 1) && p1
&& p2
9022 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
9023 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
9025 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
9028 ? integer_minus_one_node
9029 : (r
> 0 ? integer_one_node
: integer_zero_node
));
9032 /* If len parameter is one, return an expression corresponding to
9033 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9034 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
9036 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9037 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
9039 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9040 build1 (INDIRECT_REF
, cst_uchar_node
,
9041 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
9043 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9044 build1 (INDIRECT_REF
, cst_uchar_node
,
9045 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
9046 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
9052 /* Simplify a call to the strcmp builtin.
9054 Return 0 if no simplification was possible, otherwise return the
9055 simplified form of the call as a tree.
9057 The simplified form may be a constant or other expression which
9058 computes the same value, but in a more efficient manner (including
9059 calls to other builtin functions).
9061 The call may contain arguments which need to be evaluated, but
9062 which are not useful to determine the result of the call. In
9063 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9064 COMPOUND_EXPR will be an argument which must be evaluated.
9065 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9066 COMPOUND_EXPR in the chain will contain the tree for the simplified
9067 form of the builtin function call. */
9070 simplify_builtin_strcmp (tree arglist
)
9073 const char *p1
, *p2
;
9075 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9078 arg1
= TREE_VALUE (arglist
);
9079 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
9081 /* If both arguments are equal (and not volatile), return zero. */
9082 if (operand_equal_p (arg1
, arg2
, 0))
9083 return integer_zero_node
;
9085 p1
= c_getstr (arg1
);
9086 p2
= c_getstr (arg2
);
9090 const int i
= strcmp (p1
, p2
);
9092 ? integer_minus_one_node
9093 : (i
> 0 ? integer_one_node
: integer_zero_node
));
9096 /* If either arg is "", return an expression corresponding to
9097 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9098 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
9100 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9101 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
9103 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9104 build1 (INDIRECT_REF
, cst_uchar_node
,
9105 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
9107 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9108 build1 (INDIRECT_REF
, cst_uchar_node
,
9109 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
9110 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
9116 /* Simplify a call to the strncmp builtin.
9118 Return 0 if no simplification was possible, otherwise return the
9119 simplified form of the call as a tree.
9121 The simplified form may be a constant or other expression which
9122 computes the same value, but in a more efficient manner (including
9123 calls to other builtin functions).
9125 The call may contain arguments which need to be evaluated, but
9126 which are not useful to determine the result of the call. In
9127 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9128 COMPOUND_EXPR will be an argument which must be evaluated.
9129 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9130 COMPOUND_EXPR in the chain will contain the tree for the simplified
9131 form of the builtin function call. */
9134 simplify_builtin_strncmp (tree arglist
)
9136 tree arg1
, arg2
, arg3
;
9137 const char *p1
, *p2
;
9139 if (!validate_arglist (arglist
,
9140 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9143 arg1
= TREE_VALUE (arglist
);
9144 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
9145 arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9147 /* If the len parameter is zero, return zero. */
9148 if (integer_zerop (arg3
))
9149 /* Evaluate and ignore arg1 and arg2 in case they have side-effects. */
9150 return omit_two_operands (integer_type_node
, integer_zero_node
,
9153 /* If arg1 and arg2 are equal (and not volatile), return zero. */
9154 if (operand_equal_p (arg1
, arg2
, 0))
9155 /* Evaluate and ignore arg3 in case it has side-effects. */
9156 return omit_one_operand (integer_type_node
, integer_zero_node
, arg3
);
9158 p1
= c_getstr (arg1
);
9159 p2
= c_getstr (arg2
);
9161 /* If all arguments are constant, evaluate at compile-time. */
9162 if (host_integerp (arg3
, 1) && p1
&& p2
)
9164 const int r
= strncmp (p1
, p2
, tree_low_cst (arg3
, 1));
9166 ? integer_minus_one_node
9167 : (r
> 0 ? integer_one_node
: integer_zero_node
));
9170 /* If len == 1 or (either string parameter is "" and (len >= 1)),
9171 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
9172 if (host_integerp (arg3
, 1)
9173 && (tree_low_cst (arg3
, 1) == 1
9174 || (tree_low_cst (arg3
, 1) > 1
9175 && ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0')))))
9177 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9178 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
9180 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9181 build1 (INDIRECT_REF
, cst_uchar_node
,
9182 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
9184 fold (build1 (CONVERT_EXPR
, integer_type_node
,
9185 build1 (INDIRECT_REF
, cst_uchar_node
,
9186 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
9187 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
9193 /* Simplify a call to the strcat builtin.
9195 Return 0 if no simplification was possible, otherwise return the
9196 simplified form of the call as a tree.
9198 The simplified form may be a constant or other expression which
9199 computes the same value, but in a more efficient manner (including
9200 calls to other builtin functions).
9202 The call may contain arguments which need to be evaluated, but
9203 which are not useful to determine the result of the call. In
9204 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9205 COMPOUND_EXPR will be an argument which must be evaluated.
9206 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9207 COMPOUND_EXPR in the chain will contain the tree for the simplified
9208 form of the builtin function call. */
9211 simplify_builtin_strcat (tree arglist
)
9213 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9217 tree dst
= TREE_VALUE (arglist
),
9218 src
= TREE_VALUE (TREE_CHAIN (arglist
));
9219 const char *p
= c_getstr (src
);
9221 /* If the string length is zero, return the dst parameter. */
9222 if (p
&& *p
== '\0')
9229 /* Simplify a call to the strncat builtin.
9231 Return 0 if no simplification was possible, otherwise return the
9232 simplified form of the call as a tree.
9234 The simplified form may be a constant or other expression which
9235 computes the same value, but in a more efficient manner (including
9236 calls to other builtin functions).
9238 The call may contain arguments which need to be evaluated, but
9239 which are not useful to determine the result of the call. In
9240 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9241 COMPOUND_EXPR will be an argument which must be evaluated.
9242 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9243 COMPOUND_EXPR in the chain will contain the tree for the simplified
9244 form of the builtin function call. */
9247 simplify_builtin_strncat (tree arglist
)
9249 if (!validate_arglist (arglist
,
9250 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9254 tree dst
= TREE_VALUE (arglist
);
9255 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
9256 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9257 const char *p
= c_getstr (src
);
9259 /* If the requested length is zero, or the src parameter string
9260 length is zero, return the dst parameter. */
9261 if (integer_zerop (len
) || (p
&& *p
== '\0'))
9262 return omit_two_operands (TREE_TYPE (dst
), dst
, src
, len
);
9264 /* If the requested len is greater than or equal to the string
9265 length, call strcat. */
9266 if (TREE_CODE (len
) == INTEGER_CST
&& p
9267 && compare_tree_int (len
, strlen (p
)) >= 0)
9270 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
9271 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
9273 /* If the replacement _DECL isn't initialized, don't do the
9278 return build_function_call_expr (fn
, newarglist
);
9284 /* Simplify a call to the strspn builtin.
9286 Return 0 if no simplification was possible, otherwise return the
9287 simplified form of the call as a tree.
9289 The simplified form may be a constant or other expression which
9290 computes the same value, but in a more efficient manner (including
9291 calls to other builtin functions).
9293 The call may contain arguments which need to be evaluated, but
9294 which are not useful to determine the result of the call. In
9295 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9296 COMPOUND_EXPR will be an argument which must be evaluated.
9297 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9298 COMPOUND_EXPR in the chain will contain the tree for the simplified
9299 form of the builtin function call. */
9302 simplify_builtin_strspn (tree arglist
)
9304 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9308 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9309 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9311 /* If both arguments are constants, evaluate at compile-time. */
9314 const size_t r
= strspn (p1
, p2
);
9315 return size_int (r
);
9318 /* If either argument is "", return 0. */
9319 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
9320 /* Evaluate and ignore both arguments in case either one has
9322 return omit_two_operands (integer_type_node
, integer_zero_node
,
9328 /* Simplify a call to the strcspn builtin.
9330 Return 0 if no simplification was possible, otherwise return the
9331 simplified form of the call as a tree.
9333 The simplified form may be a constant or other expression which
9334 computes the same value, but in a more efficient manner (including
9335 calls to other builtin functions).
9337 The call may contain arguments which need to be evaluated, but
9338 which are not useful to determine the result of the call. In
9339 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9340 COMPOUND_EXPR will be an argument which must be evaluated.
9341 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9342 COMPOUND_EXPR in the chain will contain the tree for the simplified
9343 form of the builtin function call. */
9346 simplify_builtin_strcspn (tree arglist
)
9348 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9352 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9353 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9355 /* If both arguments are constants, evaluate at compile-time. */
9358 const size_t r
= strcspn (p1
, p2
);
9359 return size_int (r
);
9362 /* If the first argument is "", return 0. */
9363 if (p1
&& *p1
== '\0')
9365 /* Evaluate and ignore argument s2 in case it has
9367 return omit_one_operand (integer_type_node
,
9368 integer_zero_node
, s2
);
9371 /* If the second argument is "", return __builtin_strlen(s1). */
9372 if (p2
&& *p2
== '\0')
9374 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
9375 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
9377 /* If the replacement _DECL isn't initialized, don't do the
9382 return build_function_call_expr (fn
, newarglist
);
9388 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
9389 by the builtin will be ignored. UNLOCKED is true is true if this
9390 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
9391 the known length of the string. Return NULL_TREE if no simplification
9395 fold_builtin_fputs (tree arglist
, bool ignore
, bool unlocked
, tree len
)
9398 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
9399 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
9400 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
9401 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
9403 /* If the return value is used, or the replacement _DECL isn't
9404 initialized, don't do the transformation. */
9405 if (!ignore
|| !fn_fputc
|| !fn_fwrite
)
9408 /* Verify the arguments in the original call. */
9409 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9413 len
= c_strlen (TREE_VALUE (arglist
), 0);
9415 /* Get the length of the string passed to fputs. If the length
9416 can't be determined, punt. */
9418 || TREE_CODE (len
) != INTEGER_CST
)
9421 switch (compare_tree_int (len
, 1))
9423 case -1: /* length is 0, delete the call entirely . */
9424 return omit_one_operand (integer_type_node
, integer_zero_node
,
9425 TREE_VALUE (TREE_CHAIN (arglist
)));
9427 case 0: /* length is 1, call fputc. */
9429 const char *p
= c_getstr (TREE_VALUE (arglist
));
9433 /* New argument list transforming fputs(string, stream) to
9434 fputc(string[0], stream). */
9436 build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
9437 arglist
= tree_cons (NULL_TREE
, build_int_2 (p
[0], 0), arglist
);
9443 case 1: /* length is greater than 1, call fwrite. */
9447 /* If optimizing for size keep fputs. */
9450 string_arg
= TREE_VALUE (arglist
);
9451 /* New argument list transforming fputs(string, stream) to
9452 fwrite(string, 1, len, stream). */
9453 arglist
= build_tree_list (NULL_TREE
,
9454 TREE_VALUE (TREE_CHAIN (arglist
)));
9455 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
9456 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
9457 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
9465 /* These optimizations are only performed when the result is ignored,
9466 hence there's no need to cast the result to integer_type_node. */
9467 return build_function_call_expr (fn
, arglist
);
9471 simplify_builtin_va_start (tree arglist
)
9473 tree chain
= TREE_CHAIN (arglist
);
9475 if (TREE_CHAIN (chain
))
9476 error ("too many arguments to function `va_start'");
9478 simplify_builtin_next_arg (chain
);
9482 simplify_builtin_next_arg (tree arglist
)
9484 tree fntype
= TREE_TYPE (current_function_decl
);
9486 if (TYPE_ARG_TYPES (fntype
) == 0
9487 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
9489 error ("`va_start' used in function with fixed args");
9492 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
9493 tree arg
= TREE_VALUE (arglist
);
9495 /* Strip off all nops for the sake of the comparison. This
9496 is not quite the same as STRIP_NOPS. It does more.
9497 We must also strip off INDIRECT_EXPR for C++ reference
9499 while (TREE_CODE (arg
) == NOP_EXPR
9500 || TREE_CODE (arg
) == CONVERT_EXPR
9501 || TREE_CODE (arg
) == NON_LVALUE_EXPR
9502 || TREE_CODE (arg
) == INDIRECT_REF
)
9503 arg
= TREE_OPERAND (arg
, 0);
9504 if (arg
!= last_parm
)
9505 warning ("second parameter of `va_start' not last named argument");
9506 TREE_VALUE (arglist
) = arg
;
9509 /* Evidently an out of date version of <stdarg.h>; can't validate
9510 va_start's second argument, but can still work as intended. */
9511 warning ("`__builtin_next_arg' called without an argument");
9515 /* Simplify a call to the sprintf builtin.
9517 Return 0 if no simplification was possible, otherwise return the
9518 simplified form of the call as a tree. If IGNORED is true, it means that
9519 the caller does not use the returned value of the function. */
9522 simplify_builtin_sprintf (tree arglist
, int ignored
)
9524 tree call
, retval
, dest
, fmt
;
9525 const char *fmt_str
= NULL
;
9527 /* Verify the required arguments in the original call. We deal with two
9528 types of sprintf() calls: 'sprintf (str, fmt)' and
9529 'sprintf (dest, "%s", orig)'. */
9530 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
)
9531 && !validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
9535 /* Get the destination string and the format specifier. */
9536 dest
= TREE_VALUE (arglist
);
9537 fmt
= TREE_VALUE (TREE_CHAIN (arglist
));
9539 /* Check whether the format is a literal string constant. */
9540 fmt_str
= c_getstr (fmt
);
9541 if (fmt_str
== NULL
)
9547 /* If the format doesn't contain % args or %%, use strcpy. */
9548 if (strchr (fmt_str
, '%') == NULL
)
9550 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9555 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9556 'format' is known to contain no % formats. */
9557 arglist
= build_tree_list (NULL_TREE
, fmt
);
9558 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9559 call
= build_function_call_expr (fn
, arglist
);
9561 retval
= build_int_2 (strlen (fmt_str
), 0);
9564 /* If the format is "%s", use strcpy if the result isn't used. */
9565 else if (fmt_str
&& strcmp (fmt_str
, "%s") == 0)
9568 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9573 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
9574 orig
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9575 arglist
= build_tree_list (NULL_TREE
, orig
);
9576 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9579 retval
= c_strlen (orig
, 1);
9580 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
9583 call
= build_function_call_expr (fn
, arglist
);
9589 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
9591 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);