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"
32 #include "hard-reg-set.h"
35 #include "insn-config.h"
41 #include "typeclass.h"
46 #include "langhooks.h"
48 #define CALLED_AS_BUILT_IN(NODE) \
49 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
51 #ifndef PAD_VARARGS_DOWN
52 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
55 /* Define the names of the builtin function types and codes. */
56 const char *const built_in_class_names[4]
57 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
59 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM) #X,
60 const char *const built_in_names[(int) END_BUILTINS] =
62 #include "builtins.def"
66 /* Setup an array of _DECL trees, make sure each element is
67 initialized to NULL_TREE. */
68 tree built_in_decls[(int) END_BUILTINS];
69 /* Declarations used when constructing the builtin implicitly in the compiler.
70 It may be NULL_TREE when this is invalid (for instance runtime is not
71 required to implement the function call in all cases. */
72 tree implicit_built_in_decls[(int) END_BUILTINS];
74 static int get_pointer_alignment (tree, unsigned int);
75 static tree c_strlen (tree, int);
76 static const char *c_getstr (tree);
77 static rtx c_readstr (const char *, enum machine_mode);
78 static int target_char_cast (tree, char *);
79 static rtx get_memory_rtx (tree);
80 static tree build_string_literal (int, const char *);
81 static int apply_args_size (void);
82 static int apply_result_size (void);
83 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
84 static rtx result_vector (int, rtx);
86 static rtx expand_builtin_setjmp (tree, rtx);
87 static void expand_builtin_prefetch (tree);
88 static rtx expand_builtin_apply_args (void);
89 static rtx expand_builtin_apply_args_1 (void);
90 static rtx expand_builtin_apply (rtx, rtx, rtx);
91 static void expand_builtin_return (rtx);
92 static enum type_class type_to_class (tree);
93 static rtx expand_builtin_classify_type (tree);
94 static void expand_errno_check (tree, rtx);
95 static rtx expand_builtin_mathfn (tree, rtx, rtx);
96 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
97 static rtx expand_builtin_constant_p (tree, enum machine_mode);
98 static rtx expand_builtin_args_info (tree);
99 static rtx expand_builtin_next_arg (tree);
100 static rtx expand_builtin_va_start (tree);
101 static rtx expand_builtin_va_end (tree);
102 static rtx expand_builtin_va_copy (tree);
103 static rtx expand_builtin_memcmp (tree, tree, rtx, enum machine_mode);
104 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
105 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
106 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
107 static rtx expand_builtin_strcat (tree, rtx, enum machine_mode);
108 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
109 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
110 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
111 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
112 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode, int);
113 static rtx expand_builtin_memmove (tree, rtx, enum machine_mode);
114 static rtx expand_builtin_bcopy (tree);
115 static rtx expand_builtin_strcpy (tree, rtx, enum machine_mode);
116 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
117 static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
118 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
119 static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
120 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
121 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
122 static rtx expand_builtin_bzero (tree);
123 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
124 static rtx expand_builtin_strstr (tree, rtx, enum machine_mode);
125 static rtx expand_builtin_strpbrk (tree, rtx, enum machine_mode);
126 static rtx expand_builtin_strchr (tree, rtx, enum machine_mode);
127 static rtx expand_builtin_strrchr (tree, rtx, enum machine_mode);
128 static rtx expand_builtin_alloca (tree, rtx);
129 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
130 static rtx expand_builtin_frame_address (tree, tree);
131 static rtx expand_builtin_fputs (tree, rtx, bool);
132 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
133 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
134 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
135 static tree stabilize_va_list (tree, int);
136 static rtx expand_builtin_expect (tree, rtx);
137 static tree fold_builtin_constant_p (tree);
138 static tree fold_builtin_classify_type (tree);
139 static tree fold_builtin_inf (tree, int);
140 static tree fold_builtin_nan (tree, tree, int);
141 static int validate_arglist (tree, ...);
142 static bool integer_valued_real_p (tree);
143 static tree fold_trunc_transparent_mathfn (tree);
144 static bool readonly_data_expr (tree);
145 static rtx expand_builtin_fabs (tree, rtx, rtx);
146 static rtx expand_builtin_cabs (tree, rtx);
147 static rtx expand_builtin_signbit (tree, rtx);
148 static tree fold_builtin_cabs (tree, tree, tree);
149 static tree fold_builtin_trunc (tree);
150 static tree fold_builtin_floor (tree);
151 static tree fold_builtin_ceil (tree);
152 static tree fold_builtin_round (tree);
153 static tree fold_builtin_bitop (tree);
154 static tree fold_builtin_memcpy (tree);
155 static tree fold_builtin_mempcpy (tree);
156 static tree fold_builtin_memmove (tree);
157 static tree fold_builtin_strcpy (tree);
158 static tree fold_builtin_strncpy (tree);
159 static tree fold_builtin_memcmp (tree);
160 static tree fold_builtin_strcmp (tree);
161 static tree fold_builtin_strncmp (tree);
162 static tree fold_builtin_signbit (tree);
164 /* Return the alignment in bits of EXP, a pointer valued expression.
165 But don't return more than MAX_ALIGN no matter what.
166 The alignment returned is, by default, the alignment of the thing that
167 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
169 Otherwise, look at the expression to see if we can do better, i.e., if the
170 expression is actually pointing at an object whose alignment is tighter. */
173 get_pointer_alignment (tree exp, unsigned int max_align)
175 unsigned int align, inner;
177 if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
180 align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
181 align = MIN (align, max_align);
185 switch (TREE_CODE (exp))
189 case NON_LVALUE_EXPR:
190 exp = TREE_OPERAND (exp, 0);
191 if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
194 inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
195 align = MIN (inner, max_align);
199 /* If sum of pointer + int, restrict our maximum alignment to that
200 imposed by the integer. If not, we can't do any better than
202 if (! host_integerp (TREE_OPERAND (exp, 1), 1))
205 while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
206 & (max_align / BITS_PER_UNIT - 1))
210 exp = TREE_OPERAND (exp, 0);
214 /* See what we are pointing at and look at its alignment. */
215 exp = TREE_OPERAND (exp, 0);
216 if (TREE_CODE (exp) == FUNCTION_DECL)
217 align = FUNCTION_BOUNDARY;
218 else if (DECL_P (exp))
219 align = DECL_ALIGN (exp);
220 #ifdef CONSTANT_ALIGNMENT
221 else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
222 align = CONSTANT_ALIGNMENT (exp, align);
224 return MIN (align, max_align);
232 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
233 way, because it could contain a zero byte in the middle.
234 TREE_STRING_LENGTH is the size of the character array, not the string.
236 ONLY_VALUE should be nonzero if the result is not going to be emitted
237 into the instruction stream and zero if it is going to be expanded.
238 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
239 is returned, otherwise NULL, since
240 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
241 evaluate the side-effects.
243 The value returned is of type `ssizetype'.
245 Unfortunately, string_constant can't access the values of const char
246 arrays with initializers, so neither can we do so here. */
249 c_strlen (tree src, int only_value)
252 HOST_WIDE_INT offset;
257 if (TREE_CODE (src) == COND_EXPR
258 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
262 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
263 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
264 if (tree_int_cst_equal (len1, len2))
268 if (TREE_CODE (src) == COMPOUND_EXPR
269 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
270 return c_strlen (TREE_OPERAND (src, 1), only_value);
272 src = string_constant (src, &offset_node);
276 max = TREE_STRING_LENGTH (src) - 1;
277 ptr = TREE_STRING_POINTER (src);
279 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
281 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
282 compute the offset to the following null if we don't know where to
283 start searching for it. */
286 for (i = 0; i < max; i++)
290 /* We don't know the starting offset, but we do know that the string
291 has no internal zero bytes. We can assume that the offset falls
292 within the bounds of the string; otherwise, the programmer deserves
293 what he gets. Subtract the offset from the length of the string,
294 and return that. This would perhaps not be valid if we were dealing
295 with named arrays in addition to literal string constants. */
297 return size_diffop (size_int (max), offset_node);
300 /* We have a known offset into the string. Start searching there for
301 a null character if we can represent it as a single HOST_WIDE_INT. */
302 if (offset_node == 0)
304 else if (! host_integerp (offset_node, 0))
307 offset = tree_low_cst (offset_node, 0);
309 /* If the offset is known to be out of bounds, warn, and call strlen at
311 if (offset < 0 || offset > max)
313 warning ("offset outside bounds of constant string");
317 /* Use strlen to search for the first zero byte. Since any strings
318 constructed with build_string will have nulls appended, we win even
319 if we get handed something like (char[4])"abcd".
321 Since OFFSET is our starting index into the string, no further
322 calculation is needed. */
323 return ssize_int (strlen (ptr + offset));
326 /* Return a char pointer for a C string if it is a string constant
327 or sum of string constant and integer constant. */
334 src = string_constant (src, &offset_node);
338 if (offset_node == 0)
339 return TREE_STRING_POINTER (src);
340 else if (!host_integerp (offset_node, 1)
341 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
344 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
347 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
348 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
351 c_readstr (const char *str, enum machine_mode mode)
357 if (GET_MODE_CLASS (mode) != MODE_INT)
362 for (i = 0; i < GET_MODE_SIZE (mode); i++)
365 if (WORDS_BIG_ENDIAN)
366 j = GET_MODE_SIZE (mode) - i - 1;
367 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
368 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
369 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
371 if (j > 2 * HOST_BITS_PER_WIDE_INT)
374 ch = (unsigned char) str[i];
375 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
377 return immed_double_const (c[0], c[1], mode);
380 /* Cast a target constant CST to target CHAR and if that value fits into
381 host char type, return zero and put that value into variable pointed by
385 target_char_cast (tree cst, char *p)
387 unsigned HOST_WIDE_INT val, hostval;
389 if (!host_integerp (cst, 1)
390 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
393 val = tree_low_cst (cst, 1);
394 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
395 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
398 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
399 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
408 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
409 times to get the address of either a higher stack frame, or a return
410 address located within it (depending on FNDECL_CODE). */
413 expand_builtin_return_addr (enum built_in_function fndecl_code, int count,
418 /* Some machines need special handling before we can access
419 arbitrary frames. For example, on the sparc, we must first flush
420 all register windows to the stack. */
421 #ifdef SETUP_FRAME_ADDRESSES
423 SETUP_FRAME_ADDRESSES ();
426 /* On the sparc, the return address is not in the frame, it is in a
427 register. There is no way to access it off of the current frame
428 pointer, but it can be accessed off the previous frame pointer by
429 reading the value from the register window save area. */
430 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
431 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
435 /* Scan back COUNT frames to the specified frame. */
436 for (i = 0; i < count; i++)
438 /* Assume the dynamic chain pointer is in the word that the
439 frame address points to, unless otherwise specified. */
440 #ifdef DYNAMIC_CHAIN_ADDRESS
441 tem = DYNAMIC_CHAIN_ADDRESS (tem);
443 tem = memory_address (Pmode, tem);
444 tem = gen_rtx_MEM (Pmode, tem);
445 set_mem_alias_set (tem, get_frame_alias_set ());
446 tem = copy_to_reg (tem);
449 /* For __builtin_frame_address, return what we've got. */
450 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
453 /* For __builtin_return_address, Get the return address from that
455 #ifdef RETURN_ADDR_RTX
456 tem = RETURN_ADDR_RTX (count, tem);
458 tem = memory_address (Pmode,
459 plus_constant (tem, GET_MODE_SIZE (Pmode)));
460 tem = gen_rtx_MEM (Pmode, tem);
461 set_mem_alias_set (tem, get_frame_alias_set ());
466 /* Alias set used for setjmp buffer. */
467 static HOST_WIDE_INT setjmp_alias_set = -1;
469 /* Construct the leading half of a __builtin_setjmp call. Control will
470 return to RECEIVER_LABEL. This is used directly by sjlj exception
474 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
476 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
480 if (setjmp_alias_set == -1)
481 setjmp_alias_set = new_alias_set ();
483 buf_addr = convert_memory_address (Pmode, buf_addr);
485 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
489 /* We store the frame pointer and the address of receiver_label in
490 the buffer and use the rest of it for the stack save area, which
491 is machine-dependent. */
493 mem = gen_rtx_MEM (Pmode, buf_addr);
494 set_mem_alias_set (mem, setjmp_alias_set);
495 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
497 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
498 set_mem_alias_set (mem, setjmp_alias_set);
500 emit_move_insn (validize_mem (mem),
501 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
503 stack_save = gen_rtx_MEM (sa_mode,
504 plus_constant (buf_addr,
505 2 * GET_MODE_SIZE (Pmode)));
506 set_mem_alias_set (stack_save, setjmp_alias_set);
507 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
509 /* If there is further processing to do, do it. */
510 #ifdef HAVE_builtin_setjmp_setup
511 if (HAVE_builtin_setjmp_setup)
512 emit_insn (gen_builtin_setjmp_setup (buf_addr));
515 /* Tell optimize_save_area_alloca that extra work is going to
516 need to go on during alloca. */
517 current_function_calls_setjmp = 1;
519 /* Set this so all the registers get saved in our frame; we need to be
520 able to copy the saved values for any registers from frames we unwind. */
521 current_function_has_nonlocal_label = 1;
524 /* Construct the trailing part of a __builtin_setjmp call.
525 This is used directly by sjlj exception handling code. */
528 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
530 /* Clobber the FP when we get here, so we have to make sure it's
531 marked as used by this function. */
532 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
534 /* Mark the static chain as clobbered here so life information
535 doesn't get messed up for it. */
536 emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
538 /* Now put in the code to restore the frame pointer, and argument
539 pointer, if needed. The code below is from expand_end_bindings
540 in stmt.c; see detailed documentation there. */
541 #ifdef HAVE_nonlocal_goto
542 if (! HAVE_nonlocal_goto)
544 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
546 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
547 if (fixed_regs[ARG_POINTER_REGNUM])
549 #ifdef ELIMINABLE_REGS
551 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
553 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
554 if (elim_regs[i].from == ARG_POINTER_REGNUM
555 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
558 if (i == ARRAY_SIZE (elim_regs))
561 /* Now restore our arg pointer from the address at which it
562 was saved in our stack frame. */
563 emit_move_insn (virtual_incoming_args_rtx,
564 copy_to_reg (get_arg_pointer_save_area (cfun)));
569 #ifdef HAVE_builtin_setjmp_receiver
570 if (HAVE_builtin_setjmp_receiver)
571 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
574 #ifdef HAVE_nonlocal_goto_receiver
575 if (HAVE_nonlocal_goto_receiver)
576 emit_insn (gen_nonlocal_goto_receiver ());
581 /* @@@ This is a kludge. Not all machine descriptions define a blockage
582 insn, but we must not allow the code we just generated to be reordered
583 by scheduling. Specifically, the update of the frame pointer must
584 happen immediately, not later. So emit an ASM_INPUT to act as blockage
586 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
589 /* __builtin_setjmp is passed a pointer to an array of five words (not
590 all will be used on all machines). It operates similarly to the C
591 library function of the same name, but is more efficient. Much of
592 the code below (and for longjmp) is copied from the handling of
595 NOTE: This is intended for use by GNAT and the exception handling
596 scheme in the compiler and will only work in the method used by
600 expand_builtin_setjmp (tree arglist, rtx target)
602 rtx buf_addr, next_lab, cont_lab;
604 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
607 if (target == 0 || GET_CODE (target) != REG
608 || REGNO (target) < FIRST_PSEUDO_REGISTER)
609 target = gen_reg_rtx (TYPE_MODE (integer_type_node));
611 buf_addr = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
613 next_lab = gen_label_rtx ();
614 cont_lab = gen_label_rtx ();
616 expand_builtin_setjmp_setup (buf_addr, next_lab);
618 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
619 ensure that pending stack adjustments are flushed. */
620 emit_move_insn (target, const0_rtx);
621 emit_jump (cont_lab);
623 emit_label (next_lab);
625 expand_builtin_setjmp_receiver (next_lab);
627 /* Set TARGET to one. */
628 emit_move_insn (target, const1_rtx);
629 emit_label (cont_lab);
631 /* Tell flow about the strange goings on. Putting `next_lab' on
632 `nonlocal_goto_handler_labels' to indicates that function
633 calls may traverse the arc back to this label. */
635 current_function_has_nonlocal_label = 1;
636 nonlocal_goto_handler_labels
637 = gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
642 /* __builtin_longjmp is passed a pointer to an array of five words (not
643 all will be used on all machines). It operates similarly to the C
644 library function of the same name, but is more efficient. Much of
645 the code below is copied from the handling of non-local gotos.
647 NOTE: This is intended for use by GNAT and the exception handling
648 scheme in the compiler and will only work in the method used by
652 expand_builtin_longjmp (rtx buf_addr, rtx value)
654 rtx fp, lab, stack, insn, last;
655 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
657 if (setjmp_alias_set == -1)
658 setjmp_alias_set = new_alias_set ();
660 buf_addr = convert_memory_address (Pmode, buf_addr);
662 buf_addr = force_reg (Pmode, buf_addr);
664 /* We used to store value in static_chain_rtx, but that fails if pointers
665 are smaller than integers. We instead require that the user must pass
666 a second argument of 1, because that is what builtin_setjmp will
667 return. This also makes EH slightly more efficient, since we are no
668 longer copying around a value that we don't care about. */
669 if (value != const1_rtx)
672 current_function_calls_longjmp = 1;
674 last = get_last_insn ();
675 #ifdef HAVE_builtin_longjmp
676 if (HAVE_builtin_longjmp)
677 emit_insn (gen_builtin_longjmp (buf_addr));
681 fp = gen_rtx_MEM (Pmode, buf_addr);
682 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
683 GET_MODE_SIZE (Pmode)));
685 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
686 2 * GET_MODE_SIZE (Pmode)));
687 set_mem_alias_set (fp, setjmp_alias_set);
688 set_mem_alias_set (lab, setjmp_alias_set);
689 set_mem_alias_set (stack, setjmp_alias_set);
691 /* Pick up FP, label, and SP from the block and jump. This code is
692 from expand_goto in stmt.c; see there for detailed comments. */
693 #if HAVE_nonlocal_goto
694 if (HAVE_nonlocal_goto)
695 /* We have to pass a value to the nonlocal_goto pattern that will
696 get copied into the static_chain pointer, but it does not matter
697 what that value is, because builtin_setjmp does not use it. */
698 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
702 lab = copy_to_reg (lab);
704 emit_insn (gen_rtx_CLOBBER (VOIDmode,
705 gen_rtx_MEM (BLKmode,
706 gen_rtx_SCRATCH (VOIDmode))));
707 emit_insn (gen_rtx_CLOBBER (VOIDmode,
708 gen_rtx_MEM (BLKmode,
709 hard_frame_pointer_rtx)));
711 emit_move_insn (hard_frame_pointer_rtx, fp);
712 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
714 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
715 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
716 emit_indirect_jump (lab);
720 /* Search backwards and mark the jump insn as a non-local goto.
721 Note that this precludes the use of __builtin_longjmp to a
722 __builtin_setjmp target in the same function. However, we've
723 already cautioned the user that these functions are for
724 internal exception handling use only. */
725 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
729 if (GET_CODE (insn) == JUMP_INSN)
731 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
735 else if (GET_CODE (insn) == CALL_INSN)
740 /* Expand a call to __builtin_prefetch. For a target that does not support
741 data prefetch, evaluate the memory address argument in case it has side
745 expand_builtin_prefetch (tree arglist)
747 tree arg0, arg1, arg2;
750 if (!validate_arglist (arglist, POINTER_TYPE, 0))
753 arg0 = TREE_VALUE (arglist);
754 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
755 zero (read) and argument 2 (locality) defaults to 3 (high degree of
757 if (TREE_CHAIN (arglist))
759 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
760 if (TREE_CHAIN (TREE_CHAIN (arglist)))
761 arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
763 arg2 = build_int_2 (3, 0);
767 arg1 = integer_zero_node;
768 arg2 = build_int_2 (3, 0);
771 /* Argument 0 is an address. */
772 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
774 /* Argument 1 (read/write flag) must be a compile-time constant int. */
775 if (TREE_CODE (arg1) != INTEGER_CST)
777 error ("second arg to `__builtin_prefetch' must be a constant");
778 arg1 = integer_zero_node;
780 op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
781 /* Argument 1 must be either zero or one. */
782 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
784 warning ("invalid second arg to __builtin_prefetch; using zero");
788 /* Argument 2 (locality) must be a compile-time constant int. */
789 if (TREE_CODE (arg2) != INTEGER_CST)
791 error ("third arg to `__builtin_prefetch' must be a constant");
792 arg2 = integer_zero_node;
794 op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
795 /* Argument 2 must be 0, 1, 2, or 3. */
796 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
798 warning ("invalid third arg to __builtin_prefetch; using zero");
805 if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
807 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
808 || (GET_MODE (op0) != Pmode))
810 op0 = convert_memory_address (Pmode, op0);
811 op0 = force_reg (Pmode, op0);
813 emit_insn (gen_prefetch (op0, op1, op2));
817 op0 = protect_from_queue (op0, 0);
818 /* Don't do anything with direct references to volatile memory, but
819 generate code to handle other side effects. */
820 if (GET_CODE (op0) != MEM && side_effects_p (op0))
824 /* Get a MEM rtx for expression EXP which is the address of an operand
825 to be used to be used in a string instruction (cmpstrsi, movstrsi, ..). */
828 get_memory_rtx (tree exp)
830 rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_SUM);
833 addr = convert_memory_address (Pmode, addr);
835 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
837 /* Get an expression we can use to find the attributes to assign to MEM.
838 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
839 we can. First remove any nops. */
840 while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
841 || TREE_CODE (exp) == NON_LVALUE_EXPR)
842 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
843 exp = TREE_OPERAND (exp, 0);
845 if (TREE_CODE (exp) == ADDR_EXPR)
847 exp = TREE_OPERAND (exp, 0);
848 set_mem_attributes (mem, exp, 0);
850 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
852 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
853 /* memcpy, memset and other builtin stringops can alias with anything. */
854 set_mem_alias_set (mem, 0);
860 /* Built-in functions to perform an untyped call and return. */
862 /* For each register that may be used for calling a function, this
863 gives a mode used to copy the register's value. VOIDmode indicates
864 the register is not used for calling a function. If the machine
865 has register windows, this gives only the outbound registers.
866 INCOMING_REGNO gives the corresponding inbound register. */
867 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
869 /* For each register that may be used for returning values, this gives
870 a mode used to copy the register's value. VOIDmode indicates the
871 register is not used for returning values. If the machine has
872 register windows, this gives only the outbound registers.
873 INCOMING_REGNO gives the corresponding inbound register. */
874 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
876 /* For each register that may be used for calling a function, this
877 gives the offset of that register into the block returned by
878 __builtin_apply_args. 0 indicates that the register is not
879 used for calling a function. */
880 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
882 /* Return the size required for the block returned by __builtin_apply_args,
883 and initialize apply_args_mode. */
886 apply_args_size (void)
888 static int size = -1;
891 enum machine_mode mode;
893 /* The values computed by this function never change. */
896 /* The first value is the incoming arg-pointer. */
897 size = GET_MODE_SIZE (Pmode);
899 /* The second value is the structure value address unless this is
900 passed as an "invisible" first argument. */
901 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
902 size += GET_MODE_SIZE (Pmode);
904 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
905 if (FUNCTION_ARG_REGNO_P (regno))
907 mode = reg_raw_mode[regno];
909 if (mode == VOIDmode)
912 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
913 if (size % align != 0)
914 size = CEIL (size, align) * align;
915 apply_args_reg_offset[regno] = size;
916 size += GET_MODE_SIZE (mode);
917 apply_args_mode[regno] = mode;
921 apply_args_mode[regno] = VOIDmode;
922 apply_args_reg_offset[regno] = 0;
928 /* Return the size required for the block returned by __builtin_apply,
929 and initialize apply_result_mode. */
932 apply_result_size (void)
934 static int size = -1;
936 enum machine_mode mode;
938 /* The values computed by this function never change. */
943 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
944 if (FUNCTION_VALUE_REGNO_P (regno))
946 mode = reg_raw_mode[regno];
948 if (mode == VOIDmode)
951 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
952 if (size % align != 0)
953 size = CEIL (size, align) * align;
954 size += GET_MODE_SIZE (mode);
955 apply_result_mode[regno] = mode;
958 apply_result_mode[regno] = VOIDmode;
960 /* Allow targets that use untyped_call and untyped_return to override
961 the size so that machine-specific information can be stored here. */
962 #ifdef APPLY_RESULT_SIZE
963 size = APPLY_RESULT_SIZE;
969 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
970 /* Create a vector describing the result block RESULT. If SAVEP is true,
971 the result block is used to save the values; otherwise it is used to
972 restore the values. */
975 result_vector (int savep, rtx result)
977 int regno, size, align, nelts;
978 enum machine_mode mode;
980 rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
983 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
984 if ((mode = apply_result_mode[regno]) != VOIDmode)
986 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
987 if (size % align != 0)
988 size = CEIL (size, align) * align;
989 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
990 mem = adjust_address (result, mode, size);
991 savevec[nelts++] = (savep
992 ? gen_rtx_SET (VOIDmode, mem, reg)
993 : gen_rtx_SET (VOIDmode, reg, mem));
994 size += GET_MODE_SIZE (mode);
996 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
998 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1000 /* Save the state required to perform an untyped call with the same
1001 arguments as were passed to the current function. */
1004 expand_builtin_apply_args_1 (void)
1007 int size, align, regno;
1008 enum machine_mode mode;
1009 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1011 /* Create a block where the arg-pointer, structure value address,
1012 and argument registers can be saved. */
1013 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1015 /* Walk past the arg-pointer and structure value address. */
1016 size = GET_MODE_SIZE (Pmode);
1017 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1018 size += GET_MODE_SIZE (Pmode);
1020 /* Save each register used in calling a function to the block. */
1021 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1022 if ((mode = apply_args_mode[regno]) != VOIDmode)
1024 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1025 if (size % align != 0)
1026 size = CEIL (size, align) * align;
1028 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1030 emit_move_insn (adjust_address (registers, mode, size), tem);
1031 size += GET_MODE_SIZE (mode);
1034 /* Save the arg pointer to the block. */
1035 tem = copy_to_reg (virtual_incoming_args_rtx);
1036 #ifdef STACK_GROWS_DOWNWARD
1037 /* We need the pointer as the caller actually passed them to us, not
1038 as we might have pretended they were passed. Make sure it's a valid
1039 operand, as emit_move_insn isn't expected to handle a PLUS. */
1041 = force_operand (plus_constant (tem, current_function_pretend_args_size),
1044 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1046 size = GET_MODE_SIZE (Pmode);
1048 /* Save the structure value address unless this is passed as an
1049 "invisible" first argument. */
1050 if (struct_incoming_value)
1052 emit_move_insn (adjust_address (registers, Pmode, size),
1053 copy_to_reg (struct_incoming_value));
1054 size += GET_MODE_SIZE (Pmode);
1057 /* Return the address of the block. */
1058 return copy_addr_to_reg (XEXP (registers, 0));
1061 /* __builtin_apply_args returns block of memory allocated on
1062 the stack into which is stored the arg pointer, structure
1063 value address, static chain, and all the registers that might
1064 possibly be used in performing a function call. The code is
1065 moved to the start of the function so the incoming values are
1069 expand_builtin_apply_args (void)
1071 /* Don't do __builtin_apply_args more than once in a function.
1072 Save the result of the first call and reuse it. */
1073 if (apply_args_value != 0)
1074 return apply_args_value;
1076 /* When this function is called, it means that registers must be
1077 saved on entry to this function. So we migrate the
1078 call to the first insn of this function. */
1083 temp = expand_builtin_apply_args_1 ();
1087 apply_args_value = temp;
1089 /* Put the insns after the NOTE that starts the function.
1090 If this is inside a start_sequence, make the outer-level insn
1091 chain current, so the code is placed at the start of the
1093 push_topmost_sequence ();
1094 emit_insn_before (seq, NEXT_INSN (get_insns ()));
1095 pop_topmost_sequence ();
1100 /* Perform an untyped call and save the state required to perform an
1101 untyped return of whatever value was returned by the given function. */
1104 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1106 int size, align, regno;
1107 enum machine_mode mode;
1108 rtx incoming_args, result, reg, dest, src, call_insn;
1109 rtx old_stack_level = 0;
1110 rtx call_fusage = 0;
1111 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1113 arguments = convert_memory_address (Pmode, arguments);
1115 /* Create a block where the return registers can be saved. */
1116 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1118 /* Fetch the arg pointer from the ARGUMENTS block. */
1119 incoming_args = gen_reg_rtx (Pmode);
1120 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1121 #ifndef STACK_GROWS_DOWNWARD
1122 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1123 incoming_args, 0, OPTAB_LIB_WIDEN);
1126 /* Perform postincrements before actually calling the function. */
1129 /* Push a new argument block and copy the arguments. Do not allow
1130 the (potential) memcpy call below to interfere with our stack
1132 do_pending_stack_adjust ();
1135 /* Save the stack with nonlocal if available. */
1136 #ifdef HAVE_save_stack_nonlocal
1137 if (HAVE_save_stack_nonlocal)
1138 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1141 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1143 /* Allocate a block of memory onto the stack and copy the memory
1144 arguments to the outgoing arguments address. */
1145 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1146 dest = virtual_outgoing_args_rtx;
1147 #ifndef STACK_GROWS_DOWNWARD
1148 if (GET_CODE (argsize) == CONST_INT)
1149 dest = plus_constant (dest, -INTVAL (argsize));
1151 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1153 dest = gen_rtx_MEM (BLKmode, dest);
1154 set_mem_align (dest, PARM_BOUNDARY);
1155 src = gen_rtx_MEM (BLKmode, incoming_args);
1156 set_mem_align (src, PARM_BOUNDARY);
1157 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1159 /* Refer to the argument block. */
1161 arguments = gen_rtx_MEM (BLKmode, arguments);
1162 set_mem_align (arguments, PARM_BOUNDARY);
1164 /* Walk past the arg-pointer and structure value address. */
1165 size = GET_MODE_SIZE (Pmode);
1167 size += GET_MODE_SIZE (Pmode);
1169 /* Restore each of the registers previously saved. Make USE insns
1170 for each of these registers for use in making the call. */
1171 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1172 if ((mode = apply_args_mode[regno]) != VOIDmode)
1174 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1175 if (size % align != 0)
1176 size = CEIL (size, align) * align;
1177 reg = gen_rtx_REG (mode, regno);
1178 emit_move_insn (reg, adjust_address (arguments, mode, size));
1179 use_reg (&call_fusage, reg);
1180 size += GET_MODE_SIZE (mode);
1183 /* Restore the structure value address unless this is passed as an
1184 "invisible" first argument. */
1185 size = GET_MODE_SIZE (Pmode);
1188 rtx value = gen_reg_rtx (Pmode);
1189 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1190 emit_move_insn (struct_value, value);
1191 if (GET_CODE (struct_value) == REG)
1192 use_reg (&call_fusage, struct_value);
1193 size += GET_MODE_SIZE (Pmode);
1196 /* All arguments and registers used for the call are set up by now! */
1197 function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
1199 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1200 and we don't want to load it into a register as an optimization,
1201 because prepare_call_address already did it if it should be done. */
1202 if (GET_CODE (function) != SYMBOL_REF)
1203 function = memory_address (FUNCTION_MODE, function);
1205 /* Generate the actual call instruction and save the return value. */
1206 #ifdef HAVE_untyped_call
1207 if (HAVE_untyped_call)
1208 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1209 result, result_vector (1, result)));
1212 #ifdef HAVE_call_value
1213 if (HAVE_call_value)
1217 /* Locate the unique return register. It is not possible to
1218 express a call that sets more than one return register using
1219 call_value; use untyped_call for that. In fact, untyped_call
1220 only needs to save the return registers in the given block. */
1221 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1222 if ((mode = apply_result_mode[regno]) != VOIDmode)
1225 abort (); /* HAVE_untyped_call required. */
1226 valreg = gen_rtx_REG (mode, regno);
1229 emit_call_insn (GEN_CALL_VALUE (valreg,
1230 gen_rtx_MEM (FUNCTION_MODE, function),
1231 const0_rtx, NULL_RTX, const0_rtx));
1233 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1239 /* Find the CALL insn we just emitted, and attach the register usage
1241 call_insn = last_call_insn ();
1242 add_function_usage_to (call_insn, call_fusage);
1244 /* Restore the stack. */
1245 #ifdef HAVE_save_stack_nonlocal
1246 if (HAVE_save_stack_nonlocal)
1247 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1250 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1254 /* Return the address of the result block. */
1255 result = copy_addr_to_reg (XEXP (result, 0));
1256 return convert_memory_address (ptr_mode, result);
1259 /* Perform an untyped return. */
1262 expand_builtin_return (rtx result)
1264 int size, align, regno;
1265 enum machine_mode mode;
1267 rtx call_fusage = 0;
1269 result = convert_memory_address (Pmode, result);
1271 apply_result_size ();
1272 result = gen_rtx_MEM (BLKmode, result);
1274 #ifdef HAVE_untyped_return
1275 if (HAVE_untyped_return)
1277 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1283 /* Restore the return value and note that each value is used. */
1285 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1286 if ((mode = apply_result_mode[regno]) != VOIDmode)
1288 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1289 if (size % align != 0)
1290 size = CEIL (size, align) * align;
1291 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1292 emit_move_insn (reg, adjust_address (result, mode, size));
1294 push_to_sequence (call_fusage);
1295 emit_insn (gen_rtx_USE (VOIDmode, reg));
1296 call_fusage = get_insns ();
1298 size += GET_MODE_SIZE (mode);
1301 /* Put the USE insns before the return. */
1302 emit_insn (call_fusage);
1304 /* Return whatever values was restored by jumping directly to the end
1306 expand_naked_return ();
1309 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1311 static enum type_class
1312 type_to_class (tree type)
1314 switch (TREE_CODE (type))
1316 case VOID_TYPE: return void_type_class;
1317 case INTEGER_TYPE: return integer_type_class;
1318 case CHAR_TYPE: return char_type_class;
1319 case ENUMERAL_TYPE: return enumeral_type_class;
1320 case BOOLEAN_TYPE: return boolean_type_class;
1321 case POINTER_TYPE: return pointer_type_class;
1322 case REFERENCE_TYPE: return reference_type_class;
1323 case OFFSET_TYPE: return offset_type_class;
1324 case REAL_TYPE: return real_type_class;
1325 case COMPLEX_TYPE: return complex_type_class;
1326 case FUNCTION_TYPE: return function_type_class;
1327 case METHOD_TYPE: return method_type_class;
1328 case RECORD_TYPE: return record_type_class;
1330 case QUAL_UNION_TYPE: return union_type_class;
1331 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1332 ? string_type_class : array_type_class);
1333 case SET_TYPE: return set_type_class;
1334 case FILE_TYPE: return file_type_class;
1335 case LANG_TYPE: return lang_type_class;
1336 default: return no_type_class;
1340 /* Expand a call to __builtin_classify_type with arguments found in
1344 expand_builtin_classify_type (tree arglist)
1347 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1348 return GEN_INT (no_type_class);
1351 /* Expand expression EXP, which is a call to __builtin_constant_p. */
1354 expand_builtin_constant_p (tree arglist, enum machine_mode target_mode)
1360 arglist = TREE_VALUE (arglist);
1362 /* We have taken care of the easy cases during constant folding. This
1363 case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE
1364 get a chance to see if it can deduce whether ARGLIST is constant.
1365 If CSE isn't going to run, of course, don't bother waiting. */
1367 if (cse_not_expected)
1370 current_function_calls_constant_p = 1;
1372 tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);
1373 tmp = gen_rtx_CONSTANT_P_RTX (target_mode, tmp);
1377 /* This helper macro, meant to be used in mathfn_built_in below,
1378 determines which among a set of three builtin math functions is
1379 appropriate for a given type mode. The `F' and `L' cases are
1380 automatically generated from the `double' case. */
1381 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1382 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1383 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1384 fcodel = BUILT_IN_MATHFN##L ; break;
1386 /* Return mathematic function equivalent to FN but operating directly
1387 on TYPE, if available. If we can't do the conversion, return zero. */
1389 mathfn_built_in (tree type, enum built_in_function fn)
1391 const enum machine_mode type_mode = TYPE_MODE (type);
1392 enum built_in_function fcode, fcodef, fcodel;
1396 CASE_MATHFN (BUILT_IN_ACOS)
1397 CASE_MATHFN (BUILT_IN_ACOSH)
1398 CASE_MATHFN (BUILT_IN_ASIN)
1399 CASE_MATHFN (BUILT_IN_ASINH)
1400 CASE_MATHFN (BUILT_IN_ATAN)
1401 CASE_MATHFN (BUILT_IN_ATAN2)
1402 CASE_MATHFN (BUILT_IN_ATANH)
1403 CASE_MATHFN (BUILT_IN_CBRT)
1404 CASE_MATHFN (BUILT_IN_CEIL)
1405 CASE_MATHFN (BUILT_IN_COPYSIGN)
1406 CASE_MATHFN (BUILT_IN_COS)
1407 CASE_MATHFN (BUILT_IN_COSH)
1408 CASE_MATHFN (BUILT_IN_DREM)
1409 CASE_MATHFN (BUILT_IN_ERF)
1410 CASE_MATHFN (BUILT_IN_ERFC)
1411 CASE_MATHFN (BUILT_IN_EXP)
1412 CASE_MATHFN (BUILT_IN_EXP10)
1413 CASE_MATHFN (BUILT_IN_EXP2)
1414 CASE_MATHFN (BUILT_IN_EXPM1)
1415 CASE_MATHFN (BUILT_IN_FABS)
1416 CASE_MATHFN (BUILT_IN_FDIM)
1417 CASE_MATHFN (BUILT_IN_FLOOR)
1418 CASE_MATHFN (BUILT_IN_FMA)
1419 CASE_MATHFN (BUILT_IN_FMAX)
1420 CASE_MATHFN (BUILT_IN_FMIN)
1421 CASE_MATHFN (BUILT_IN_FMOD)
1422 CASE_MATHFN (BUILT_IN_FREXP)
1423 CASE_MATHFN (BUILT_IN_GAMMA)
1424 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1425 CASE_MATHFN (BUILT_IN_HYPOT)
1426 CASE_MATHFN (BUILT_IN_ILOGB)
1427 CASE_MATHFN (BUILT_IN_INF)
1428 CASE_MATHFN (BUILT_IN_J0)
1429 CASE_MATHFN (BUILT_IN_J1)
1430 CASE_MATHFN (BUILT_IN_JN)
1431 CASE_MATHFN (BUILT_IN_LDEXP)
1432 CASE_MATHFN (BUILT_IN_LGAMMA)
1433 CASE_MATHFN (BUILT_IN_LLRINT)
1434 CASE_MATHFN (BUILT_IN_LLROUND)
1435 CASE_MATHFN (BUILT_IN_LOG)
1436 CASE_MATHFN (BUILT_IN_LOG10)
1437 CASE_MATHFN (BUILT_IN_LOG1P)
1438 CASE_MATHFN (BUILT_IN_LOG2)
1439 CASE_MATHFN (BUILT_IN_LOGB)
1440 CASE_MATHFN (BUILT_IN_LRINT)
1441 CASE_MATHFN (BUILT_IN_LROUND)
1442 CASE_MATHFN (BUILT_IN_MODF)
1443 CASE_MATHFN (BUILT_IN_NAN)
1444 CASE_MATHFN (BUILT_IN_NANS)
1445 CASE_MATHFN (BUILT_IN_NEARBYINT)
1446 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1447 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1448 CASE_MATHFN (BUILT_IN_POW)
1449 CASE_MATHFN (BUILT_IN_POW10)
1450 CASE_MATHFN (BUILT_IN_REMAINDER)
1451 CASE_MATHFN (BUILT_IN_REMQUO)
1452 CASE_MATHFN (BUILT_IN_RINT)
1453 CASE_MATHFN (BUILT_IN_ROUND)
1454 CASE_MATHFN (BUILT_IN_SCALB)
1455 CASE_MATHFN (BUILT_IN_SCALBLN)
1456 CASE_MATHFN (BUILT_IN_SCALBN)
1457 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1458 CASE_MATHFN (BUILT_IN_SIN)
1459 CASE_MATHFN (BUILT_IN_SINCOS)
1460 CASE_MATHFN (BUILT_IN_SINH)
1461 CASE_MATHFN (BUILT_IN_SQRT)
1462 CASE_MATHFN (BUILT_IN_TAN)
1463 CASE_MATHFN (BUILT_IN_TANH)
1464 CASE_MATHFN (BUILT_IN_TGAMMA)
1465 CASE_MATHFN (BUILT_IN_TRUNC)
1466 CASE_MATHFN (BUILT_IN_Y0)
1467 CASE_MATHFN (BUILT_IN_Y1)
1468 CASE_MATHFN (BUILT_IN_YN)
1474 if (type_mode == TYPE_MODE (double_type_node))
1475 return implicit_built_in_decls[fcode];
1476 else if (type_mode == TYPE_MODE (float_type_node))
1477 return implicit_built_in_decls[fcodef];
1478 else if (type_mode == TYPE_MODE (long_double_type_node))
1479 return implicit_built_in_decls[fcodel];
1484 /* If errno must be maintained, expand the RTL to check if the result,
1485 TARGET, of a built-in function call, EXP, is NaN, and if so set
1489 expand_errno_check (tree exp, rtx target)
1491 rtx lab = gen_label_rtx ();
1493 /* Test the result; if it is NaN, set errno=EDOM because
1494 the argument was not in the domain. */
1495 emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1499 /* If this built-in doesn't throw an exception, set errno directly. */
1500 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
1502 #ifdef GEN_ERRNO_RTX
1503 rtx errno_rtx = GEN_ERRNO_RTX;
1506 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1508 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1514 /* We can't set errno=EDOM directly; let the library call do it.
1515 Pop the arguments right away in case the call gets deleted. */
1517 expand_call (exp, target, 0);
1523 /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
1524 Return 0 if a normal call should be emitted rather than expanding the
1525 function in-line. EXP is the expression that is a call to the builtin
1526 function; if convenient, the result should be placed in TARGET.
1527 SUBTARGET may be used as the target for computing one of EXP's operands. */
1530 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1532 optab builtin_optab;
1533 rtx op0, insns, before_call;
1534 tree fndecl = get_callee_fndecl (exp);
1535 tree arglist = TREE_OPERAND (exp, 1);
1536 enum machine_mode mode;
1537 bool errno_set = false;
1540 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1543 arg = TREE_VALUE (arglist);
1545 switch (DECL_FUNCTION_CODE (fndecl))
1550 builtin_optab = sin_optab; break;
1554 builtin_optab = cos_optab; break;
1556 case BUILT_IN_SQRTF:
1557 case BUILT_IN_SQRTL:
1558 errno_set = ! tree_expr_nonnegative_p (arg);
1559 builtin_optab = sqrt_optab;
1564 errno_set = true; builtin_optab = exp_optab; break;
1565 case BUILT_IN_EXP10:
1566 case BUILT_IN_EXP10F:
1567 case BUILT_IN_EXP10L:
1568 case BUILT_IN_POW10:
1569 case BUILT_IN_POW10F:
1570 case BUILT_IN_POW10L:
1571 errno_set = true; builtin_optab = exp10_optab; break;
1573 case BUILT_IN_EXP2F:
1574 case BUILT_IN_EXP2L:
1575 errno_set = true; builtin_optab = exp2_optab; break;
1579 errno_set = true; builtin_optab = log_optab; break;
1580 case BUILT_IN_LOG10:
1581 case BUILT_IN_LOG10F:
1582 case BUILT_IN_LOG10L:
1583 errno_set = true; builtin_optab = log10_optab; break;
1585 case BUILT_IN_LOG2F:
1586 case BUILT_IN_LOG2L:
1587 errno_set = true; builtin_optab = log2_optab; break;
1591 builtin_optab = tan_optab; break;
1593 case BUILT_IN_ATANF:
1594 case BUILT_IN_ATANL:
1595 builtin_optab = atan_optab; break;
1596 case BUILT_IN_FLOOR:
1597 case BUILT_IN_FLOORF:
1598 case BUILT_IN_FLOORL:
1599 builtin_optab = floor_optab; break;
1601 case BUILT_IN_CEILF:
1602 case BUILT_IN_CEILL:
1603 builtin_optab = ceil_optab; break;
1604 case BUILT_IN_TRUNC:
1605 case BUILT_IN_TRUNCF:
1606 case BUILT_IN_TRUNCL:
1607 builtin_optab = btrunc_optab; break;
1608 case BUILT_IN_ROUND:
1609 case BUILT_IN_ROUNDF:
1610 case BUILT_IN_ROUNDL:
1611 builtin_optab = round_optab; break;
1612 case BUILT_IN_NEARBYINT:
1613 case BUILT_IN_NEARBYINTF:
1614 case BUILT_IN_NEARBYINTL:
1615 builtin_optab = nearbyint_optab; break;
1620 /* Make a suitable register to place result in. */
1621 mode = TYPE_MODE (TREE_TYPE (exp));
1623 if (! flag_errno_math || ! HONOR_NANS (mode))
1626 /* Before working hard, check whether the instruction is available. */
1627 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1629 target = gen_reg_rtx (mode);
1631 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1632 need to expand the argument again. This way, we will not perform
1633 side-effects more the once. */
1634 narg = save_expr (arg);
1637 arglist = build_tree_list (NULL_TREE, arg);
1638 exp = build_function_call_expr (fndecl, arglist);
1641 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1646 /* Compute into TARGET.
1647 Set TARGET to wherever the result comes back. */
1648 target = expand_unop (mode, builtin_optab, op0, target, 0);
1653 expand_errno_check (exp, target);
1655 /* Output the entire sequence. */
1656 insns = get_insns ();
1662 /* If we were unable to expand via the builtin, stop the sequence
1663 (without outputting the insns) and call to the library function
1664 with the stabilized argument list. */
1668 before_call = get_last_insn ();
1670 target = expand_call (exp, target, target == const0_rtx);
1672 /* If this is a sqrt operation and we don't care about errno, try to
1673 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1674 This allows the semantics of the libcall to be visible to the RTL
1676 if (builtin_optab == sqrt_optab && !errno_set)
1678 /* Search backwards through the insns emitted by expand_call looking
1679 for the instruction with the REG_RETVAL note. */
1680 rtx last = get_last_insn ();
1681 while (last != before_call)
1683 if (find_reg_note (last, REG_RETVAL, NULL))
1685 rtx note = find_reg_note (last, REG_EQUAL, NULL);
1686 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1687 two elements, i.e. symbol_ref(sqrt) and the operand. */
1689 && GET_CODE (note) == EXPR_LIST
1690 && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1691 && XEXP (XEXP (note, 0), 1) != NULL_RTX
1692 && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1694 rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1695 /* Check operand is a register with expected mode. */
1697 && GET_CODE (operand) == REG
1698 && GET_MODE (operand) == mode)
1700 /* Replace the REG_EQUAL note with a SQRT rtx. */
1701 rtx equiv = gen_rtx_SQRT (mode, operand);
1702 set_unique_reg_note (last, REG_EQUAL, equiv);
1707 last = PREV_INSN (last);
1714 /* Expand a call to the builtin binary math functions (pow and atan2).
1715 Return 0 if a normal call should be emitted rather than expanding the
1716 function in-line. EXP is the expression that is a call to the builtin
1717 function; if convenient, the result should be placed in TARGET.
1718 SUBTARGET may be used as the target for computing one of EXP's
1722 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1724 optab builtin_optab;
1725 rtx op0, op1, insns;
1726 tree fndecl = get_callee_fndecl (exp);
1727 tree arglist = TREE_OPERAND (exp, 1);
1728 tree arg0, arg1, temp, narg;
1729 enum machine_mode mode;
1730 bool errno_set = true;
1733 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
1736 arg0 = TREE_VALUE (arglist);
1737 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
1739 switch (DECL_FUNCTION_CODE (fndecl))
1744 builtin_optab = pow_optab; break;
1745 case BUILT_IN_ATAN2:
1746 case BUILT_IN_ATAN2F:
1747 case BUILT_IN_ATAN2L:
1748 builtin_optab = atan2_optab; break;
1753 /* Make a suitable register to place result in. */
1754 mode = TYPE_MODE (TREE_TYPE (exp));
1756 /* Before working hard, check whether the instruction is available. */
1757 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
1760 target = gen_reg_rtx (mode);
1762 if (! flag_errno_math || ! HONOR_NANS (mode))
1765 /* Alway stabilize the argument list. */
1766 narg = save_expr (arg1);
1769 temp = build_tree_list (NULL_TREE, narg);
1773 temp = TREE_CHAIN (arglist);
1775 narg = save_expr (arg0);
1778 arglist = tree_cons (NULL_TREE, narg, temp);
1782 arglist = tree_cons (NULL_TREE, arg0, temp);
1785 exp = build_function_call_expr (fndecl, arglist);
1787 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
1788 op1 = expand_expr (arg1, 0, VOIDmode, 0);
1793 /* Compute into TARGET.
1794 Set TARGET to wherever the result comes back. */
1795 target = expand_binop (mode, builtin_optab, op0, op1,
1796 target, 0, OPTAB_DIRECT);
1798 /* If we were unable to expand via the builtin, stop the sequence
1799 (without outputting the insns) and call to the library function
1800 with the stabilized argument list. */
1804 return expand_call (exp, target, target == const0_rtx);
1808 expand_errno_check (exp, target);
1810 /* Output the entire sequence. */
1811 insns = get_insns ();
1818 /* To evaluate powi(x,n), the floating point value x raised to the
1819 constant integer exponent n, we use a hybrid algorithm that
1820 combines the "window method" with look-up tables. For an
1821 introduction to exponentiation algorithms and "addition chains",
1822 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
1823 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
1824 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
1825 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
1827 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
1828 multiplications to inline before calling the system library's pow
1829 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
1830 so this default never requires calling pow, powf or powl. */
1832 #ifndef POWI_MAX_MULTS
1833 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
1836 /* The size of the "optimal power tree" lookup table. All
1837 exponents less than this value are simply looked up in the
1838 powi_table below. This threshold is also used to size the
1839 cache of pseudo registers that hold intermediate results. */
1840 #define POWI_TABLE_SIZE 256
1842 /* The size, in bits of the window, used in the "window method"
1843 exponentiation algorithm. This is equivalent to a radix of
1844 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
1845 #define POWI_WINDOW_SIZE 3
1847 /* The following table is an efficient representation of an
1848 "optimal power tree". For each value, i, the corresponding
1849 value, j, in the table states than an optimal evaluation
1850 sequence for calculating pow(x,i) can be found by evaluating
1851 pow(x,j)*pow(x,i-j). An optimal power tree for the first
1852 100 integers is given in Knuth's "Seminumerical algorithms". */
1854 static const unsigned char powi_table[POWI_TABLE_SIZE] =
1856 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
1857 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
1858 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
1859 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
1860 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
1861 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
1862 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
1863 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
1864 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
1865 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
1866 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
1867 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
1868 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
1869 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
1870 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
1871 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
1872 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
1873 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
1874 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
1875 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
1876 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
1877 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
1878 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
1879 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
1880 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
1881 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
1882 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
1883 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
1884 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
1885 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
1886 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
1887 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
1891 /* Return the number of multiplications required to calculate
1892 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
1893 subroutine of powi_cost. CACHE is an array indicating
1894 which exponents have already been calculated. */
1897 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
1899 /* If we've already calculated this exponent, then this evaluation
1900 doesn't require any additional multiplications. */
1905 return powi_lookup_cost (n - powi_table[n], cache)
1906 + powi_lookup_cost (powi_table[n], cache) + 1;
1909 /* Return the number of multiplications required to calculate
1910 powi(x,n) for an arbitrary x, given the exponent N. This
1911 function needs to be kept in sync with expand_powi below. */
1914 powi_cost (HOST_WIDE_INT n)
1916 bool cache[POWI_TABLE_SIZE];
1917 unsigned HOST_WIDE_INT digit;
1918 unsigned HOST_WIDE_INT val;
1924 /* Ignore the reciprocal when calculating the cost. */
1925 val = (n < 0) ? -n : n;
1927 /* Initialize the exponent cache. */
1928 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
1933 while (val >= POWI_TABLE_SIZE)
1937 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
1938 result += powi_lookup_cost (digit, cache)
1939 + POWI_WINDOW_SIZE + 1;
1940 val >>= POWI_WINDOW_SIZE;
1949 return result + powi_lookup_cost (val, cache);
1952 /* Recursive subroutine of expand_powi. This function takes the array,
1953 CACHE, of already calculated exponents and an exponent N and returns
1954 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
1957 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
1959 unsigned HOST_WIDE_INT digit;
1963 if (n < POWI_TABLE_SIZE)
1968 target = gen_reg_rtx (mode);
1971 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
1972 op1 = expand_powi_1 (mode, powi_table[n], cache);
1976 target = gen_reg_rtx (mode);
1977 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
1978 op0 = expand_powi_1 (mode, n - digit, cache);
1979 op1 = expand_powi_1 (mode, digit, cache);
1983 target = gen_reg_rtx (mode);
1984 op0 = expand_powi_1 (mode, n >> 1, cache);
1988 result = expand_mult (mode, op0, op1, target, 0);
1989 if (result != target)
1990 emit_move_insn (target, result);
1994 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
1995 floating point operand in mode MODE, and N is the exponent. This
1996 function needs to be kept in sync with powi_cost above. */
1999 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2001 unsigned HOST_WIDE_INT val;
2002 rtx cache[POWI_TABLE_SIZE];
2006 return CONST1_RTX (mode);
2008 val = (n < 0) ? -n : n;
2010 memset (cache, 0, sizeof (cache));
2013 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2015 /* If the original exponent was negative, reciprocate the result. */
2017 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2018 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2023 /* Expand a call to the pow built-in mathematical function. Return 0 if
2024 a normal call should be emitted rather than expanding the function
2025 in-line. EXP is the expression that is a call to the builtin
2026 function; if convenient, the result should be placed in TARGET. */
2029 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2031 tree arglist = TREE_OPERAND (exp, 1);
2034 if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2037 arg0 = TREE_VALUE (arglist);
2038 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2040 if (TREE_CODE (arg1) == REAL_CST
2041 && ! TREE_CONSTANT_OVERFLOW (arg1))
2043 REAL_VALUE_TYPE cint;
2047 c = TREE_REAL_CST (arg1);
2048 n = real_to_integer (&c);
2049 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2050 if (real_identical (&c, &cint))
2052 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2053 Otherwise, check the number of multiplications required.
2054 Note that pow never sets errno for an integer exponent. */
2055 if ((n >= -1 && n <= 2)
2056 || (flag_unsafe_math_optimizations
2058 && powi_cost (n) <= POWI_MAX_MULTS))
2060 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2061 rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
2062 op = force_reg (mode, op);
2063 return expand_powi (op, mode, n);
2068 if (! flag_unsafe_math_optimizations)
2070 return expand_builtin_mathfn_2 (exp, target, subtarget);
2073 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2074 if we failed the caller should emit a normal call, otherwise
2075 try to get the result in TARGET, if convenient. */
2078 expand_builtin_strlen (tree arglist, rtx target,
2079 enum machine_mode target_mode)
2081 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
2086 tree len, src = TREE_VALUE (arglist);
2087 rtx result, src_reg, char_rtx, before_strlen;
2088 enum machine_mode insn_mode = target_mode, char_mode;
2089 enum insn_code icode = CODE_FOR_nothing;
2092 /* If the length can be computed at compile-time, return it. */
2093 len = c_strlen (src, 0);
2095 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2097 /* If the length can be computed at compile-time and is constant
2098 integer, but there are side-effects in src, evaluate
2099 src for side-effects, then return len.
2100 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2101 can be optimized into: i++; x = 3; */
2102 len = c_strlen (src, 1);
2103 if (len && TREE_CODE (len) == INTEGER_CST)
2105 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2106 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2109 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2111 /* If SRC is not a pointer type, don't do this operation inline. */
2115 /* Bail out if we can't compute strlen in the right mode. */
2116 while (insn_mode != VOIDmode)
2118 icode = strlen_optab->handlers[(int) insn_mode].insn_code;
2119 if (icode != CODE_FOR_nothing)
2122 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2124 if (insn_mode == VOIDmode)
2127 /* Make a place to write the result of the instruction. */
2130 && GET_CODE (result) == REG
2131 && GET_MODE (result) == insn_mode
2132 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2133 result = gen_reg_rtx (insn_mode);
2135 /* Make a place to hold the source address. We will not expand
2136 the actual source until we are sure that the expansion will
2137 not fail -- there are trees that cannot be expanded twice. */
2138 src_reg = gen_reg_rtx (Pmode);
2140 /* Mark the beginning of the strlen sequence so we can emit the
2141 source operand later. */
2142 before_strlen = get_last_insn ();
2144 char_rtx = const0_rtx;
2145 char_mode = insn_data[(int) icode].operand[2].mode;
2146 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
2148 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
2150 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
2151 char_rtx, GEN_INT (align));
2156 /* Now that we are assured of success, expand the source. */
2158 pat = memory_address (BLKmode,
2159 expand_expr (src, src_reg, ptr_mode, EXPAND_SUM));
2161 emit_move_insn (src_reg, pat);
2166 emit_insn_after (pat, before_strlen);
2168 emit_insn_before (pat, get_insns ());
2170 /* Return the value in the proper mode for this function. */
2171 if (GET_MODE (result) == target_mode)
2173 else if (target != 0)
2174 convert_move (target, result, 0);
2176 target = convert_to_mode (target_mode, result, 0);
2182 /* Expand a call to the strstr builtin. Return 0 if we failed the
2183 caller should emit a normal call, otherwise try to get the result
2184 in TARGET, if convenient (and in mode MODE if that's convenient). */
2187 expand_builtin_strstr (tree arglist, rtx target, enum machine_mode mode)
2189 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2193 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2195 const char *p1, *p2;
2204 const char *r = strstr (p1, p2);
2209 /* Return an offset into the constant string argument. */
2210 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2211 s1, convert (TREE_TYPE (s1),
2212 ssize_int (r - p1)))),
2213 target, mode, EXPAND_NORMAL);
2217 return expand_expr (s1, target, mode, EXPAND_NORMAL);
2222 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2226 /* New argument list transforming strstr(s1, s2) to
2227 strchr(s1, s2[0]). */
2229 build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
2230 arglist = tree_cons (NULL_TREE, s1, arglist);
2231 return expand_expr (build_function_call_expr (fn, arglist),
2232 target, mode, EXPAND_NORMAL);
2236 /* Expand a call to the strchr builtin. Return 0 if we failed the
2237 caller should emit a normal call, otherwise try to get the result
2238 in TARGET, if convenient (and in mode MODE if that's convenient). */
2241 expand_builtin_strchr (tree arglist, rtx target, enum machine_mode mode)
2243 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2247 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2250 if (TREE_CODE (s2) != INTEGER_CST)
2259 if (target_char_cast (s2, &c))
2267 /* Return an offset into the constant string argument. */
2268 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2269 s1, convert (TREE_TYPE (s1),
2270 ssize_int (r - p1)))),
2271 target, mode, EXPAND_NORMAL);
2274 /* FIXME: Should use here strchrM optab so that ports can optimize
2280 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2281 caller should emit a normal call, otherwise try to get the result
2282 in TARGET, if convenient (and in mode MODE if that's convenient). */
2285 expand_builtin_strrchr (tree arglist, rtx target, enum machine_mode mode)
2287 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2291 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2295 if (TREE_CODE (s2) != INTEGER_CST)
2304 if (target_char_cast (s2, &c))
2307 r = strrchr (p1, c);
2312 /* Return an offset into the constant string argument. */
2313 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2314 s1, convert (TREE_TYPE (s1),
2315 ssize_int (r - p1)))),
2316 target, mode, EXPAND_NORMAL);
2319 if (! integer_zerop (s2))
2322 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2326 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
2327 return expand_expr (build_function_call_expr (fn, arglist),
2328 target, mode, EXPAND_NORMAL);
2332 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2333 caller should emit a normal call, otherwise try to get the result
2334 in TARGET, if convenient (and in mode MODE if that's convenient). */
2337 expand_builtin_strpbrk (tree arglist, rtx target, enum machine_mode mode)
2339 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2343 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2345 const char *p1, *p2;
2354 const char *r = strpbrk (p1, p2);
2359 /* Return an offset into the constant string argument. */
2360 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2361 s1, convert (TREE_TYPE (s1),
2362 ssize_int (r - p1)))),
2363 target, mode, EXPAND_NORMAL);
2368 /* strpbrk(x, "") == NULL.
2369 Evaluate and ignore the arguments in case they had
2371 expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
2376 return 0; /* Really call strpbrk. */
2378 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2382 /* New argument list transforming strpbrk(s1, s2) to
2383 strchr(s1, s2[0]). */
2385 build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
2386 arglist = tree_cons (NULL_TREE, s1, arglist);
2387 return expand_expr (build_function_call_expr (fn, arglist),
2388 target, mode, EXPAND_NORMAL);
2392 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2393 bytes from constant string DATA + OFFSET and return it as target
2397 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2398 enum machine_mode mode)
2400 const char *str = (const char *) data;
2403 || ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2404 > strlen (str) + 1))
2405 abort (); /* Attempt to read past the end of constant string. */
2407 return c_readstr (str + offset, mode);
2410 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2411 Return 0 if we failed, the caller should emit a normal call,
2412 otherwise try to get the result in TARGET, if convenient (and in
2413 mode MODE if that's convenient). */
2415 expand_builtin_memcpy (tree arglist, rtx target, enum machine_mode mode)
2417 if (!validate_arglist (arglist,
2418 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2422 tree dest = TREE_VALUE (arglist);
2423 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2424 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2425 const char *src_str;
2426 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2427 unsigned int dest_align
2428 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2429 rtx dest_mem, src_mem, dest_addr, len_rtx;
2431 /* If DEST is not a pointer type, call the normal function. */
2432 if (dest_align == 0)
2435 /* If the LEN parameter is zero, return DEST. */
2436 if (integer_zerop (len))
2438 /* Evaluate and ignore SRC in case it has side-effects. */
2439 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2440 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2443 /* If SRC and DEST are the same (and not volatile), return DEST. */
2444 if (operand_equal_p (src, dest, 0))
2446 /* Evaluate and ignore LEN in case it has side-effects. */
2447 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2448 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2451 /* If either SRC is not a pointer type, don't do this
2452 operation in-line. */
2456 dest_mem = get_memory_rtx (dest);
2457 set_mem_align (dest_mem, dest_align);
2458 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2459 src_str = c_getstr (src);
2461 /* If SRC is a string constant and block move would be done
2462 by pieces, we can avoid loading the string from memory
2463 and only stored the computed constants. */
2465 && GET_CODE (len_rtx) == CONST_INT
2466 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2467 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2468 (void *) src_str, dest_align))
2470 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2471 builtin_memcpy_read_str,
2472 (void *) src_str, dest_align, 0);
2473 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2474 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2478 src_mem = get_memory_rtx (src);
2479 set_mem_align (src_mem, src_align);
2481 /* Copy word part most expediently. */
2482 dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
2487 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2488 dest_addr = convert_memory_address (ptr_mode, dest_addr);
2494 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2495 Return 0 if we failed the caller should emit a normal call,
2496 otherwise try to get the result in TARGET, if convenient (and in
2497 mode MODE if that's convenient). If ENDP is 0 return the
2498 destination pointer, if ENDP is 1 return the end pointer ala
2499 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2503 expand_builtin_mempcpy (tree arglist, rtx target, enum machine_mode mode,
2506 if (!validate_arglist (arglist,
2507 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2509 /* If return value is ignored, transform mempcpy into memcpy. */
2510 else if (target == const0_rtx)
2512 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2517 return expand_expr (build_function_call_expr (fn, arglist),
2518 target, mode, EXPAND_NORMAL);
2522 tree dest = TREE_VALUE (arglist);
2523 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2524 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2525 const char *src_str;
2526 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2527 unsigned int dest_align
2528 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2529 rtx dest_mem, src_mem, len_rtx;
2531 /* If DEST is not a pointer type, call the normal function. */
2532 if (dest_align == 0)
2535 /* If SRC and DEST are the same (and not volatile), do nothing. */
2536 if (operand_equal_p (src, dest, 0))
2542 /* Evaluate and ignore LEN in case it has side-effects. */
2543 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2544 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2548 len = fold (build (MINUS_EXPR, TREE_TYPE (len), dest,
2550 len = convert (TREE_TYPE (dest), len);
2551 expr = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
2552 return expand_expr (expr, target, mode, EXPAND_NORMAL);
2555 /* If LEN is not constant, call the normal function. */
2556 if (! host_integerp (len, 1))
2559 /* If the LEN parameter is zero, return DEST. */
2560 if (tree_low_cst (len, 1) == 0)
2562 /* Evaluate and ignore SRC in case it has side-effects. */
2563 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2564 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2567 /* If either SRC is not a pointer type, don't do this
2568 operation in-line. */
2572 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2573 src_str = c_getstr (src);
2575 /* If SRC is a string constant and block move would be done
2576 by pieces, we can avoid loading the string from memory
2577 and only stored the computed constants. */
2579 && GET_CODE (len_rtx) == CONST_INT
2580 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2581 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2582 (void *) src_str, dest_align))
2584 dest_mem = get_memory_rtx (dest);
2585 set_mem_align (dest_mem, dest_align);
2586 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2587 builtin_memcpy_read_str,
2588 (void *) src_str, dest_align, endp);
2589 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2590 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2594 if (GET_CODE (len_rtx) == CONST_INT
2595 && can_move_by_pieces (INTVAL (len_rtx),
2596 MIN (dest_align, src_align)))
2598 dest_mem = get_memory_rtx (dest);
2599 set_mem_align (dest_mem, dest_align);
2600 src_mem = get_memory_rtx (src);
2601 set_mem_align (src_mem, src_align);
2602 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
2603 MIN (dest_align, src_align), endp);
2604 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2605 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2613 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2614 if we failed the caller should emit a normal call. */
2617 expand_builtin_memmove (tree arglist, rtx target, enum machine_mode mode)
2619 if (!validate_arglist (arglist,
2620 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2624 tree dest = TREE_VALUE (arglist);
2625 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2626 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2628 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2629 unsigned int dest_align
2630 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2632 /* If DEST is not a pointer type, call the normal function. */
2633 if (dest_align == 0)
2636 /* If the LEN parameter is zero, return DEST. */
2637 if (integer_zerop (len))
2639 /* Evaluate and ignore SRC in case it has side-effects. */
2640 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2641 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2644 /* If SRC and DEST are the same (and not volatile), return DEST. */
2645 if (operand_equal_p (src, dest, 0))
2647 /* Evaluate and ignore LEN in case it has side-effects. */
2648 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2649 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2652 /* If either SRC is not a pointer type, don't do this
2653 operation in-line. */
2657 /* If src is categorized for a readonly section we can use
2659 if (readonly_data_expr (src))
2661 tree const fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2664 return expand_expr (build_function_call_expr (fn, arglist),
2665 target, mode, EXPAND_NORMAL);
2668 /* Otherwise, call the normal function. */
2673 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
2674 if we failed the caller should emit a normal call. */
2677 expand_builtin_bcopy (tree arglist)
2679 tree src, dest, size, newarglist;
2681 if (!validate_arglist (arglist,
2682 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2685 src = TREE_VALUE (arglist);
2686 dest = TREE_VALUE (TREE_CHAIN (arglist));
2687 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2689 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
2690 memmove(ptr y, ptr x, size_t z). This is done this way
2691 so that if it isn't expanded inline, we fallback to
2692 calling bcopy instead of memmove. */
2694 newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
2695 newarglist = tree_cons (NULL_TREE, src, newarglist);
2696 newarglist = tree_cons (NULL_TREE, dest, newarglist);
2698 return expand_builtin_memmove (newarglist, const0_rtx, VOIDmode);
2701 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
2702 if we failed the caller should emit a normal call, otherwise try to get
2703 the result in TARGET, if convenient (and in mode MODE if that's
2707 expand_builtin_strcpy (tree arglist, rtx target, enum machine_mode mode)
2709 tree fn, len, src, dst;
2711 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2714 src = TREE_VALUE (TREE_CHAIN (arglist));
2715 dst = TREE_VALUE (arglist);
2717 /* If SRC and DST are equal (and not volatile), return DST. */
2718 if (operand_equal_p (src, dst, 0))
2719 return expand_expr (dst, target, mode, EXPAND_NORMAL);
2721 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2725 len = c_strlen (src, 1);
2726 if (len == 0 || TREE_SIDE_EFFECTS (len))
2729 len = size_binop (PLUS_EXPR, len, ssize_int (1));
2730 arglist = build_tree_list (NULL_TREE, len);
2731 arglist = tree_cons (NULL_TREE, src, arglist);
2732 arglist = tree_cons (NULL_TREE, dst, arglist);
2733 return expand_expr (build_function_call_expr (fn, arglist),
2734 target, mode, EXPAND_NORMAL);
2737 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
2738 Return 0 if we failed the caller should emit a normal call,
2739 otherwise try to get the result in TARGET, if convenient (and in
2740 mode MODE if that's convenient). */
2743 expand_builtin_stpcpy (tree arglist, rtx target, enum machine_mode mode)
2745 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2751 /* If return value is ignored, transform stpcpy into strcpy. */
2752 if (target == const0_rtx)
2754 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
2758 return expand_expr (build_function_call_expr (fn, arglist),
2759 target, mode, EXPAND_NORMAL);
2762 /* Ensure we get an actual string whose length can be evaluated at
2763 compile-time, not an expression containing a string. This is
2764 because the latter will potentially produce pessimized code
2765 when used to produce the return value. */
2766 src = TREE_VALUE (TREE_CHAIN (arglist));
2767 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
2770 dst = TREE_VALUE (arglist);
2771 len = fold (size_binop (PLUS_EXPR, len, ssize_int (1)));
2772 arglist = build_tree_list (NULL_TREE, len);
2773 arglist = tree_cons (NULL_TREE, src, arglist);
2774 arglist = tree_cons (NULL_TREE, dst, arglist);
2775 return expand_builtin_mempcpy (arglist, target, mode, /*endp=*/2);
2779 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2780 bytes from constant string DATA + OFFSET and return it as target
2784 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
2785 enum machine_mode mode)
2787 const char *str = (const char *) data;
2789 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
2792 return c_readstr (str + offset, mode);
2795 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
2796 if we failed the caller should emit a normal call. */
2799 expand_builtin_strncpy (tree arglist, rtx target, enum machine_mode mode)
2801 if (!validate_arglist (arglist,
2802 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2806 tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
2807 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2810 /* We must be passed a constant len parameter. */
2811 if (TREE_CODE (len) != INTEGER_CST)
2814 /* If the len parameter is zero, return the dst parameter. */
2815 if (integer_zerop (len))
2817 /* Evaluate and ignore the src argument in case it has
2819 expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
2820 VOIDmode, EXPAND_NORMAL);
2821 /* Return the dst parameter. */
2822 return expand_expr (TREE_VALUE (arglist), target, mode,
2826 /* Now, we must be passed a constant src ptr parameter. */
2827 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
2830 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
2832 /* We're required to pad with trailing zeros if the requested
2833 len is greater than strlen(s2)+1. In that case try to
2834 use store_by_pieces, if it fails, punt. */
2835 if (tree_int_cst_lt (slen, len))
2837 tree dest = TREE_VALUE (arglist);
2838 unsigned int dest_align
2839 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2840 const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
2843 if (!p || dest_align == 0 || !host_integerp (len, 1)
2844 || !can_store_by_pieces (tree_low_cst (len, 1),
2845 builtin_strncpy_read_str,
2846 (void *) p, dest_align))
2849 dest_mem = get_memory_rtx (dest);
2850 store_by_pieces (dest_mem, tree_low_cst (len, 1),
2851 builtin_strncpy_read_str,
2852 (void *) p, dest_align, 0);
2853 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2854 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2858 /* OK transform into builtin memcpy. */
2859 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2862 return expand_expr (build_function_call_expr (fn, arglist),
2863 target, mode, EXPAND_NORMAL);
2867 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2868 bytes from constant string DATA + OFFSET and return it as target
2872 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2873 enum machine_mode mode)
2875 const char *c = (const char *) data;
2876 char *p = alloca (GET_MODE_SIZE (mode));
2878 memset (p, *c, GET_MODE_SIZE (mode));
2880 return c_readstr (p, mode);
2883 /* Callback routine for store_by_pieces. Return the RTL of a register
2884 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
2885 char value given in the RTL register data. For example, if mode is
2886 4 bytes wide, return the RTL for 0x01010101*data. */
2889 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2890 enum machine_mode mode)
2896 size = GET_MODE_SIZE (mode);
2901 memset (p, 1, size);
2902 coeff = c_readstr (p, mode);
2904 target = convert_to_mode (mode, (rtx) data, 1);
2905 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
2906 return force_reg (mode, target);
2909 /* Expand expression EXP, which is a call to the memset builtin. Return 0
2910 if we failed the caller should emit a normal call, otherwise try to get
2911 the result in TARGET, if convenient (and in mode MODE if that's
2915 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode)
2917 if (!validate_arglist (arglist,
2918 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
2922 tree dest = TREE_VALUE (arglist);
2923 tree val = TREE_VALUE (TREE_CHAIN (arglist));
2924 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2927 unsigned int dest_align
2928 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2929 rtx dest_mem, dest_addr, len_rtx;
2931 /* If DEST is not a pointer type, don't do this
2932 operation in-line. */
2933 if (dest_align == 0)
2936 /* If the LEN parameter is zero, return DEST. */
2937 if (integer_zerop (len))
2939 /* Evaluate and ignore VAL in case it has side-effects. */
2940 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
2941 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2944 if (TREE_CODE (val) != INTEGER_CST)
2948 if (!host_integerp (len, 1))
2951 if (optimize_size && tree_low_cst (len, 1) > 1)
2954 /* Assume that we can memset by pieces if we can store the
2955 * the coefficients by pieces (in the required modes).
2956 * We can't pass builtin_memset_gen_str as that emits RTL. */
2958 if (!can_store_by_pieces (tree_low_cst (len, 1),
2959 builtin_memset_read_str,
2963 val = fold (build1 (CONVERT_EXPR, unsigned_char_type_node, val));
2964 val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
2965 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
2967 dest_mem = get_memory_rtx (dest);
2968 store_by_pieces (dest_mem, tree_low_cst (len, 1),
2969 builtin_memset_gen_str,
2970 val_rtx, dest_align, 0);
2971 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2972 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2976 if (target_char_cast (val, &c))
2981 if (!host_integerp (len, 1))
2983 if (!can_store_by_pieces (tree_low_cst (len, 1),
2984 builtin_memset_read_str, &c,
2988 dest_mem = get_memory_rtx (dest);
2989 store_by_pieces (dest_mem, tree_low_cst (len, 1),
2990 builtin_memset_read_str,
2992 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2993 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2997 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2999 dest_mem = get_memory_rtx (dest);
3000 set_mem_align (dest_mem, dest_align);
3001 dest_addr = clear_storage (dest_mem, len_rtx);
3005 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3006 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3013 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3014 if we failed the caller should emit a normal call. */
3017 expand_builtin_bzero (tree arglist)
3019 tree dest, size, newarglist;
3021 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3024 dest = TREE_VALUE (arglist);
3025 size = TREE_VALUE (TREE_CHAIN (arglist));
3027 /* New argument list transforming bzero(ptr x, int y) to
3028 memset(ptr x, int 0, size_t y). This is done this way
3029 so that if it isn't expanded inline, we fallback to
3030 calling bzero instead of memset. */
3032 newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
3033 newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
3034 newarglist = tree_cons (NULL_TREE, dest, newarglist);
3036 return expand_builtin_memset (newarglist, const0_rtx, VOIDmode);
3039 /* Expand expression EXP, which is a call to the memcmp built-in function.
3040 ARGLIST is the argument list for this call. Return 0 if we failed and the
3041 caller should emit a normal call, otherwise try to get the result in
3042 TARGET, if convenient (and in mode MODE, if that's convenient). */
3045 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED, tree arglist, rtx target,
3046 enum machine_mode mode)
3048 tree arg1, arg2, len;
3049 const char *p1, *p2;
3051 if (!validate_arglist (arglist,
3052 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3055 arg1 = TREE_VALUE (arglist);
3056 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3057 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3059 /* If the len parameter is zero, return zero. */
3060 if (integer_zerop (len))
3062 /* Evaluate and ignore arg1 and arg2 in case they have
3064 expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3065 expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3069 /* If both arguments are equal (and not volatile), return zero. */
3070 if (operand_equal_p (arg1, arg2, 0))
3072 /* Evaluate and ignore len in case it has side-effects. */
3073 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
3077 p1 = c_getstr (arg1);
3078 p2 = c_getstr (arg2);
3080 /* If all arguments are constant, and the value of len is not greater
3081 than the lengths of arg1 and arg2, evaluate at compile-time. */
3082 if (host_integerp (len, 1) && p1 && p2
3083 && compare_tree_int (len, strlen (p1) + 1) <= 0
3084 && compare_tree_int (len, strlen (p2) + 1) <= 0)
3086 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
3088 return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
3091 /* If len parameter is one, return an expression corresponding to
3092 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3093 if (integer_onep (len))
3095 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3096 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3098 fold (build1 (CONVERT_EXPR, integer_type_node,
3099 build1 (INDIRECT_REF, cst_uchar_node,
3100 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3102 fold (build1 (CONVERT_EXPR, integer_type_node,
3103 build1 (INDIRECT_REF, cst_uchar_node,
3104 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3105 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3106 return expand_expr (result, target, mode, EXPAND_NORMAL);
3109 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
3111 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3116 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3118 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3119 enum machine_mode insn_mode;
3121 #ifdef HAVE_cmpmemsi
3123 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3126 #ifdef HAVE_cmpstrsi
3128 insn_mode = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3133 /* If we don't have POINTER_TYPE, call the function. */
3134 if (arg1_align == 0 || arg2_align == 0)
3137 /* Make a place to write the result of the instruction. */
3140 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3141 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3142 result = gen_reg_rtx (insn_mode);
3144 arg1_rtx = get_memory_rtx (arg1);
3145 arg2_rtx = get_memory_rtx (arg2);
3146 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3147 #ifdef HAVE_cmpmemsi
3149 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3150 GEN_INT (MIN (arg1_align, arg2_align)));
3153 #ifdef HAVE_cmpstrsi
3155 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3156 GEN_INT (MIN (arg1_align, arg2_align)));
3164 emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
3165 TYPE_MODE (integer_type_node), 3,
3166 XEXP (arg1_rtx, 0), Pmode,
3167 XEXP (arg2_rtx, 0), Pmode,
3168 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3169 TYPE_UNSIGNED (sizetype)),
3170 TYPE_MODE (sizetype));
3172 /* Return the value in the proper mode for this function. */
3173 mode = TYPE_MODE (TREE_TYPE (exp));
3174 if (GET_MODE (result) == mode)
3176 else if (target != 0)
3178 convert_move (target, result, 0);
3182 return convert_to_mode (mode, result, 0);
3189 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3190 if we failed the caller should emit a normal call, otherwise try to get
3191 the result in TARGET, if convenient. */
3194 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
3196 tree arglist = TREE_OPERAND (exp, 1);
3198 const char *p1, *p2;
3200 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3203 arg1 = TREE_VALUE (arglist);
3204 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3206 /* If both arguments are equal (and not volatile), return zero. */
3207 if (operand_equal_p (arg1, arg2, 0))
3210 p1 = c_getstr (arg1);
3211 p2 = c_getstr (arg2);
3215 const int i = strcmp (p1, p2);
3216 return (i < 0 ? constm1_rtx : (i > 0 ? const1_rtx : const0_rtx));
3219 /* If either arg is "", return an expression corresponding to
3220 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3221 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
3223 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3224 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3226 fold (build1 (CONVERT_EXPR, integer_type_node,
3227 build1 (INDIRECT_REF, cst_uchar_node,
3228 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3230 fold (build1 (CONVERT_EXPR, integer_type_node,
3231 build1 (INDIRECT_REF, cst_uchar_node,
3232 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3233 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3234 return expand_expr (result, target, mode, EXPAND_NORMAL);
3237 #ifdef HAVE_cmpstrsi
3240 tree len, len1, len2;
3241 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3246 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3248 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3249 enum machine_mode insn_mode
3250 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3252 len1 = c_strlen (arg1, 1);
3253 len2 = c_strlen (arg2, 1);
3256 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3258 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3260 /* If we don't have a constant length for the first, use the length
3261 of the second, if we know it. We don't require a constant for
3262 this case; some cost analysis could be done if both are available
3263 but neither is constant. For now, assume they're equally cheap,
3264 unless one has side effects. If both strings have constant lengths,
3271 else if (TREE_SIDE_EFFECTS (len1))
3273 else if (TREE_SIDE_EFFECTS (len2))
3275 else if (TREE_CODE (len1) != INTEGER_CST)
3277 else if (TREE_CODE (len2) != INTEGER_CST)
3279 else if (tree_int_cst_lt (len1, len2))
3284 /* If both arguments have side effects, we cannot optimize. */
3285 if (!len || TREE_SIDE_EFFECTS (len))
3288 /* If we don't have POINTER_TYPE, call the function. */
3289 if (arg1_align == 0 || arg2_align == 0)
3292 /* Make a place to write the result of the instruction. */
3295 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3296 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3297 result = gen_reg_rtx (insn_mode);
3299 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3300 arg1 = save_expr (arg1);
3301 arg2 = save_expr (arg2);
3303 arg1_rtx = get_memory_rtx (arg1);
3304 arg2_rtx = get_memory_rtx (arg2);
3305 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3306 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3307 GEN_INT (MIN (arg1_align, arg2_align)));
3312 /* Return the value in the proper mode for this function. */
3313 mode = TYPE_MODE (TREE_TYPE (exp));
3314 if (GET_MODE (result) == mode)
3317 return convert_to_mode (mode, result, 0);
3318 convert_move (target, result, 0);
3322 /* Expand the library call ourselves using a stabilized argument
3323 list to avoid re-evaluating the function's arguments twice. */
3324 arglist = build_tree_list (NULL_TREE, arg2);
3325 arglist = tree_cons (NULL_TREE, arg1, arglist);
3326 fndecl = get_callee_fndecl (exp);
3327 exp = build_function_call_expr (fndecl, arglist);
3328 return expand_call (exp, target, target == const0_rtx);
3334 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3335 if we failed the caller should emit a normal call, otherwise try to get
3336 the result in TARGET, if convenient. */
3339 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
3341 tree arglist = TREE_OPERAND (exp, 1);
3342 tree arg1, arg2, arg3;
3343 const char *p1, *p2;
3345 if (!validate_arglist (arglist,
3346 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3349 arg1 = TREE_VALUE (arglist);
3350 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3351 arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3353 /* If the len parameter is zero, return zero. */
3354 if (integer_zerop (arg3))
3356 /* Evaluate and ignore arg1 and arg2 in case they have
3358 expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3359 expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3363 /* If arg1 and arg2 are equal (and not volatile), return zero. */
3364 if (operand_equal_p (arg1, arg2, 0))
3366 /* Evaluate and ignore arg3 in case it has side-effects. */
3367 expand_expr (arg3, const0_rtx, VOIDmode, EXPAND_NORMAL);
3371 p1 = c_getstr (arg1);
3372 p2 = c_getstr (arg2);
3374 /* If all arguments are constant, evaluate at compile-time. */
3375 if (host_integerp (arg3, 1) && p1 && p2)
3377 const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
3378 return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
3381 /* If len == 1 or (either string parameter is "" and (len >= 1)),
3382 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
3383 if (host_integerp (arg3, 1)
3384 && (tree_low_cst (arg3, 1) == 1
3385 || (tree_low_cst (arg3, 1) > 1
3386 && ((p1 && *p1 == '\0') || (p2 && *p2 == '\0')))))
3388 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3389 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3391 fold (build1 (CONVERT_EXPR, integer_type_node,
3392 build1 (INDIRECT_REF, cst_uchar_node,
3393 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3395 fold (build1 (CONVERT_EXPR, integer_type_node,
3396 build1 (INDIRECT_REF, cst_uchar_node,
3397 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3398 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3399 return expand_expr (result, target, mode, EXPAND_NORMAL);
3402 /* If c_strlen can determine an expression for one of the string
3403 lengths, and it doesn't have side effects, then emit cmpstrsi
3404 using length MIN(strlen(string)+1, arg3). */
3405 #ifdef HAVE_cmpstrsi
3408 tree len, len1, len2;
3409 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3414 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3416 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3417 enum machine_mode insn_mode
3418 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3420 len1 = c_strlen (arg1, 1);
3421 len2 = c_strlen (arg2, 1);
3424 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3426 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3428 /* If we don't have a constant length for the first, use the length
3429 of the second, if we know it. We don't require a constant for
3430 this case; some cost analysis could be done if both are available
3431 but neither is constant. For now, assume they're equally cheap,
3432 unless one has side effects. If both strings have constant lengths,
3439 else if (TREE_SIDE_EFFECTS (len1))
3441 else if (TREE_SIDE_EFFECTS (len2))
3443 else if (TREE_CODE (len1) != INTEGER_CST)
3445 else if (TREE_CODE (len2) != INTEGER_CST)
3447 else if (tree_int_cst_lt (len1, len2))
3452 /* If both arguments have side effects, we cannot optimize. */
3453 if (!len || TREE_SIDE_EFFECTS (len))
3456 /* The actual new length parameter is MIN(len,arg3). */
3457 len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
3459 /* If we don't have POINTER_TYPE, call the function. */
3460 if (arg1_align == 0 || arg2_align == 0)
3463 /* Make a place to write the result of the instruction. */
3466 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3467 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3468 result = gen_reg_rtx (insn_mode);
3470 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3471 arg1 = save_expr (arg1);
3472 arg2 = save_expr (arg2);
3473 len = save_expr (len);
3475 arg1_rtx = get_memory_rtx (arg1);
3476 arg2_rtx = get_memory_rtx (arg2);
3477 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3478 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3479 GEN_INT (MIN (arg1_align, arg2_align)));
3484 /* Return the value in the proper mode for this function. */
3485 mode = TYPE_MODE (TREE_TYPE (exp));
3486 if (GET_MODE (result) == mode)
3489 return convert_to_mode (mode, result, 0);
3490 convert_move (target, result, 0);
3494 /* Expand the library call ourselves using a stabilized argument
3495 list to avoid re-evaluating the function's arguments twice. */
3496 arglist = build_tree_list (NULL_TREE, len);
3497 arglist = tree_cons (NULL_TREE, arg2, arglist);
3498 arglist = tree_cons (NULL_TREE, arg1, arglist);
3499 fndecl = get_callee_fndecl (exp);
3500 exp = build_function_call_expr (fndecl, arglist);
3501 return expand_call (exp, target, target == const0_rtx);
3507 /* Expand expression EXP, which is a call to the strcat builtin.
3508 Return 0 if we failed the caller should emit a normal call,
3509 otherwise try to get the result in TARGET, if convenient. */
3512 expand_builtin_strcat (tree arglist, rtx target, enum machine_mode mode)
3514 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3518 tree dst = TREE_VALUE (arglist),
3519 src = TREE_VALUE (TREE_CHAIN (arglist));
3520 const char *p = c_getstr (src);
3524 /* If the string length is zero, return the dst parameter. */
3526 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3527 else if (!optimize_size)
3529 /* Otherwise if !optimize_size, see if we can store by
3530 pieces into (dst + strlen(dst)). */
3531 tree newdst, arglist,
3532 strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3534 /* This is the length argument. */
3535 arglist = build_tree_list (NULL_TREE,
3536 fold (size_binop (PLUS_EXPR,
3539 /* Prepend src argument. */
3540 arglist = tree_cons (NULL_TREE, src, arglist);
3542 /* We're going to use dst more than once. */
3543 dst = save_expr (dst);
3545 /* Create strlen (dst). */
3547 fold (build_function_call_expr (strlen_fn,
3548 build_tree_list (NULL_TREE,
3550 /* Create (dst + strlen (dst)). */
3551 newdst = fold (build (PLUS_EXPR, TREE_TYPE (dst), dst, newdst));
3553 /* Prepend the new dst argument. */
3554 arglist = tree_cons (NULL_TREE, newdst, arglist);
3556 /* We don't want to get turned into a memcpy if the
3557 target is const0_rtx, i.e. when the return value
3558 isn't used. That would produce pessimized code so
3559 pass in a target of zero, it should never actually be
3560 used. If this was successful return the original
3561 dst, not the result of mempcpy. */
3562 if (expand_builtin_mempcpy (arglist, /*target=*/0, mode, /*endp=*/0))
3563 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3573 /* Expand expression EXP, which is a call to the strncat builtin.
3574 Return 0 if we failed the caller should emit a normal call,
3575 otherwise try to get the result in TARGET, if convenient. */
3578 expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
3580 if (!validate_arglist (arglist,
3581 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3585 tree dst = TREE_VALUE (arglist),
3586 src = TREE_VALUE (TREE_CHAIN (arglist)),
3587 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3588 const char *p = c_getstr (src);
3590 /* If the requested length is zero, or the src parameter string
3591 length is zero, return the dst parameter. */
3592 if (integer_zerop (len) || (p && *p == '\0'))
3594 /* Evaluate and ignore the src and len parameters in case
3595 they have side-effects. */
3596 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3597 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
3598 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3601 /* If the requested len is greater than or equal to the string
3602 length, call strcat. */
3603 if (TREE_CODE (len) == INTEGER_CST && p
3604 && compare_tree_int (len, strlen (p)) >= 0)
3607 = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
3608 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
3610 /* If the replacement _DECL isn't initialized, don't do the
3615 return expand_expr (build_function_call_expr (fn, newarglist),
3616 target, mode, EXPAND_NORMAL);
3622 /* Expand expression EXP, which is a call to the strspn builtin.
3623 Return 0 if we failed the caller should emit a normal call,
3624 otherwise try to get the result in TARGET, if convenient. */
3627 expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
3629 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3633 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
3634 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
3636 /* If both arguments are constants, evaluate at compile-time. */
3639 const size_t r = strspn (p1, p2);
3640 return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
3643 /* If either argument is "", return 0. */
3644 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
3646 /* Evaluate and ignore both arguments in case either one has
3648 expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3649 expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3656 /* Expand expression EXP, which is a call to the strcspn builtin.
3657 Return 0 if we failed the caller should emit a normal call,
3658 otherwise try to get the result in TARGET, if convenient. */
3661 expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
3663 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3667 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
3668 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
3670 /* If both arguments are constants, evaluate at compile-time. */
3673 const size_t r = strcspn (p1, p2);
3674 return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
3677 /* If the first argument is "", return 0. */
3678 if (p1 && *p1 == '\0')
3680 /* Evaluate and ignore argument s2 in case it has
3682 expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3686 /* If the second argument is "", return __builtin_strlen(s1). */
3687 if (p2 && *p2 == '\0')
3689 tree newarglist = build_tree_list (NULL_TREE, s1),
3690 fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3692 /* If the replacement _DECL isn't initialized, don't do the
3697 return expand_expr (build_function_call_expr (fn, newarglist),
3698 target, mode, EXPAND_NORMAL);
3704 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
3705 if that's convenient. */
3708 expand_builtin_saveregs (void)
3712 /* Don't do __builtin_saveregs more than once in a function.
3713 Save the result of the first call and reuse it. */
3714 if (saveregs_value != 0)
3715 return saveregs_value;
3717 /* When this function is called, it means that registers must be
3718 saved on entry to this function. So we migrate the call to the
3719 first insn of this function. */
3723 /* Do whatever the machine needs done in this case. */
3724 val = targetm.calls.expand_builtin_saveregs ();
3729 saveregs_value = val;
3731 /* Put the insns after the NOTE that starts the function. If this
3732 is inside a start_sequence, make the outer-level insn chain current, so
3733 the code is placed at the start of the function. */
3734 push_topmost_sequence ();
3735 emit_insn_after (seq, get_insns ());
3736 pop_topmost_sequence ();
3741 /* __builtin_args_info (N) returns word N of the arg space info
3742 for the current function. The number and meanings of words
3743 is controlled by the definition of CUMULATIVE_ARGS. */
3746 expand_builtin_args_info (tree arglist)
3748 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
3749 int *word_ptr = (int *) ¤t_function_args_info;
3751 if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
3756 if (!host_integerp (TREE_VALUE (arglist), 0))
3757 error ("argument of `__builtin_args_info' must be constant");
3760 HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
3762 if (wordnum < 0 || wordnum >= nwords)
3763 error ("argument of `__builtin_args_info' out of range");
3765 return GEN_INT (word_ptr[wordnum]);
3769 error ("missing argument in `__builtin_args_info'");
3774 /* Expand ARGLIST, from a call to __builtin_next_arg. */
3777 expand_builtin_next_arg (tree arglist)
3779 tree fntype = TREE_TYPE (current_function_decl);
3781 if (TYPE_ARG_TYPES (fntype) == 0
3782 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
3785 error ("`va_start' used in function with fixed args");
3791 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
3792 tree arg = TREE_VALUE (arglist);
3794 /* Strip off all nops for the sake of the comparison. This
3795 is not quite the same as STRIP_NOPS. It does more.
3796 We must also strip off INDIRECT_EXPR for C++ reference
3798 while (TREE_CODE (arg) == NOP_EXPR
3799 || TREE_CODE (arg) == CONVERT_EXPR
3800 || TREE_CODE (arg) == NON_LVALUE_EXPR
3801 || TREE_CODE (arg) == INDIRECT_REF)
3802 arg = TREE_OPERAND (arg, 0);
3803 if (arg != last_parm)
3804 warning ("second parameter of `va_start' not last named argument");
3807 /* Evidently an out of date version of <stdarg.h>; can't validate
3808 va_start's second argument, but can still work as intended. */
3809 warning ("`__builtin_next_arg' called without an argument");
3811 return expand_binop (Pmode, add_optab,
3812 current_function_internal_arg_pointer,
3813 current_function_arg_offset_rtx,
3814 NULL_RTX, 0, OPTAB_LIB_WIDEN);
3817 /* Make it easier for the backends by protecting the valist argument
3818 from multiple evaluations. */
3821 stabilize_va_list (tree valist, int needs_lvalue)
3823 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3825 if (TREE_SIDE_EFFECTS (valist))
3826 valist = save_expr (valist);
3828 /* For this case, the backends will be expecting a pointer to
3829 TREE_TYPE (va_list_type_node), but it's possible we've
3830 actually been given an array (an actual va_list_type_node).
3832 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
3834 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
3835 tree p2 = build_pointer_type (va_list_type_node);
3837 valist = build1 (ADDR_EXPR, p2, valist);
3838 valist = fold (build1 (NOP_EXPR, p1, valist));
3847 if (! TREE_SIDE_EFFECTS (valist))
3850 pt = build_pointer_type (va_list_type_node);
3851 valist = fold (build1 (ADDR_EXPR, pt, valist));
3852 TREE_SIDE_EFFECTS (valist) = 1;
3855 if (TREE_SIDE_EFFECTS (valist))
3856 valist = save_expr (valist);
3857 valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
3864 /* The "standard" definition of va_list is void*. */
3867 std_build_builtin_va_list (void)
3869 return ptr_type_node;
3872 /* The "standard" implementation of va_start: just assign `nextarg' to
3876 std_expand_builtin_va_start (tree valist, rtx nextarg)
3880 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3881 make_tree (ptr_type_node, nextarg));
3882 TREE_SIDE_EFFECTS (t) = 1;
3884 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3887 /* Expand ARGLIST, from a call to __builtin_va_start. */
3890 expand_builtin_va_start (tree arglist)
3895 chain = TREE_CHAIN (arglist);
3897 if (TREE_CHAIN (chain))
3898 error ("too many arguments to function `va_start'");
3900 nextarg = expand_builtin_next_arg (chain);
3901 valist = stabilize_va_list (TREE_VALUE (arglist), 1);
3903 #ifdef EXPAND_BUILTIN_VA_START
3904 EXPAND_BUILTIN_VA_START (valist, nextarg);
3906 std_expand_builtin_va_start (valist, nextarg);
3912 /* The "standard" implementation of va_arg: read the value from the
3913 current (padded) address and increment by the (padded) size. */
3916 std_expand_builtin_va_arg (tree valist, tree type)
3918 tree addr_tree, t, type_size = NULL;
3919 tree align, alignm1;
3922 HOST_WIDE_INT boundary;
3924 /* Compute the rounded size of the type. */
3925 align = size_int (PARM_BOUNDARY / BITS_PER_UNIT);
3926 alignm1 = size_int (PARM_BOUNDARY / BITS_PER_UNIT - 1);
3927 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
3929 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
3930 requires greater alignment, we must perform dynamic alignment. */
3932 if (boundary > PARM_BOUNDARY)
3934 if (!PAD_VARARGS_DOWN)
3936 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3937 build (PLUS_EXPR, TREE_TYPE (valist), valist,
3938 build_int_2 (boundary / BITS_PER_UNIT - 1, 0)));
3939 TREE_SIDE_EFFECTS (t) = 1;
3940 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3942 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3943 build (BIT_AND_EXPR, TREE_TYPE (valist), valist,
3944 build_int_2 (~(boundary / BITS_PER_UNIT - 1), -1)));
3945 TREE_SIDE_EFFECTS (t) = 1;
3946 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3948 if (type == error_mark_node
3949 || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
3950 || TREE_OVERFLOW (type_size))
3951 rounded_size = size_zero_node;
3953 rounded_size = fold (build (MULT_EXPR, sizetype,
3954 fold (build (TRUNC_DIV_EXPR, sizetype,
3955 fold (build (PLUS_EXPR, sizetype,
3956 type_size, alignm1)),
3962 if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
3964 /* Small args are padded downward. */
3965 addr_tree = fold (build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
3966 fold (build (COND_EXPR, sizetype,
3967 fold (build (GT_EXPR, sizetype,
3971 fold (build (MINUS_EXPR, sizetype,
3976 addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
3977 addr = copy_to_reg (addr);
3979 /* Compute new value for AP. */
3980 if (! integer_zerop (rounded_size))
3982 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3983 build (PLUS_EXPR, TREE_TYPE (valist), valist,
3985 TREE_SIDE_EFFECTS (t) = 1;
3986 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3992 /* Expand __builtin_va_arg, which is not really a builtin function, but
3993 a very special sort of operator. */
3996 expand_builtin_va_arg (tree valist, tree type)
3999 tree promoted_type, want_va_type, have_va_type;
4001 /* Verify that valist is of the proper type. */
4003 want_va_type = va_list_type_node;
4004 have_va_type = TREE_TYPE (valist);
4005 if (TREE_CODE (want_va_type) == ARRAY_TYPE)
4007 /* If va_list is an array type, the argument may have decayed
4008 to a pointer type, e.g. by being passed to another function.
4009 In that case, unwrap both types so that we can compare the
4010 underlying records. */
4011 if (TREE_CODE (have_va_type) == ARRAY_TYPE
4012 || TREE_CODE (have_va_type) == POINTER_TYPE)
4014 want_va_type = TREE_TYPE (want_va_type);
4015 have_va_type = TREE_TYPE (have_va_type);
4018 if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
4020 error ("first argument to `va_arg' not of type `va_list'");
4024 /* Generate a diagnostic for requesting data of a type that cannot
4025 be passed through `...' due to type promotion at the call site. */
4026 else if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4029 const char *name = "<anonymous type>", *pname = 0;
4030 static bool gave_help;
4032 if (TYPE_NAME (type))
4034 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
4035 name = IDENTIFIER_POINTER (TYPE_NAME (type));
4036 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4037 && DECL_NAME (TYPE_NAME (type)))
4038 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
4040 if (TYPE_NAME (promoted_type))
4042 if (TREE_CODE (TYPE_NAME (promoted_type)) == IDENTIFIER_NODE)
4043 pname = IDENTIFIER_POINTER (TYPE_NAME (promoted_type));
4044 else if (TREE_CODE (TYPE_NAME (promoted_type)) == TYPE_DECL
4045 && DECL_NAME (TYPE_NAME (promoted_type)))
4046 pname = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type)));
4049 /* Unfortunately, this is merely undefined, rather than a constraint
4050 violation, so we cannot make this an error. If this call is never
4051 executed, the program is still strictly conforming. */
4052 warning ("`%s' is promoted to `%s' when passed through `...'",
4057 warning ("(so you should pass `%s' not `%s' to `va_arg')",
4061 /* We can, however, treat "undefined" any way we please.
4062 Call abort to encourage the user to fix the program. */
4063 inform ("if this code is reached, the program will abort");
4064 expand_builtin_trap ();
4066 /* This is dead code, but go ahead and finish so that the
4067 mode of the result comes out right. */
4072 /* Make it easier for the backends by protecting the valist argument
4073 from multiple evaluations. */
4074 valist = stabilize_va_list (valist, 0);
4076 #ifdef EXPAND_BUILTIN_VA_ARG
4077 addr = EXPAND_BUILTIN_VA_ARG (valist, type);
4079 addr = std_expand_builtin_va_arg (valist, type);
4083 addr = convert_memory_address (Pmode, addr);
4085 result = gen_rtx_MEM (TYPE_MODE (type), addr);
4086 set_mem_alias_set (result, get_varargs_alias_set ());
4091 /* Expand ARGLIST, from a call to __builtin_va_end. */
4094 expand_builtin_va_end (tree arglist)
4096 tree valist = TREE_VALUE (arglist);
4098 /* Evaluate for side effects, if needed. I hate macros that don't
4100 if (TREE_SIDE_EFFECTS (valist))
4101 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4106 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4107 builtin rather than just as an assignment in stdarg.h because of the
4108 nastiness of array-type va_list types. */
4111 expand_builtin_va_copy (tree arglist)
4115 dst = TREE_VALUE (arglist);
4116 src = TREE_VALUE (TREE_CHAIN (arglist));
4118 dst = stabilize_va_list (dst, 1);
4119 src = stabilize_va_list (src, 0);
4121 if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
4123 t = build (MODIFY_EXPR, va_list_type_node, dst, src);
4124 TREE_SIDE_EFFECTS (t) = 1;
4125 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4129 rtx dstb, srcb, size;
4131 /* Evaluate to pointers. */
4132 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4133 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4134 size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
4135 VOIDmode, EXPAND_NORMAL);
4137 dstb = convert_memory_address (Pmode, dstb);
4138 srcb = convert_memory_address (Pmode, srcb);
4140 /* "Dereference" to BLKmode memories. */
4141 dstb = gen_rtx_MEM (BLKmode, dstb);
4142 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4143 set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
4144 srcb = gen_rtx_MEM (BLKmode, srcb);
4145 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4146 set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
4149 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4155 /* Expand a call to one of the builtin functions __builtin_frame_address or
4156 __builtin_return_address. */
4159 expand_builtin_frame_address (tree fndecl, tree arglist)
4161 /* The argument must be a nonnegative integer constant.
4162 It counts the number of frames to scan up the stack.
4163 The value is the return address saved in that frame. */
4165 /* Warning about missing arg was already issued. */
4167 else if (! host_integerp (TREE_VALUE (arglist), 1))
4169 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4170 error ("invalid arg to `__builtin_frame_address'");
4172 error ("invalid arg to `__builtin_return_address'");
4178 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4179 tree_low_cst (TREE_VALUE (arglist), 1),
4180 hard_frame_pointer_rtx);
4182 /* Some ports cannot access arbitrary stack frames. */
4185 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4186 warning ("unsupported arg to `__builtin_frame_address'");
4188 warning ("unsupported arg to `__builtin_return_address'");
4192 /* For __builtin_frame_address, return what we've got. */
4193 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4196 if (GET_CODE (tem) != REG
4197 && ! CONSTANT_P (tem))
4198 tem = copy_to_mode_reg (Pmode, tem);
4203 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4204 we failed and the caller should emit a normal call, otherwise try to get
4205 the result in TARGET, if convenient. */
4208 expand_builtin_alloca (tree arglist, rtx target)
4213 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4216 /* Compute the argument. */
4217 op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
4219 /* Allocate the desired space. */
4220 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4221 result = convert_memory_address (ptr_mode, result);
4226 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4227 Return 0 if a normal call should be emitted rather than expanding the
4228 function in-line. If convenient, the result should be placed in TARGET.
4229 SUBTARGET may be used as the target for computing one of EXP's operands. */
4232 expand_builtin_unop (enum machine_mode target_mode, tree arglist, rtx target,
4233 rtx subtarget, optab op_optab)
4236 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4239 /* Compute the argument. */
4240 op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
4241 /* Compute op, into TARGET if possible.
4242 Set TARGET to wherever the result comes back. */
4243 target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
4244 op_optab, op0, target, 1);
4248 return convert_to_mode (target_mode, target, 0);
4251 /* If the string passed to fputs is a constant and is one character
4252 long, we attempt to transform this call into __builtin_fputc(). */
4255 expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
4258 tree fn_fputc = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4259 : implicit_built_in_decls[BUILT_IN_FPUTC];
4260 tree fn_fwrite = unlocked ? implicit_built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
4261 : implicit_built_in_decls[BUILT_IN_FWRITE];
4263 /* If the return value is used, or the replacement _DECL isn't
4264 initialized, don't do the transformation. */
4265 if (target != const0_rtx || !fn_fputc || !fn_fwrite)
4268 /* Verify the arguments in the original call. */
4269 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4272 /* Get the length of the string passed to fputs. If the length
4273 can't be determined, punt. */
4274 if (!(len = c_strlen (TREE_VALUE (arglist), 1))
4275 || TREE_CODE (len) != INTEGER_CST)
4278 switch (compare_tree_int (len, 1))
4280 case -1: /* length is 0, delete the call entirely . */
4282 /* Evaluate and ignore the argument in case it has
4284 expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
4285 VOIDmode, EXPAND_NORMAL);
4288 case 0: /* length is 1, call fputc. */
4290 const char *p = c_getstr (TREE_VALUE (arglist));
4294 /* New argument list transforming fputs(string, stream) to
4295 fputc(string[0], stream). */
4297 build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
4299 tree_cons (NULL_TREE, build_int_2 (p[0], 0), arglist);
4305 case 1: /* length is greater than 1, call fwrite. */
4309 /* If optimizing for size keep fputs. */
4312 string_arg = TREE_VALUE (arglist);
4313 /* New argument list transforming fputs(string, stream) to
4314 fwrite(string, 1, len, stream). */
4315 arglist = build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
4316 arglist = tree_cons (NULL_TREE, len, arglist);
4317 arglist = tree_cons (NULL_TREE, size_one_node, arglist);
4318 arglist = tree_cons (NULL_TREE, string_arg, arglist);
4326 return expand_expr (build_function_call_expr (fn, arglist),
4327 const0_rtx, VOIDmode, EXPAND_NORMAL);
4330 /* Expand a call to __builtin_expect. We return our argument and emit a
4331 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4332 a non-jump context. */
4335 expand_builtin_expect (tree arglist, rtx target)
4340 if (arglist == NULL_TREE
4341 || TREE_CHAIN (arglist) == NULL_TREE)
4343 exp = TREE_VALUE (arglist);
4344 c = TREE_VALUE (TREE_CHAIN (arglist));
4346 if (TREE_CODE (c) != INTEGER_CST)
4348 error ("second arg to `__builtin_expect' must be a constant");
4349 c = integer_zero_node;
4352 target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
4354 /* Don't bother with expected value notes for integral constants. */
4355 if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
4357 /* We do need to force this into a register so that we can be
4358 moderately sure to be able to correctly interpret the branch
4360 target = force_reg (GET_MODE (target), target);
4362 rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
4364 note = emit_note (NOTE_INSN_EXPECTED_VALUE);
4365 NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
4371 /* Like expand_builtin_expect, except do this in a jump context. This is
4372 called from do_jump if the conditional is a __builtin_expect. Return either
4373 a list of insns to emit the jump or NULL if we cannot optimize
4374 __builtin_expect. We need to optimize this at jump time so that machines
4375 like the PowerPC don't turn the test into a SCC operation, and then jump
4376 based on the test being 0/1. */
4379 expand_builtin_expect_jump (tree exp, rtx if_false_label, rtx if_true_label)
4381 tree arglist = TREE_OPERAND (exp, 1);
4382 tree arg0 = TREE_VALUE (arglist);
4383 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
4386 /* Only handle __builtin_expect (test, 0) and
4387 __builtin_expect (test, 1). */
4388 if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
4389 && (integer_zerop (arg1) || integer_onep (arg1)))
4391 rtx insn, drop_through_label, temp;
4393 /* Expand the jump insns. */
4395 do_jump (arg0, if_false_label, if_true_label);
4398 drop_through_label = get_last_insn ();
4399 if (drop_through_label && GET_CODE (drop_through_label) == NOTE)
4400 drop_through_label = prev_nonnote_insn (drop_through_label);
4401 if (drop_through_label && GET_CODE (drop_through_label) != CODE_LABEL)
4402 drop_through_label = NULL_RTX;
4405 if (! if_true_label)
4406 if_true_label = drop_through_label;
4407 if (! if_false_label)
4408 if_false_label = drop_through_label;
4410 /* Go through and add the expect's to each of the conditional jumps. */
4412 while (insn != NULL_RTX)
4414 rtx next = NEXT_INSN (insn);
4416 if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn))
4418 rtx ifelse = SET_SRC (pc_set (insn));
4419 rtx then_dest = XEXP (ifelse, 1);
4420 rtx else_dest = XEXP (ifelse, 2);
4423 /* First check if we recognize any of the labels. */
4424 if (GET_CODE (then_dest) == LABEL_REF
4425 && XEXP (then_dest, 0) == if_true_label)
4427 else if (GET_CODE (then_dest) == LABEL_REF
4428 && XEXP (then_dest, 0) == if_false_label)
4430 else if (GET_CODE (else_dest) == LABEL_REF
4431 && XEXP (else_dest, 0) == if_false_label)
4433 else if (GET_CODE (else_dest) == LABEL_REF
4434 && XEXP (else_dest, 0) == if_true_label)
4436 /* Otherwise check where we drop through. */
4437 else if (else_dest == pc_rtx)
4439 if (next && GET_CODE (next) == NOTE)
4440 next = next_nonnote_insn (next);
4442 if (next && GET_CODE (next) == JUMP_INSN
4443 && any_uncondjump_p (next))
4444 temp = XEXP (SET_SRC (pc_set (next)), 0);
4448 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4449 else that can't possibly match either target label. */
4450 if (temp == if_false_label)
4452 else if (temp == if_true_label)
4455 else if (then_dest == pc_rtx)
4457 if (next && GET_CODE (next) == NOTE)
4458 next = next_nonnote_insn (next);
4460 if (next && GET_CODE (next) == JUMP_INSN
4461 && any_uncondjump_p (next))
4462 temp = XEXP (SET_SRC (pc_set (next)), 0);
4466 if (temp == if_false_label)
4468 else if (temp == if_true_label)
4474 /* If the test is expected to fail, reverse the
4476 if (integer_zerop (arg1))
4478 predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
4490 expand_builtin_trap (void)
4494 emit_insn (gen_trap ());
4497 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4501 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4502 Return 0 if a normal call should be emitted rather than expanding
4503 the function inline. If convenient, the result should be placed
4504 in TARGET. SUBTARGET may be used as the target for computing
4508 expand_builtin_fabs (tree arglist, rtx target, rtx subtarget)
4510 enum machine_mode mode;
4514 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4517 arg = TREE_VALUE (arglist);
4518 mode = TYPE_MODE (TREE_TYPE (arg));
4519 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
4520 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4523 /* Expand a call to cabs, cabsf or cabsl with arguments ARGLIST.
4524 Return 0 if a normal call should be emitted rather than expanding
4525 the function inline. If convenient, the result should be placed
4529 expand_builtin_cabs (tree arglist, rtx target)
4531 enum machine_mode mode;
4535 if (arglist == 0 || TREE_CHAIN (arglist))
4537 arg = TREE_VALUE (arglist);
4538 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
4539 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
4542 mode = TYPE_MODE (TREE_TYPE (arg));
4543 op0 = expand_expr (arg, NULL_RTX, VOIDmode, 0);
4544 return expand_complex_abs (mode, op0, target, 0);
4547 /* Create a new constant string literal and return a char* pointer to it.
4548 The STRING_CST value is the LEN characters at STR. */
4550 build_string_literal (int len, const char *str)
4552 tree t, elem, index, type;
4554 t = build_string (len, str);
4555 elem = build_type_variant (char_type_node, 1, 0);
4556 index = build_index_type (build_int_2 (len - 1, 0));
4557 type = build_array_type (elem, index);
4558 TREE_TYPE (t) = type;
4559 TREE_CONSTANT (t) = 1;
4560 TREE_READONLY (t) = 1;
4561 TREE_STATIC (t) = 1;
4563 type = build_pointer_type (type);
4564 t = build1 (ADDR_EXPR, type, t);
4566 type = build_pointer_type (elem);
4567 t = build1 (NOP_EXPR, type, t);
4571 /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
4572 Return 0 if a normal call should be emitted rather than transforming
4573 the function inline. If convenient, the result should be placed in
4574 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4577 expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode,
4580 tree fn_putchar = unlocked
4581 ? implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
4582 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4583 tree fn_puts = unlocked ? implicit_built_in_decls[BUILT_IN_PUTS_UNLOCKED]
4584 : implicit_built_in_decls[BUILT_IN_PUTS];
4585 const char *fmt_str;
4588 /* If the return value is used, don't do the transformation. */
4589 if (target != const0_rtx)
4592 /* Verify the required arguments in the original call. */
4595 fmt = TREE_VALUE (arglist);
4596 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4598 arglist = TREE_CHAIN (arglist);
4600 /* Check whether the format is a literal string constant. */
4601 fmt_str = c_getstr (fmt);
4602 if (fmt_str == NULL)
4605 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4606 if (strcmp (fmt_str, "%s\n") == 0)
4609 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
4610 || TREE_CHAIN (arglist))
4614 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4615 else if (strcmp (fmt_str, "%c") == 0)
4618 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4619 || TREE_CHAIN (arglist))
4625 /* We can't handle anything else with % args or %% ... yet. */
4626 if (strchr (fmt_str, '%'))
4632 /* If the format specifier was "", printf does nothing. */
4633 if (fmt_str[0] == '\0')
4635 /* If the format specifier has length of 1, call putchar. */
4636 if (fmt_str[1] == '\0')
4638 /* Given printf("c"), (where c is any one character,)
4639 convert "c"[0] to an int and pass that to the replacement
4641 arg = build_int_2 (fmt_str[0], 0);
4642 arglist = build_tree_list (NULL_TREE, arg);
4647 /* If the format specifier was "string\n", call puts("string"). */
4648 size_t len = strlen (fmt_str);
4649 if (fmt_str[len - 1] == '\n')
4651 /* Create a NUL-terminated string that's one char shorter
4652 than the original, stripping off the trailing '\n'. */
4653 char *newstr = alloca (len);
4654 memcpy (newstr, fmt_str, len - 1);
4655 newstr[len - 1] = 0;
4657 arg = build_string_literal (len, newstr);
4658 arglist = build_tree_list (NULL_TREE, arg);
4662 /* We'd like to arrange to call fputs(string,stdout) here,
4663 but we need stdout and don't have a way to get it yet. */
4670 return expand_expr (build_function_call_expr (fn, arglist),
4671 target, mode, EXPAND_NORMAL);
4674 /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
4675 Return 0 if a normal call should be emitted rather than transforming
4676 the function inline. If convenient, the result should be placed in
4677 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4680 expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode,
4683 tree fn_fputc = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4684 : implicit_built_in_decls[BUILT_IN_FPUTC];
4685 tree fn_fputs = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
4686 : implicit_built_in_decls[BUILT_IN_FPUTS];
4687 const char *fmt_str;
4688 tree fn, fmt, fp, arg;
4690 /* If the return value is used, don't do the transformation. */
4691 if (target != const0_rtx)
4694 /* Verify the required arguments in the original call. */
4697 fp = TREE_VALUE (arglist);
4698 if (TREE_CODE (TREE_TYPE (fp)) != POINTER_TYPE)
4700 arglist = TREE_CHAIN (arglist);
4703 fmt = TREE_VALUE (arglist);
4704 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4706 arglist = TREE_CHAIN (arglist);
4708 /* Check whether the format is a literal string constant. */
4709 fmt_str = c_getstr (fmt);
4710 if (fmt_str == NULL)
4713 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
4714 if (strcmp (fmt_str, "%s") == 0)
4717 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
4718 || TREE_CHAIN (arglist))
4720 arg = TREE_VALUE (arglist);
4721 arglist = build_tree_list (NULL_TREE, fp);
4722 arglist = tree_cons (NULL_TREE, arg, arglist);
4725 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
4726 else if (strcmp (fmt_str, "%c") == 0)
4729 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4730 || TREE_CHAIN (arglist))
4732 arg = TREE_VALUE (arglist);
4733 arglist = build_tree_list (NULL_TREE, fp);
4734 arglist = tree_cons (NULL_TREE, arg, arglist);
4739 /* We can't handle anything else with % args or %% ... yet. */
4740 if (strchr (fmt_str, '%'))
4746 /* If the format specifier was "", fprintf does nothing. */
4747 if (fmt_str[0] == '\0')
4749 /* Evaluate and ignore FILE* argument for side-effects. */
4750 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
4754 /* When "string" doesn't contain %, replace all cases of
4755 fprintf(stream,string) with fputs(string,stream). The fputs
4756 builtin will take care of special cases like length == 1. */
4757 arglist = build_tree_list (NULL_TREE, fp);
4758 arglist = tree_cons (NULL_TREE, fmt, arglist);
4764 return expand_expr (build_function_call_expr (fn, arglist),
4765 target, mode, EXPAND_NORMAL);
4768 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
4769 a normal call should be emitted rather than expanding the function
4770 inline. If convenient, the result should be placed in TARGET with
4774 expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
4776 tree orig_arglist, dest, fmt;
4777 const char *fmt_str;
4779 orig_arglist = arglist;
4781 /* Verify the required arguments in the original call. */
4784 dest = TREE_VALUE (arglist);
4785 if (TREE_CODE (TREE_TYPE (dest)) != POINTER_TYPE)
4787 arglist = TREE_CHAIN (arglist);
4790 fmt = TREE_VALUE (arglist);
4791 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4793 arglist = TREE_CHAIN (arglist);
4795 /* Check whether the format is a literal string constant. */
4796 fmt_str = c_getstr (fmt);
4797 if (fmt_str == NULL)
4800 /* If the format doesn't contain % args or %%, use strcpy. */
4801 if (strchr (fmt_str, '%') == 0)
4803 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
4806 if (arglist || ! fn)
4808 expand_expr (build_function_call_expr (fn, orig_arglist),
4809 const0_rtx, VOIDmode, EXPAND_NORMAL);
4810 if (target == const0_rtx)
4812 exp = build_int_2 (strlen (fmt_str), 0);
4813 exp = fold (build1 (NOP_EXPR, integer_type_node, exp));
4814 return expand_expr (exp, target, mode, EXPAND_NORMAL);
4816 /* If the format is "%s", use strcpy if the result isn't used. */
4817 else if (strcmp (fmt_str, "%s") == 0)
4820 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
4825 if (! arglist || TREE_CHAIN (arglist))
4827 arg = TREE_VALUE (arglist);
4828 if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
4831 if (target != const0_rtx)
4833 len = c_strlen (arg, 1);
4834 if (! len || TREE_CODE (len) != INTEGER_CST)
4840 arglist = build_tree_list (NULL_TREE, arg);
4841 arglist = tree_cons (NULL_TREE, dest, arglist);
4842 expand_expr (build_function_call_expr (fn, arglist),
4843 const0_rtx, VOIDmode, EXPAND_NORMAL);
4845 if (target == const0_rtx)
4847 return expand_expr (len, target, mode, EXPAND_NORMAL);
4853 /* Expand a call to the built-in signbit, signbitf or signbitl function.
4854 Return NULL_RTX if a normal call should be emitted rather than expanding
4855 the function in-line. EXP is the expression that is a call to the builtin
4856 function; if convenient, the result should be placed in TARGET. */
4859 expand_builtin_signbit (tree exp, rtx target)
4861 const struct real_format *fmt;
4862 enum machine_mode fmode, imode, rmode;
4863 HOST_WIDE_INT hi, lo;
4868 arglist = TREE_OPERAND (exp, 1);
4869 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4872 arg = TREE_VALUE (arglist);
4873 fmode = TYPE_MODE (TREE_TYPE (arg));
4874 rmode = TYPE_MODE (TREE_TYPE (exp));
4875 fmt = REAL_MODE_FORMAT (fmode);
4877 /* For floating point formats without a sign bit, implement signbit
4879 if (fmt->signbit < 0)
4881 /* But we can't do this if the format supports signed zero. */
4882 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
4885 arg = fold (build (LT_EXPR, TREE_TYPE (exp), arg,
4886 build_real (TREE_TYPE (arg), dconst0)));
4887 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4890 imode = int_mode_for_mode (fmode);
4891 if (imode == BLKmode)
4894 bitpos = fmt->signbit;
4895 /* Handle targets with different FP word orders. */
4896 if (FLOAT_WORDS_BIG_ENDIAN != WORDS_BIG_ENDIAN)
4898 int nwords = GET_MODE_BITSIZE (fmode) / BITS_PER_WORD;
4899 int word = nwords - (bitpos / BITS_PER_WORD) - 1;
4900 bitpos = word * BITS_PER_WORD + bitpos % BITS_PER_WORD;
4903 /* If the sign bit is not in the lowpart and the floating point format
4904 is wider than an integer, check that is twice the size of an integer
4905 so that we can use gen_highpart below. */
4906 if (bitpos >= GET_MODE_BITSIZE (rmode)
4907 && GET_MODE_BITSIZE (imode) != 2 * GET_MODE_BITSIZE (rmode))
4910 temp = expand_expr (arg, NULL_RTX, VOIDmode, 0);
4911 temp = gen_lowpart (imode, temp);
4913 if (GET_MODE_BITSIZE (imode) > GET_MODE_BITSIZE (rmode))
4915 if (BITS_BIG_ENDIAN)
4916 bitpos = GET_MODE_BITSIZE (imode) - 1 - bitpos;
4917 temp = copy_to_mode_reg (imode, temp);
4918 temp = extract_bit_field (temp, 1, bitpos, 1,
4919 NULL_RTX, rmode, rmode,
4920 GET_MODE_SIZE (imode));
4924 if (GET_MODE_BITSIZE (imode) < GET_MODE_BITSIZE (rmode))
4925 temp = gen_lowpart (rmode, temp);
4926 if (bitpos < HOST_BITS_PER_WIDE_INT)
4929 lo = (HOST_WIDE_INT) 1 << bitpos;
4933 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
4937 temp = force_reg (rmode, temp);
4938 temp = expand_binop (rmode, and_optab, temp,
4939 immed_double_const (lo, hi, rmode),
4940 target, 1, OPTAB_LIB_WIDEN);
4945 /* Expand an expression EXP that calls a built-in function,
4946 with result going to TARGET if that's convenient
4947 (and in mode MODE if that's convenient).
4948 SUBTARGET may be used as the target for computing one of EXP's operands.
4949 IGNORE is nonzero if the value is to be ignored. */
4952 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
4955 tree fndecl = get_callee_fndecl (exp);
4956 tree arglist = TREE_OPERAND (exp, 1);
4957 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4958 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
4960 /* Perform postincrements before expanding builtin functions. */
4963 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
4964 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
4966 /* When not optimizing, generate calls to library functions for a certain
4969 && !CALLED_AS_BUILT_IN (fndecl)
4970 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
4971 && fcode != BUILT_IN_ALLOCA)
4972 return expand_call (exp, target, ignore);
4974 /* The built-in function expanders test for target == const0_rtx
4975 to determine whether the function's result will be ignored. */
4977 target = const0_rtx;
4979 /* If the result of a pure or const built-in function is ignored, and
4980 none of its arguments are volatile, we can avoid expanding the
4981 built-in call and just evaluate the arguments for side-effects. */
4982 if (target == const0_rtx
4983 && (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
4985 bool volatilep = false;
4988 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
4989 if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
4997 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
4998 expand_expr (TREE_VALUE (arg), const0_rtx,
4999 VOIDmode, EXPAND_NORMAL);
5008 case BUILT_IN_LLABS:
5009 case BUILT_IN_IMAXABS:
5010 /* build_function_call changes these into ABS_EXPR. */
5014 case BUILT_IN_FABSF:
5015 case BUILT_IN_FABSL:
5016 target = expand_builtin_fabs (arglist, target, subtarget);
5022 case BUILT_IN_CABSF:
5023 case BUILT_IN_CABSL:
5024 if (flag_unsafe_math_optimizations)
5026 target = expand_builtin_cabs (arglist, target);
5033 case BUILT_IN_CONJF:
5034 case BUILT_IN_CONJL:
5035 case BUILT_IN_CREAL:
5036 case BUILT_IN_CREALF:
5037 case BUILT_IN_CREALL:
5038 case BUILT_IN_CIMAG:
5039 case BUILT_IN_CIMAGF:
5040 case BUILT_IN_CIMAGL:
5041 /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
5042 and IMAGPART_EXPR. */
5054 case BUILT_IN_EXP10:
5055 case BUILT_IN_EXP10F:
5056 case BUILT_IN_EXP10L:
5057 case BUILT_IN_POW10:
5058 case BUILT_IN_POW10F:
5059 case BUILT_IN_POW10L:
5061 case BUILT_IN_EXP2F:
5062 case BUILT_IN_EXP2L:
5066 case BUILT_IN_LOG10:
5067 case BUILT_IN_LOG10F:
5068 case BUILT_IN_LOG10L:
5070 case BUILT_IN_LOG2F:
5071 case BUILT_IN_LOG2L:
5076 case BUILT_IN_ATANF:
5077 case BUILT_IN_ATANL:
5078 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5079 because of possible accuracy problems. */
5080 if (! flag_unsafe_math_optimizations)
5083 case BUILT_IN_SQRTF:
5084 case BUILT_IN_SQRTL:
5085 case BUILT_IN_FLOOR:
5086 case BUILT_IN_FLOORF:
5087 case BUILT_IN_FLOORL:
5089 case BUILT_IN_CEILF:
5090 case BUILT_IN_CEILL:
5091 case BUILT_IN_TRUNC:
5092 case BUILT_IN_TRUNCF:
5093 case BUILT_IN_TRUNCL:
5094 case BUILT_IN_ROUND:
5095 case BUILT_IN_ROUNDF:
5096 case BUILT_IN_ROUNDL:
5097 case BUILT_IN_NEARBYINT:
5098 case BUILT_IN_NEARBYINTF:
5099 case BUILT_IN_NEARBYINTL:
5100 target = expand_builtin_mathfn (exp, target, subtarget);
5108 target = expand_builtin_pow (exp, target, subtarget);
5113 case BUILT_IN_ATAN2:
5114 case BUILT_IN_ATAN2F:
5115 case BUILT_IN_ATAN2L:
5116 if (! flag_unsafe_math_optimizations)
5118 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5123 case BUILT_IN_APPLY_ARGS:
5124 return expand_builtin_apply_args ();
5126 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5127 FUNCTION with a copy of the parameters described by
5128 ARGUMENTS, and ARGSIZE. It returns a block of memory
5129 allocated on the stack into which is stored all the registers
5130 that might possibly be used for returning the result of a
5131 function. ARGUMENTS is the value returned by
5132 __builtin_apply_args. ARGSIZE is the number of bytes of
5133 arguments that must be copied. ??? How should this value be
5134 computed? We'll also need a safe worst case value for varargs
5136 case BUILT_IN_APPLY:
5137 if (!validate_arglist (arglist, POINTER_TYPE,
5138 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5139 && !validate_arglist (arglist, REFERENCE_TYPE,
5140 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5148 for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
5149 ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
5151 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5154 /* __builtin_return (RESULT) causes the function to return the
5155 value described by RESULT. RESULT is address of the block of
5156 memory returned by __builtin_apply. */
5157 case BUILT_IN_RETURN:
5158 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5159 expand_builtin_return (expand_expr (TREE_VALUE (arglist),
5160 NULL_RTX, VOIDmode, 0));
5163 case BUILT_IN_SAVEREGS:
5164 return expand_builtin_saveregs ();
5166 case BUILT_IN_ARGS_INFO:
5167 return expand_builtin_args_info (arglist);
5169 /* Return the address of the first anonymous stack arg. */
5170 case BUILT_IN_NEXT_ARG:
5171 return expand_builtin_next_arg (arglist);
5173 case BUILT_IN_CLASSIFY_TYPE:
5174 return expand_builtin_classify_type (arglist);
5176 case BUILT_IN_CONSTANT_P:
5177 return expand_builtin_constant_p (arglist, target_mode);
5179 case BUILT_IN_FRAME_ADDRESS:
5180 case BUILT_IN_RETURN_ADDRESS:
5181 return expand_builtin_frame_address (fndecl, arglist);
5183 /* Returns the address of the area where the structure is returned.
5185 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5187 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5188 || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
5191 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5193 case BUILT_IN_ALLOCA:
5194 target = expand_builtin_alloca (arglist, target);
5201 case BUILT_IN_FFSLL:
5202 target = expand_builtin_unop (target_mode, arglist, target,
5203 subtarget, ffs_optab);
5210 case BUILT_IN_CLZLL:
5211 target = expand_builtin_unop (target_mode, arglist, target,
5212 subtarget, clz_optab);
5219 case BUILT_IN_CTZLL:
5220 target = expand_builtin_unop (target_mode, arglist, target,
5221 subtarget, ctz_optab);
5226 case BUILT_IN_POPCOUNT:
5227 case BUILT_IN_POPCOUNTL:
5228 case BUILT_IN_POPCOUNTLL:
5229 target = expand_builtin_unop (target_mode, arglist, target,
5230 subtarget, popcount_optab);
5235 case BUILT_IN_PARITY:
5236 case BUILT_IN_PARITYL:
5237 case BUILT_IN_PARITYLL:
5238 target = expand_builtin_unop (target_mode, arglist, target,
5239 subtarget, parity_optab);
5244 case BUILT_IN_STRLEN:
5245 target = expand_builtin_strlen (arglist, target, target_mode);
5250 case BUILT_IN_STRCPY:
5251 target = expand_builtin_strcpy (arglist, target, mode);
5256 case BUILT_IN_STRNCPY:
5257 target = expand_builtin_strncpy (arglist, target, mode);
5262 case BUILT_IN_STPCPY:
5263 target = expand_builtin_stpcpy (arglist, target, mode);
5268 case BUILT_IN_STRCAT:
5269 target = expand_builtin_strcat (arglist, target, mode);
5274 case BUILT_IN_STRNCAT:
5275 target = expand_builtin_strncat (arglist, target, mode);
5280 case BUILT_IN_STRSPN:
5281 target = expand_builtin_strspn (arglist, target, mode);
5286 case BUILT_IN_STRCSPN:
5287 target = expand_builtin_strcspn (arglist, target, mode);
5292 case BUILT_IN_STRSTR:
5293 target = expand_builtin_strstr (arglist, target, mode);
5298 case BUILT_IN_STRPBRK:
5299 target = expand_builtin_strpbrk (arglist, target, mode);
5304 case BUILT_IN_INDEX:
5305 case BUILT_IN_STRCHR:
5306 target = expand_builtin_strchr (arglist, target, mode);
5311 case BUILT_IN_RINDEX:
5312 case BUILT_IN_STRRCHR:
5313 target = expand_builtin_strrchr (arglist, target, mode);
5318 case BUILT_IN_MEMCPY:
5319 target = expand_builtin_memcpy (arglist, target, mode);
5324 case BUILT_IN_MEMPCPY:
5325 target = expand_builtin_mempcpy (arglist, target, mode, /*endp=*/ 1);
5330 case BUILT_IN_MEMMOVE:
5331 target = expand_builtin_memmove (arglist, target, mode);
5336 case BUILT_IN_BCOPY:
5337 target = expand_builtin_bcopy (arglist);
5342 case BUILT_IN_MEMSET:
5343 target = expand_builtin_memset (arglist, target, mode);
5348 case BUILT_IN_BZERO:
5349 target = expand_builtin_bzero (arglist);
5354 case BUILT_IN_STRCMP:
5355 target = expand_builtin_strcmp (exp, target, mode);
5360 case BUILT_IN_STRNCMP:
5361 target = expand_builtin_strncmp (exp, target, mode);
5367 case BUILT_IN_MEMCMP:
5368 target = expand_builtin_memcmp (exp, arglist, target, mode);
5373 case BUILT_IN_SETJMP:
5374 target = expand_builtin_setjmp (arglist, target);
5379 /* __builtin_longjmp is passed a pointer to an array of five words.
5380 It's similar to the C library longjmp function but works with
5381 __builtin_setjmp above. */
5382 case BUILT_IN_LONGJMP:
5383 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5387 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
5389 rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
5390 NULL_RTX, VOIDmode, 0);
5392 if (value != const1_rtx)
5394 error ("__builtin_longjmp second argument must be 1");
5398 expand_builtin_longjmp (buf_addr, value);
5403 expand_builtin_trap ();
5406 case BUILT_IN_PRINTF:
5407 target = expand_builtin_printf (arglist, target, mode, false);
5412 case BUILT_IN_PRINTF_UNLOCKED:
5413 target = expand_builtin_printf (arglist, target, mode, true);
5418 case BUILT_IN_FPUTS:
5419 target = expand_builtin_fputs (arglist, target, false);
5424 case BUILT_IN_FPUTS_UNLOCKED:
5425 target = expand_builtin_fputs (arglist, target, true);
5430 case BUILT_IN_FPRINTF:
5431 target = expand_builtin_fprintf (arglist, target, mode, false);
5436 case BUILT_IN_FPRINTF_UNLOCKED:
5437 target = expand_builtin_fprintf (arglist, target, mode, true);
5442 case BUILT_IN_SPRINTF:
5443 target = expand_builtin_sprintf (arglist, target, mode);
5448 case BUILT_IN_SIGNBIT:
5449 case BUILT_IN_SIGNBITF:
5450 case BUILT_IN_SIGNBITL:
5451 target = expand_builtin_signbit (exp, target);
5456 /* Various hooks for the DWARF 2 __throw routine. */
5457 case BUILT_IN_UNWIND_INIT:
5458 expand_builtin_unwind_init ();
5460 case BUILT_IN_DWARF_CFA:
5461 return virtual_cfa_rtx;
5462 #ifdef DWARF2_UNWIND_INFO
5463 case BUILT_IN_DWARF_SP_COLUMN:
5464 return expand_builtin_dwarf_sp_column ();
5465 case BUILT_IN_INIT_DWARF_REG_SIZES:
5466 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
5469 case BUILT_IN_FROB_RETURN_ADDR:
5470 return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
5471 case BUILT_IN_EXTRACT_RETURN_ADDR:
5472 return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
5473 case BUILT_IN_EH_RETURN:
5474 expand_builtin_eh_return (TREE_VALUE (arglist),
5475 TREE_VALUE (TREE_CHAIN (arglist)));
5477 #ifdef EH_RETURN_DATA_REGNO
5478 case BUILT_IN_EH_RETURN_DATA_REGNO:
5479 return expand_builtin_eh_return_data_regno (arglist);
5481 case BUILT_IN_EXTEND_POINTER:
5482 return expand_builtin_extend_pointer (TREE_VALUE (arglist));
5484 case BUILT_IN_VA_START:
5485 case BUILT_IN_STDARG_START:
5486 return expand_builtin_va_start (arglist);
5487 case BUILT_IN_VA_END:
5488 return expand_builtin_va_end (arglist);
5489 case BUILT_IN_VA_COPY:
5490 return expand_builtin_va_copy (arglist);
5491 case BUILT_IN_EXPECT:
5492 return expand_builtin_expect (arglist, target);
5493 case BUILT_IN_PREFETCH:
5494 expand_builtin_prefetch (arglist);
5498 default: /* just do library call, if unknown builtin */
5499 if (!DECL_ASSEMBLER_NAME_SET_P (fndecl))
5500 error ("built-in function `%s' not currently supported",
5501 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
5504 /* The switch statement above can drop through to cause the function
5505 to be called normally. */
5506 return expand_call (exp, target, ignore);
5509 /* Determine whether a tree node represents a call to a built-in
5510 function. If the tree T is a call to a built-in function with
5511 the right number of arguments of the appropriate types, return
5512 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
5513 Otherwise the return value is END_BUILTINS. */
5515 enum built_in_function
5516 builtin_mathfn_code (tree t)
5518 tree fndecl, arglist, parmlist;
5519 tree argtype, parmtype;
5521 if (TREE_CODE (t) != CALL_EXPR
5522 || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
5523 return END_BUILTINS;
5525 fndecl = get_callee_fndecl (t);
5526 if (fndecl == NULL_TREE
5527 || TREE_CODE (fndecl) != FUNCTION_DECL
5528 || ! DECL_BUILT_IN (fndecl)
5529 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5530 return END_BUILTINS;
5532 arglist = TREE_OPERAND (t, 1);
5533 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5534 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
5536 /* If a function doesn't take a variable number of arguments,
5537 the last element in the list will have type `void'. */
5538 parmtype = TREE_VALUE (parmlist);
5539 if (VOID_TYPE_P (parmtype))
5542 return END_BUILTINS;
5543 return DECL_FUNCTION_CODE (fndecl);
5547 return END_BUILTINS;
5549 argtype = TREE_TYPE (TREE_VALUE (arglist));
5551 if (SCALAR_FLOAT_TYPE_P (parmtype))
5553 if (! SCALAR_FLOAT_TYPE_P (argtype))
5554 return END_BUILTINS;
5556 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
5558 if (! COMPLEX_FLOAT_TYPE_P (argtype))
5559 return END_BUILTINS;
5561 else if (POINTER_TYPE_P (parmtype))
5563 if (! POINTER_TYPE_P (argtype))
5564 return END_BUILTINS;
5566 else if (INTEGRAL_TYPE_P (parmtype))
5568 if (! INTEGRAL_TYPE_P (argtype))
5569 return END_BUILTINS;
5572 return END_BUILTINS;
5574 arglist = TREE_CHAIN (arglist);
5577 /* Variable-length argument list. */
5578 return DECL_FUNCTION_CODE (fndecl);
5581 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
5582 constant. ARGLIST is the argument list of the call. */
5585 fold_builtin_constant_p (tree arglist)
5590 arglist = TREE_VALUE (arglist);
5592 /* We return 1 for a numeric type that's known to be a constant
5593 value at compile-time or for an aggregate type that's a
5594 literal constant. */
5595 STRIP_NOPS (arglist);
5597 /* If we know this is a constant, emit the constant of one. */
5598 if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
5599 || (TREE_CODE (arglist) == CONSTRUCTOR
5600 && TREE_CONSTANT (arglist))
5601 || (TREE_CODE (arglist) == ADDR_EXPR
5602 && TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST))
5603 return integer_one_node;
5605 /* If this expression has side effects, show we don't know it to be a
5606 constant. Likewise if it's a pointer or aggregate type since in
5607 those case we only want literals, since those are only optimized
5608 when generating RTL, not later.
5609 And finally, if we are compiling an initializer, not code, we
5610 need to return a definite result now; there's not going to be any
5611 more optimization done. */
5612 if (TREE_SIDE_EFFECTS (arglist)
5613 || AGGREGATE_TYPE_P (TREE_TYPE (arglist))
5614 || POINTER_TYPE_P (TREE_TYPE (arglist))
5616 return integer_zero_node;
5621 /* Fold a call to __builtin_classify_type. */
5624 fold_builtin_classify_type (tree arglist)
5627 return build_int_2 (no_type_class, 0);
5629 return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
5632 /* Fold a call to __builtin_inf or __builtin_huge_val. */
5635 fold_builtin_inf (tree type, int warn)
5637 REAL_VALUE_TYPE real;
5639 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
5640 warning ("target format does not support infinity");
5643 return build_real (type, real);
5646 /* Fold a call to __builtin_nan or __builtin_nans. */
5649 fold_builtin_nan (tree arglist, tree type, int quiet)
5651 REAL_VALUE_TYPE real;
5654 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5656 str = c_getstr (TREE_VALUE (arglist));
5660 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
5663 return build_real (type, real);
5666 /* Return true if the floating point expression T has an integer value.
5667 We also allow +Inf, -Inf and NaN to be considered integer values. */
5670 integer_valued_real_p (tree t)
5672 switch (TREE_CODE (t))
5679 case NON_LVALUE_EXPR:
5680 return integer_valued_real_p (TREE_OPERAND (t, 0));
5685 return integer_valued_real_p (TREE_OPERAND (t, 1));
5692 return integer_valued_real_p (TREE_OPERAND (t, 0))
5693 && integer_valued_real_p (TREE_OPERAND (t, 1));
5696 return integer_valued_real_p (TREE_OPERAND (t, 1))
5697 && integer_valued_real_p (TREE_OPERAND (t, 2));
5700 if (! TREE_CONSTANT_OVERFLOW (t))
5702 REAL_VALUE_TYPE c, cint;
5704 c = TREE_REAL_CST (t);
5705 real_trunc (&cint, TYPE_MODE (TREE_TYPE (t)), &c);
5706 return real_identical (&c, &cint);
5711 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
5712 if (TREE_CODE (type) == INTEGER_TYPE)
5714 if (TREE_CODE (type) == REAL_TYPE)
5715 return integer_valued_real_p (TREE_OPERAND (t, 0));
5720 switch (builtin_mathfn_code (t))
5723 case BUILT_IN_CEILF:
5724 case BUILT_IN_CEILL:
5725 case BUILT_IN_FLOOR:
5726 case BUILT_IN_FLOORF:
5727 case BUILT_IN_FLOORL:
5728 case BUILT_IN_NEARBYINT:
5729 case BUILT_IN_NEARBYINTF:
5730 case BUILT_IN_NEARBYINTL:
5732 case BUILT_IN_RINTF:
5733 case BUILT_IN_RINTL:
5734 case BUILT_IN_ROUND:
5735 case BUILT_IN_ROUNDF:
5736 case BUILT_IN_ROUNDL:
5737 case BUILT_IN_TRUNC:
5738 case BUILT_IN_TRUNCF:
5739 case BUILT_IN_TRUNCL:
5753 /* EXP is assumed to be builtin call where truncation can be propagated
5754 across (for instance floor((double)f) == (double)floorf (f).
5755 Do the transformation. */
5758 fold_trunc_transparent_mathfn (tree exp)
5760 tree fndecl = get_callee_fndecl (exp);
5761 tree arglist = TREE_OPERAND (exp, 1);
5762 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5765 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5768 arg = TREE_VALUE (arglist);
5769 /* Integer rounding functions are idempotent. */
5770 if (fcode == builtin_mathfn_code (arg))
5773 /* If argument is already integer valued, and we don't need to worry
5774 about setting errno, there's no need to perform rounding. */
5775 if (! flag_errno_math && integer_valued_real_p (arg))
5780 tree arg0 = strip_float_extensions (arg);
5781 tree ftype = TREE_TYPE (exp);
5782 tree newtype = TREE_TYPE (arg0);
5785 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
5786 && (decl = mathfn_built_in (newtype, fcode)))
5789 build_tree_list (NULL_TREE, fold (convert (newtype, arg0)));
5790 return convert (ftype,
5791 build_function_call_expr (decl, arglist));
5797 /* Fold function call to builtin cabs, cabsf or cabsl. FNDECL is the
5798 function's DECL, ARGLIST is the argument list and TYPE is the return
5799 type. Return NULL_TREE if no simplification can be made. */
5802 fold_builtin_cabs (tree fndecl, tree arglist, tree type)
5806 if (!arglist || TREE_CHAIN (arglist))
5809 arg = TREE_VALUE (arglist);
5810 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
5811 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
5814 /* Evaluate cabs of a constant at compile-time. */
5815 if (flag_unsafe_math_optimizations
5816 && TREE_CODE (arg) == COMPLEX_CST
5817 && TREE_CODE (TREE_REALPART (arg)) == REAL_CST
5818 && TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
5819 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
5820 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
5822 REAL_VALUE_TYPE r, i;
5824 r = TREE_REAL_CST (TREE_REALPART (arg));
5825 i = TREE_REAL_CST (TREE_IMAGPART (arg));
5827 real_arithmetic (&r, MULT_EXPR, &r, &r);
5828 real_arithmetic (&i, MULT_EXPR, &i, &i);
5829 real_arithmetic (&r, PLUS_EXPR, &r, &i);
5830 if (real_sqrt (&r, TYPE_MODE (type), &r)
5831 || ! flag_trapping_math)
5832 return build_real (type, r);
5835 /* If either part is zero, cabs is fabs of the other. */
5836 if (TREE_CODE (arg) == COMPLEX_EXPR
5837 && real_zerop (TREE_OPERAND (arg, 0)))
5838 return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1)));
5839 if (TREE_CODE (arg) == COMPLEX_EXPR
5840 && real_zerop (TREE_OPERAND (arg, 1)))
5841 return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0)));
5843 if (flag_unsafe_math_optimizations)
5845 enum built_in_function fcode;
5848 fcode = DECL_FUNCTION_CODE (fndecl);
5849 if (fcode == BUILT_IN_CABS)
5850 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
5851 else if (fcode == BUILT_IN_CABSF)
5852 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
5853 else if (fcode == BUILT_IN_CABSL)
5854 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
5858 if (sqrtfn != NULL_TREE)
5860 tree rpart, ipart, result, arglist;
5862 arg = save_expr (arg);
5864 rpart = fold (build1 (REALPART_EXPR, type, arg));
5865 ipart = fold (build1 (IMAGPART_EXPR, type, arg));
5867 rpart = save_expr (rpart);
5868 ipart = save_expr (ipart);
5870 result = fold (build (PLUS_EXPR, type,
5871 fold (build (MULT_EXPR, type,
5873 fold (build (MULT_EXPR, type,
5876 arglist = build_tree_list (NULL_TREE, result);
5877 return build_function_call_expr (sqrtfn, arglist);
5884 /* Fold function call to builtin trunc, truncf or truncl. Return
5885 NULL_TREE if no simplification can be made. */
5888 fold_builtin_trunc (tree exp)
5890 tree arglist = TREE_OPERAND (exp, 1);
5893 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5896 /* Optimize trunc of constant value. */
5897 arg = TREE_VALUE (arglist);
5898 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5900 REAL_VALUE_TYPE r, x;
5901 tree type = TREE_TYPE (exp);
5903 x = TREE_REAL_CST (arg);
5904 real_trunc (&r, TYPE_MODE (type), &x);
5905 return build_real (type, r);
5908 return fold_trunc_transparent_mathfn (exp);
5911 /* Fold function call to builtin floor, floorf or floorl. Return
5912 NULL_TREE if no simplification can be made. */
5915 fold_builtin_floor (tree exp)
5917 tree arglist = TREE_OPERAND (exp, 1);
5920 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5923 /* Optimize floor of constant value. */
5924 arg = TREE_VALUE (arglist);
5925 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5929 x = TREE_REAL_CST (arg);
5930 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
5932 tree type = TREE_TYPE (exp);
5935 real_floor (&r, TYPE_MODE (type), &x);
5936 return build_real (type, r);
5940 return fold_trunc_transparent_mathfn (exp);
5943 /* Fold function call to builtin ceil, ceilf or ceill. Return
5944 NULL_TREE if no simplification can be made. */
5947 fold_builtin_ceil (tree exp)
5949 tree arglist = TREE_OPERAND (exp, 1);
5952 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5955 /* Optimize ceil of constant value. */
5956 arg = TREE_VALUE (arglist);
5957 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5961 x = TREE_REAL_CST (arg);
5962 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
5964 tree type = TREE_TYPE (exp);
5967 real_ceil (&r, TYPE_MODE (type), &x);
5968 return build_real (type, r);
5972 return fold_trunc_transparent_mathfn (exp);
5975 /* Fold function call to builtin round, roundf or roundl. Return
5976 NULL_TREE if no simplification can be made. */
5979 fold_builtin_round (tree exp)
5981 tree arglist = TREE_OPERAND (exp, 1);
5984 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5987 /* Optimize ceil of constant value. */
5988 arg = TREE_VALUE (arglist);
5989 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5993 x = TREE_REAL_CST (arg);
5994 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
5996 tree type = TREE_TYPE (exp);
5999 real_round (&r, TYPE_MODE (type), &x);
6000 return build_real (type, r);
6004 return fold_trunc_transparent_mathfn (exp);
6007 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
6008 and their long and long long variants (i.e. ffsl and ffsll).
6009 Return NULL_TREE if no simplification can be made. */
6012 fold_builtin_bitop (tree exp)
6014 tree fndecl = get_callee_fndecl (exp);
6015 tree arglist = TREE_OPERAND (exp, 1);
6018 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
6021 /* Optimize for constant argument. */
6022 arg = TREE_VALUE (arglist);
6023 if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
6025 HOST_WIDE_INT hi, width, result;
6026 unsigned HOST_WIDE_INT lo;
6029 type = TREE_TYPE (arg);
6030 width = TYPE_PRECISION (type);
6031 lo = TREE_INT_CST_LOW (arg);
6033 /* Clear all the bits that are beyond the type's precision. */
6034 if (width > HOST_BITS_PER_WIDE_INT)
6036 hi = TREE_INT_CST_HIGH (arg);
6037 if (width < 2 * HOST_BITS_PER_WIDE_INT)
6038 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
6043 if (width < HOST_BITS_PER_WIDE_INT)
6044 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
6047 switch (DECL_FUNCTION_CODE (fndecl))
6051 case BUILT_IN_FFSLL:
6053 result = exact_log2 (lo & -lo) + 1;
6055 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
6062 case BUILT_IN_CLZLL:
6064 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
6066 result = width - floor_log2 (lo) - 1;
6067 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
6073 case BUILT_IN_CTZLL:
6075 result = exact_log2 (lo & -lo);
6077 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
6078 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
6082 case BUILT_IN_POPCOUNT:
6083 case BUILT_IN_POPCOUNTL:
6084 case BUILT_IN_POPCOUNTLL:
6087 result++, lo &= lo - 1;
6089 result++, hi &= hi - 1;
6092 case BUILT_IN_PARITY:
6093 case BUILT_IN_PARITYL:
6094 case BUILT_IN_PARITYLL:
6097 result++, lo &= lo - 1;
6099 result++, hi &= hi - 1;
6107 t = build_int_2 (result, 0);
6108 TREE_TYPE (t) = TREE_TYPE (exp);
6115 /* Return true if EXPR is the real constant contained in VALUE. */
6118 real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
6122 return ((TREE_CODE (expr) == REAL_CST
6123 && ! TREE_CONSTANT_OVERFLOW (expr)
6124 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
6125 || (TREE_CODE (expr) == COMPLEX_CST
6126 && real_dconstp (TREE_REALPART (expr), value)
6127 && real_zerop (TREE_IMAGPART (expr))));
6130 /* A subroutine of fold_builtin to fold the various logarithmic
6131 functions. EXP is the CALL_EXPR of a call to a builtin logN
6132 function. VALUE is the base of the logN function. */
6135 fold_builtin_logarithm (tree exp, const REAL_VALUE_TYPE *value)
6137 tree arglist = TREE_OPERAND (exp, 1);
6139 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6141 tree fndecl = get_callee_fndecl (exp);
6142 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6143 tree arg = TREE_VALUE (arglist);
6144 const enum built_in_function fcode = builtin_mathfn_code (arg);
6146 /* Optimize logN(1.0) = 0.0. */
6147 if (real_onep (arg))
6148 return build_real (type, dconst0);
6150 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
6151 exactly, then only do this if flag_unsafe_math_optimizations. */
6152 if (exact_real_truncate (TYPE_MODE (type), value)
6153 || flag_unsafe_math_optimizations)
6155 const REAL_VALUE_TYPE value_truncate =
6156 real_value_truncate (TYPE_MODE (type), *value);
6157 if (real_dconstp (arg, &value_truncate))
6158 return build_real (type, dconst1);
6161 /* Special case, optimize logN(expN(x)) = x. */
6162 if (flag_unsafe_math_optimizations
6163 && ((value == &dconste
6164 && (fcode == BUILT_IN_EXP
6165 || fcode == BUILT_IN_EXPF
6166 || fcode == BUILT_IN_EXPL))
6167 || (value == &dconst2
6168 && (fcode == BUILT_IN_EXP2
6169 || fcode == BUILT_IN_EXP2F
6170 || fcode == BUILT_IN_EXP2L))
6171 || (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
6172 return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6174 /* Optimize logN(func()) for various exponential functions. We
6175 want to determine the value "x" and the power "exponent" in
6176 order to transform logN(x**exponent) into exponent*logN(x). */
6177 if (flag_unsafe_math_optimizations)
6179 tree exponent = 0, x = 0;
6186 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
6187 x = build_real (type,
6188 real_value_truncate (TYPE_MODE (type), dconste));
6189 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6192 case BUILT_IN_EXP2F:
6193 case BUILT_IN_EXP2L:
6194 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
6195 x = build_real (type, dconst2);
6196 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6198 case BUILT_IN_EXP10:
6199 case BUILT_IN_EXP10F:
6200 case BUILT_IN_EXP10L:
6201 case BUILT_IN_POW10:
6202 case BUILT_IN_POW10F:
6203 case BUILT_IN_POW10L:
6204 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
6205 x = build_real (type, dconst10);
6206 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6209 case BUILT_IN_SQRTF:
6210 case BUILT_IN_SQRTL:
6211 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
6212 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6213 exponent = build_real (type, dconsthalf);
6216 case BUILT_IN_CBRTF:
6217 case BUILT_IN_CBRTL:
6218 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
6219 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6220 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
6226 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
6227 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6228 exponent = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6234 /* Now perform the optimization. */
6238 arglist = build_tree_list (NULL_TREE, x);
6239 logfn = build_function_call_expr (fndecl, arglist);
6240 return fold (build (MULT_EXPR, type, exponent, logfn));
6248 /* A subroutine of fold_builtin to fold the various exponent
6249 functions. EXP is the CALL_EXPR of a call to a builtin function.
6250 VALUE is the value which will be raised to a power. */
6253 fold_builtin_exponent (tree exp, const REAL_VALUE_TYPE *value)
6255 tree arglist = TREE_OPERAND (exp, 1);
6257 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6259 tree fndecl = get_callee_fndecl (exp);
6260 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6261 tree arg = TREE_VALUE (arglist);
6263 /* Optimize exp*(0.0) = 1.0. */
6264 if (real_zerop (arg))
6265 return build_real (type, dconst1);
6267 /* Optimize expN(1.0) = N. */
6268 if (real_onep (arg))
6270 REAL_VALUE_TYPE cst;
6272 real_convert (&cst, TYPE_MODE (type), value);
6273 return build_real (type, cst);
6276 /* Attempt to evaluate expN(integer) at compile-time. */
6277 if (flag_unsafe_math_optimizations
6278 && TREE_CODE (arg) == REAL_CST
6279 && ! TREE_CONSTANT_OVERFLOW (arg))
6281 REAL_VALUE_TYPE cint;
6285 c = TREE_REAL_CST (arg);
6286 n = real_to_integer (&c);
6287 real_from_integer (&cint, VOIDmode, n,
6289 if (real_identical (&c, &cint))
6293 real_powi (&x, TYPE_MODE (type), value, n);
6294 return build_real (type, x);
6298 /* Optimize expN(logN(x)) = x. */
6299 if (flag_unsafe_math_optimizations)
6301 const enum built_in_function fcode = builtin_mathfn_code (arg);
6303 if ((value == &dconste
6304 && (fcode == BUILT_IN_LOG
6305 || fcode == BUILT_IN_LOGF
6306 || fcode == BUILT_IN_LOGL))
6307 || (value == &dconst2
6308 && (fcode == BUILT_IN_LOG2
6309 || fcode == BUILT_IN_LOG2F
6310 || fcode == BUILT_IN_LOG2L))
6311 || (value == &dconst10
6312 && (fcode == BUILT_IN_LOG10
6313 || fcode == BUILT_IN_LOG10F
6314 || fcode == BUILT_IN_LOG10L)))
6315 return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6322 /* Fold function call to builtin memcpy. Return
6323 NULL_TREE if no simplification can be made. */
6326 fold_builtin_memcpy (tree exp)
6328 tree arglist = TREE_OPERAND (exp, 1);
6329 tree dest, src, len;
6331 if (!validate_arglist (arglist,
6332 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6335 dest = TREE_VALUE (arglist);
6336 src = TREE_VALUE (TREE_CHAIN (arglist));
6337 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6339 /* If the LEN parameter is zero, return DEST. */
6340 if (integer_zerop (len))
6341 return omit_one_operand (TREE_TYPE (exp), dest, src);
6343 /* If SRC and DEST are the same (and not volatile), return DEST. */
6344 if (operand_equal_p (src, dest, 0))
6345 return omit_one_operand (TREE_TYPE (exp), dest, len);
6350 /* Fold function call to builtin mempcpy. Return
6351 NULL_TREE if no simplification can be made. */
6354 fold_builtin_mempcpy (tree exp)
6356 tree arglist = TREE_OPERAND (exp, 1);
6357 tree dest, src, len;
6359 if (!validate_arglist (arglist,
6360 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6363 dest = TREE_VALUE (arglist);
6364 src = TREE_VALUE (TREE_CHAIN (arglist));
6365 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6367 /* If the LEN parameter is zero, return DEST. */
6368 if (integer_zerop (len))
6369 return omit_one_operand (TREE_TYPE (exp), dest, src);
6371 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
6372 if (operand_equal_p (src, dest, 0))
6374 tree temp = convert (TREE_TYPE (dest), len);
6375 temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
6376 return convert (TREE_TYPE (exp), temp);
6382 /* Fold function call to builtin memmove. Return
6383 NULL_TREE if no simplification can be made. */
6386 fold_builtin_memmove (tree exp)
6388 tree arglist = TREE_OPERAND (exp, 1);
6389 tree dest, src, len;
6391 if (!validate_arglist (arglist,
6392 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6395 dest = TREE_VALUE (arglist);
6396 src = TREE_VALUE (TREE_CHAIN (arglist));
6397 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6399 /* If the LEN parameter is zero, return DEST. */
6400 if (integer_zerop (len))
6401 return omit_one_operand (TREE_TYPE (exp), dest, src);
6403 /* If SRC and DEST are the same (and not volatile), return DEST. */
6404 if (operand_equal_p (src, dest, 0))
6405 return omit_one_operand (TREE_TYPE (exp), dest, len);
6410 /* Fold function call to builtin strcpy. Return
6411 NULL_TREE if no simplification can be made. */
6414 fold_builtin_strcpy (tree exp)
6416 tree arglist = TREE_OPERAND (exp, 1);
6419 if (!validate_arglist (arglist,
6420 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6423 dest = TREE_VALUE (arglist);
6424 src = TREE_VALUE (TREE_CHAIN (arglist));
6426 /* If SRC and DEST are the same (and not volatile), return DEST. */
6427 if (operand_equal_p (src, dest, 0))
6428 return convert (TREE_TYPE (exp), dest);
6433 /* Fold function call to builtin strncpy. Return
6434 NULL_TREE if no simplification can be made. */
6437 fold_builtin_strncpy (tree exp)
6439 tree arglist = TREE_OPERAND (exp, 1);
6440 tree dest, src, len;
6442 if (!validate_arglist (arglist,
6443 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6446 dest = TREE_VALUE (arglist);
6447 src = TREE_VALUE (TREE_CHAIN (arglist));
6448 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6450 /* If the LEN parameter is zero, return DEST. */
6451 if (integer_zerop (len))
6452 return omit_one_operand (TREE_TYPE (exp), dest, src);
6457 /* Fold function call to builtin memcmp. Return
6458 NULL_TREE if no simplification can be made. */
6461 fold_builtin_memcmp (tree exp)
6463 tree arglist = TREE_OPERAND (exp, 1);
6464 tree arg1, arg2, len;
6466 if (!validate_arglist (arglist,
6467 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6470 arg1 = TREE_VALUE (arglist);
6471 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6472 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6474 /* If the LEN parameter is zero, return zero. */
6475 if (integer_zerop (len))
6477 tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
6478 return omit_one_operand (TREE_TYPE (exp), temp, arg1);
6481 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6482 if (operand_equal_p (arg1, arg2, 0))
6483 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
6488 /* Fold function call to builtin strcmp. Return
6489 NULL_TREE if no simplification can be made. */
6492 fold_builtin_strcmp (tree exp)
6494 tree arglist = TREE_OPERAND (exp, 1);
6496 const char *p1, *p2;
6498 if (!validate_arglist (arglist,
6499 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6502 arg1 = TREE_VALUE (arglist);
6503 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6505 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6506 if (operand_equal_p (arg1, arg2, 0))
6507 return convert (TREE_TYPE (exp), integer_zero_node);
6509 p1 = c_getstr (arg1);
6510 p2 = c_getstr (arg2);
6515 const int i = strcmp (p1, p2);
6517 temp = integer_minus_one_node;
6519 temp = integer_one_node;
6521 temp = integer_zero_node;
6522 return convert (TREE_TYPE (exp), temp);
6528 /* Fold function call to builtin strncmp. Return
6529 NULL_TREE if no simplification can be made. */
6532 fold_builtin_strncmp (tree exp)
6534 tree arglist = TREE_OPERAND (exp, 1);
6535 tree arg1, arg2, len;
6536 const char *p1, *p2;
6538 if (!validate_arglist (arglist,
6539 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6542 arg1 = TREE_VALUE (arglist);
6543 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6544 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6546 /* If the LEN parameter is zero, return zero. */
6547 if (integer_zerop (len))
6549 tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
6550 return omit_one_operand (TREE_TYPE (exp), temp, arg1);
6553 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6554 if (operand_equal_p (arg1, arg2, 0))
6555 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
6557 p1 = c_getstr (arg1);
6558 p2 = c_getstr (arg2);
6560 if (host_integerp (len, 1) && p1 && p2)
6563 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
6565 temp = integer_minus_one_node;
6567 temp = integer_one_node;
6569 temp = integer_zero_node;
6570 return convert (TREE_TYPE (exp), temp);
6576 /* Fold function call to builtin signbit, signbitf or signbitl. Return
6577 NULL_TREE if no simplification can be made. */
6580 fold_builtin_signbit (tree exp)
6582 tree arglist = TREE_OPERAND (exp, 1);
6585 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6588 arg = TREE_VALUE (arglist);
6590 /* If ARG is a compile-time constant, determine the result. */
6591 if (TREE_CODE (arg) == REAL_CST
6592 && !TREE_CONSTANT_OVERFLOW (arg))
6596 c = TREE_REAL_CST (arg);
6597 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
6598 return convert (TREE_TYPE (exp), temp);
6601 /* If ARG is non-negative, the result is always zero. */
6602 if (tree_expr_nonnegative_p (arg))
6603 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg);
6605 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
6606 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
6607 return fold (build (LT_EXPR, TREE_TYPE (exp), arg,
6608 build_real (TREE_TYPE (arg), dconst0)));
6614 /* Used by constant folding to eliminate some builtin calls early. EXP is
6615 the CALL_EXPR of a call to a builtin function. */
6618 fold_builtin (tree exp)
6620 tree fndecl = get_callee_fndecl (exp);
6621 tree arglist = TREE_OPERAND (exp, 1);
6622 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6624 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6627 switch (DECL_FUNCTION_CODE (fndecl))
6629 case BUILT_IN_CONSTANT_P:
6630 return fold_builtin_constant_p (arglist);
6632 case BUILT_IN_CLASSIFY_TYPE:
6633 return fold_builtin_classify_type (arglist);
6635 case BUILT_IN_STRLEN:
6636 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6638 tree len = c_strlen (TREE_VALUE (arglist), 0);
6641 /* Convert from the internal "sizetype" type to "size_t". */
6643 len = convert (size_type_node, len);
6650 case BUILT_IN_FABSF:
6651 case BUILT_IN_FABSL:
6652 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6653 return fold (build1 (ABS_EXPR, type, TREE_VALUE (arglist)));
6657 case BUILT_IN_CABSF:
6658 case BUILT_IN_CABSL:
6659 return fold_builtin_cabs (fndecl, arglist, type);
6662 case BUILT_IN_SQRTF:
6663 case BUILT_IN_SQRTL:
6664 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6666 enum built_in_function fcode;
6667 tree arg = TREE_VALUE (arglist);
6669 /* Optimize sqrt of constant value. */
6670 if (TREE_CODE (arg) == REAL_CST
6671 && ! TREE_CONSTANT_OVERFLOW (arg))
6673 REAL_VALUE_TYPE r, x;
6675 x = TREE_REAL_CST (arg);
6676 if (real_sqrt (&r, TYPE_MODE (type), &x)
6677 || (!flag_trapping_math && !flag_errno_math))
6678 return build_real (type, r);
6681 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6682 fcode = builtin_mathfn_code (arg);
6683 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
6685 tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6686 arg = fold (build (MULT_EXPR, type,
6687 TREE_VALUE (TREE_OPERAND (arg, 1)),
6688 build_real (type, dconsthalf)));
6689 arglist = build_tree_list (NULL_TREE, arg);
6690 return build_function_call_expr (expfn, arglist);
6693 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
6694 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
6696 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
6700 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6702 /* The inner root was either sqrt or cbrt. */
6703 REAL_VALUE_TYPE dconstroot =
6704 BUILTIN_SQRT_P (fcode) ? dconsthalf : dconstthird;
6706 /* Adjust for the outer root. */
6707 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
6708 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
6709 tree_root = build_real (type, dconstroot);
6710 arglist = tree_cons (NULL_TREE, arg0,
6711 build_tree_list (NULL_TREE, tree_root));
6712 return build_function_call_expr (powfn, arglist);
6716 /* Optimize sqrt(pow(x,y)) = pow(x,y*0.5). */
6717 if (flag_unsafe_math_optimizations
6718 && (fcode == BUILT_IN_POW
6719 || fcode == BUILT_IN_POWF
6720 || fcode == BUILT_IN_POWL))
6722 tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6723 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6724 tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6725 tree narg1 = fold (build (MULT_EXPR, type, arg1,
6726 build_real (type, dconsthalf)));
6727 arglist = tree_cons (NULL_TREE, arg0,
6728 build_tree_list (NULL_TREE, narg1));
6729 return build_function_call_expr (powfn, arglist);
6735 case BUILT_IN_CBRTF:
6736 case BUILT_IN_CBRTL:
6737 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6739 tree arg = TREE_VALUE (arglist);
6740 const enum built_in_function fcode = builtin_mathfn_code (arg);
6742 /* Optimize cbrt of constant value. */
6743 if (real_zerop (arg) || real_onep (arg) || real_minus_onep (arg))
6746 /* Optimize cbrt(expN(x)) -> expN(x/3). */
6747 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
6749 tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6750 const REAL_VALUE_TYPE third_trunc =
6751 real_value_truncate (TYPE_MODE (type), dconstthird);
6752 arg = fold (build (MULT_EXPR, type,
6753 TREE_VALUE (TREE_OPERAND (arg, 1)),
6754 build_real (type, third_trunc)));
6755 arglist = build_tree_list (NULL_TREE, arg);
6756 return build_function_call_expr (expfn, arglist);
6759 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
6760 /* We don't optimize cbrt(cbrt(x)) -> pow(x,1/9) because if
6761 x is negative pow will error but cbrt won't. */
6762 if (flag_unsafe_math_optimizations && BUILTIN_SQRT_P (fcode))
6764 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
6768 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6770 REAL_VALUE_TYPE dconstroot = dconstthird;
6772 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
6773 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
6774 tree_root = build_real (type, dconstroot);
6775 arglist = tree_cons (NULL_TREE, arg0,
6776 build_tree_list (NULL_TREE, tree_root));
6777 return build_function_call_expr (powfn, arglist);
6787 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6789 tree arg = TREE_VALUE (arglist);
6791 /* Optimize sin(0.0) = 0.0. */
6792 if (real_zerop (arg))
6800 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6802 tree arg = TREE_VALUE (arglist);
6804 /* Optimize cos(0.0) = 1.0. */
6805 if (real_zerop (arg))
6806 return build_real (type, dconst1);
6808 /* Optimize cos(-x) into cos(x). */
6809 if (TREE_CODE (arg) == NEGATE_EXPR)
6811 tree arglist = build_tree_list (NULL_TREE,
6812 TREE_OPERAND (arg, 0));
6813 return build_function_call_expr (fndecl, arglist);
6821 return fold_builtin_exponent (exp, &dconste);
6823 case BUILT_IN_EXP2F:
6824 case BUILT_IN_EXP2L:
6825 return fold_builtin_exponent (exp, &dconst2);
6826 case BUILT_IN_EXP10:
6827 case BUILT_IN_EXP10F:
6828 case BUILT_IN_EXP10L:
6829 case BUILT_IN_POW10:
6830 case BUILT_IN_POW10F:
6831 case BUILT_IN_POW10L:
6832 return fold_builtin_exponent (exp, &dconst10);
6836 return fold_builtin_logarithm (exp, &dconste);
6839 case BUILT_IN_LOG2F:
6840 case BUILT_IN_LOG2L:
6841 return fold_builtin_logarithm (exp, &dconst2);
6843 case BUILT_IN_LOG10:
6844 case BUILT_IN_LOG10F:
6845 case BUILT_IN_LOG10L:
6846 return fold_builtin_logarithm (exp, &dconst10);
6852 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6854 enum built_in_function fcode;
6855 tree arg = TREE_VALUE (arglist);
6857 /* Optimize tan(0.0) = 0.0. */
6858 if (real_zerop (arg))
6861 /* Optimize tan(atan(x)) = x. */
6862 fcode = builtin_mathfn_code (arg);
6863 if (flag_unsafe_math_optimizations
6864 && (fcode == BUILT_IN_ATAN
6865 || fcode == BUILT_IN_ATANF
6866 || fcode == BUILT_IN_ATANL))
6867 return TREE_VALUE (TREE_OPERAND (arg, 1));
6872 case BUILT_IN_ATANF:
6873 case BUILT_IN_ATANL:
6874 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6876 tree arg = TREE_VALUE (arglist);
6878 /* Optimize atan(0.0) = 0.0. */
6879 if (real_zerop (arg))
6882 /* Optimize atan(1.0) = pi/4. */
6883 if (real_onep (arg))
6885 REAL_VALUE_TYPE cst;
6887 real_convert (&cst, TYPE_MODE (type), &dconstpi);
6888 SET_REAL_EXP (&cst, REAL_EXP (&cst) - 2);
6889 return build_real (type, cst);
6897 if (validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
6899 enum built_in_function fcode;
6900 tree arg0 = TREE_VALUE (arglist);
6901 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
6903 /* Optimize pow(1.0,y) = 1.0. */
6904 if (real_onep (arg0))
6905 return omit_one_operand (type, build_real (type, dconst1), arg1);
6907 if (TREE_CODE (arg1) == REAL_CST
6908 && ! TREE_CONSTANT_OVERFLOW (arg1))
6911 c = TREE_REAL_CST (arg1);
6913 /* Optimize pow(x,0.0) = 1.0. */
6914 if (REAL_VALUES_EQUAL (c, dconst0))
6915 return omit_one_operand (type, build_real (type, dconst1),
6918 /* Optimize pow(x,1.0) = x. */
6919 if (REAL_VALUES_EQUAL (c, dconst1))
6922 /* Optimize pow(x,-1.0) = 1.0/x. */
6923 if (REAL_VALUES_EQUAL (c, dconstm1))
6924 return fold (build (RDIV_EXPR, type,
6925 build_real (type, dconst1),
6928 /* Optimize pow(x,0.5) = sqrt(x). */
6929 if (flag_unsafe_math_optimizations
6930 && REAL_VALUES_EQUAL (c, dconsthalf))
6934 fcode = DECL_FUNCTION_CODE (fndecl);
6935 if (fcode == BUILT_IN_POW)
6936 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
6937 else if (fcode == BUILT_IN_POWF)
6938 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
6939 else if (fcode == BUILT_IN_POWL)
6940 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
6944 if (sqrtfn != NULL_TREE)
6946 tree arglist = build_tree_list (NULL_TREE, arg0);
6947 return build_function_call_expr (sqrtfn, arglist);
6951 /* Attempt to evaluate pow at compile-time. */
6952 if (TREE_CODE (arg0) == REAL_CST
6953 && ! TREE_CONSTANT_OVERFLOW (arg0))
6955 REAL_VALUE_TYPE cint;
6958 n = real_to_integer (&c);
6959 real_from_integer (&cint, VOIDmode, n,
6961 if (real_identical (&c, &cint))
6966 x = TREE_REAL_CST (arg0);
6967 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
6968 if (flag_unsafe_math_optimizations || !inexact)
6969 return build_real (type, x);
6974 /* Optimize pow(expN(x),y) = expN(x*y). */
6975 fcode = builtin_mathfn_code (arg0);
6976 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
6978 tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6979 tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
6980 arg = fold (build (MULT_EXPR, type, arg, arg1));
6981 arglist = build_tree_list (NULL_TREE, arg);
6982 return build_function_call_expr (expfn, arglist);
6985 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
6986 if (flag_unsafe_math_optimizations && BUILTIN_SQRT_P (fcode))
6988 tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
6989 tree narg1 = fold (build (MULT_EXPR, type, arg1,
6990 build_real (type, dconsthalf)));
6992 arglist = tree_cons (NULL_TREE, narg0,
6993 build_tree_list (NULL_TREE, narg1));
6994 return build_function_call_expr (fndecl, arglist);
6997 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
6998 if (flag_unsafe_math_optimizations
6999 && (fcode == BUILT_IN_POW
7000 || fcode == BUILT_IN_POWF
7001 || fcode == BUILT_IN_POWL))
7003 tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7004 tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7005 tree narg1 = fold (build (MULT_EXPR, type, arg01, arg1));
7006 arglist = tree_cons (NULL_TREE, arg00,
7007 build_tree_list (NULL_TREE, narg1));
7008 return build_function_call_expr (fndecl, arglist);
7016 return fold_builtin_inf (type, true);
7018 case BUILT_IN_HUGE_VAL:
7019 case BUILT_IN_HUGE_VALF:
7020 case BUILT_IN_HUGE_VALL:
7021 return fold_builtin_inf (type, false);
7026 return fold_builtin_nan (arglist, type, true);
7029 case BUILT_IN_NANSF:
7030 case BUILT_IN_NANSL:
7031 return fold_builtin_nan (arglist, type, false);
7033 case BUILT_IN_FLOOR:
7034 case BUILT_IN_FLOORF:
7035 case BUILT_IN_FLOORL:
7036 return fold_builtin_floor (exp);
7039 case BUILT_IN_CEILF:
7040 case BUILT_IN_CEILL:
7041 return fold_builtin_ceil (exp);
7043 case BUILT_IN_TRUNC:
7044 case BUILT_IN_TRUNCF:
7045 case BUILT_IN_TRUNCL:
7046 return fold_builtin_trunc (exp);
7048 case BUILT_IN_ROUND:
7049 case BUILT_IN_ROUNDF:
7050 case BUILT_IN_ROUNDL:
7051 return fold_builtin_round (exp);
7053 case BUILT_IN_NEARBYINT:
7054 case BUILT_IN_NEARBYINTF:
7055 case BUILT_IN_NEARBYINTL:
7057 case BUILT_IN_RINTF:
7058 case BUILT_IN_RINTL:
7059 return fold_trunc_transparent_mathfn (exp);
7063 case BUILT_IN_FFSLL:
7066 case BUILT_IN_CLZLL:
7069 case BUILT_IN_CTZLL:
7070 case BUILT_IN_POPCOUNT:
7071 case BUILT_IN_POPCOUNTL:
7072 case BUILT_IN_POPCOUNTLL:
7073 case BUILT_IN_PARITY:
7074 case BUILT_IN_PARITYL:
7075 case BUILT_IN_PARITYLL:
7076 return fold_builtin_bitop (exp);
7078 case BUILT_IN_MEMCPY:
7079 return fold_builtin_memcpy (exp);
7081 case BUILT_IN_MEMPCPY:
7082 return fold_builtin_mempcpy (exp);
7084 case BUILT_IN_MEMMOVE:
7085 return fold_builtin_memmove (exp);
7087 case BUILT_IN_STRCPY:
7088 return fold_builtin_strcpy (exp);
7090 case BUILT_IN_STRNCPY:
7091 return fold_builtin_strncpy (exp);
7093 case BUILT_IN_MEMCMP:
7094 return fold_builtin_memcmp (exp);
7096 case BUILT_IN_STRCMP:
7097 return fold_builtin_strcmp (exp);
7099 case BUILT_IN_STRNCMP:
7100 return fold_builtin_strncmp (exp);
7102 case BUILT_IN_SIGNBIT:
7103 case BUILT_IN_SIGNBITF:
7104 case BUILT_IN_SIGNBITL:
7105 return fold_builtin_signbit (exp);
7114 /* Conveniently construct a function call expression. */
7117 build_function_call_expr (tree fn, tree arglist)
7121 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
7122 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
7123 call_expr, arglist);
7124 return fold (call_expr);
7127 /* This function validates the types of a function call argument list
7128 represented as a tree chain of parameters against a specified list
7129 of tree_codes. If the last specifier is a 0, that represents an
7130 ellipses, otherwise the last specifier must be a VOID_TYPE. */
7133 validate_arglist (tree arglist, ...)
7135 enum tree_code code;
7139 va_start (ap, arglist);
7143 code = va_arg (ap, enum tree_code);
7147 /* This signifies an ellipses, any further arguments are all ok. */
7151 /* This signifies an endlink, if no arguments remain, return
7152 true, otherwise return false. */
7156 /* If no parameters remain or the parameter's code does not
7157 match the specified code, return false. Otherwise continue
7158 checking any remaining arguments. */
7160 || code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
7164 arglist = TREE_CHAIN (arglist);
7168 /* We need gotos here since we can only have one VA_CLOSE in a
7176 /* Default target-specific builtin expander that does nothing. */
7179 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
7180 rtx target ATTRIBUTE_UNUSED,
7181 rtx subtarget ATTRIBUTE_UNUSED,
7182 enum machine_mode mode ATTRIBUTE_UNUSED,
7183 int ignore ATTRIBUTE_UNUSED)
7188 /* Instantiate all remaining CONSTANT_P_RTX nodes. */
7191 purge_builtin_constant_p (void)
7193 rtx insn, set, arg, new, note;
7195 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
7197 && (set = single_set (insn)) != NULL_RTX
7198 && (GET_CODE (arg = SET_SRC (set)) == CONSTANT_P_RTX
7199 || (GET_CODE (arg) == SUBREG
7200 && (GET_CODE (arg = SUBREG_REG (arg))
7201 == CONSTANT_P_RTX))))
7203 arg = XEXP (arg, 0);
7204 new = CONSTANT_P (arg) ? const1_rtx : const0_rtx;
7205 validate_change (insn, &SET_SRC (set), new, 0);
7207 /* Remove the REG_EQUAL note from the insn. */
7208 if ((note = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
7209 remove_note (insn, note);
7213 /* Returns true is EXP represents data that would potentially reside
7214 in a readonly section. */
7217 readonly_data_expr (tree exp)
7221 if (TREE_CODE (exp) == ADDR_EXPR)
7222 return decl_readonly_section (TREE_OPERAND (exp, 0), 0);