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 /* Search for the proper mode for copying this register's
908 value. I'm not sure this is right, but it works so far. */
909 enum machine_mode best_mode = VOIDmode;
911 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
913 mode = GET_MODE_WIDER_MODE (mode))
914 if (HARD_REGNO_MODE_OK (regno, mode)
915 && hard_regno_nregs[regno][mode] == 1)
918 if (best_mode == VOIDmode)
919 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
921 mode = GET_MODE_WIDER_MODE (mode))
922 if (HARD_REGNO_MODE_OK (regno, mode)
923 && have_insn_for (SET, mode))
926 if (best_mode == VOIDmode)
927 for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
929 mode = GET_MODE_WIDER_MODE (mode))
930 if (HARD_REGNO_MODE_OK (regno, mode)
931 && have_insn_for (SET, mode))
934 if (best_mode == VOIDmode)
935 for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
937 mode = GET_MODE_WIDER_MODE (mode))
938 if (HARD_REGNO_MODE_OK (regno, mode)
939 && have_insn_for (SET, mode))
943 if (mode == VOIDmode)
946 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
947 if (size % align != 0)
948 size = CEIL (size, align) * align;
949 apply_args_reg_offset[regno] = size;
950 size += GET_MODE_SIZE (mode);
951 apply_args_mode[regno] = mode;
955 apply_args_mode[regno] = VOIDmode;
956 apply_args_reg_offset[regno] = 0;
962 /* Return the size required for the block returned by __builtin_apply,
963 and initialize apply_result_mode. */
966 apply_result_size (void)
968 static int size = -1;
970 enum machine_mode mode;
972 /* The values computed by this function never change. */
977 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
978 if (FUNCTION_VALUE_REGNO_P (regno))
980 /* Search for the proper mode for copying this register's
981 value. I'm not sure this is right, but it works so far. */
982 enum machine_mode best_mode = VOIDmode;
984 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
986 mode = GET_MODE_WIDER_MODE (mode))
987 if (HARD_REGNO_MODE_OK (regno, mode))
990 if (best_mode == VOIDmode)
991 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
993 mode = GET_MODE_WIDER_MODE (mode))
994 if (HARD_REGNO_MODE_OK (regno, mode)
995 && have_insn_for (SET, mode))
998 if (best_mode == VOIDmode)
999 for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
1001 mode = GET_MODE_WIDER_MODE (mode))
1002 if (HARD_REGNO_MODE_OK (regno, mode)
1003 && have_insn_for (SET, mode))
1006 if (best_mode == VOIDmode)
1007 for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
1009 mode = GET_MODE_WIDER_MODE (mode))
1010 if (HARD_REGNO_MODE_OK (regno, mode)
1011 && have_insn_for (SET, mode))
1015 if (mode == VOIDmode)
1018 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1019 if (size % align != 0)
1020 size = CEIL (size, align) * align;
1021 size += GET_MODE_SIZE (mode);
1022 apply_result_mode[regno] = mode;
1025 apply_result_mode[regno] = VOIDmode;
1027 /* Allow targets that use untyped_call and untyped_return to override
1028 the size so that machine-specific information can be stored here. */
1029 #ifdef APPLY_RESULT_SIZE
1030 size = APPLY_RESULT_SIZE;
1036 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1037 /* Create a vector describing the result block RESULT. If SAVEP is true,
1038 the result block is used to save the values; otherwise it is used to
1039 restore the values. */
1042 result_vector (int savep, rtx result)
1044 int regno, size, align, nelts;
1045 enum machine_mode mode;
1047 rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1050 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1051 if ((mode = apply_result_mode[regno]) != VOIDmode)
1053 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1054 if (size % align != 0)
1055 size = CEIL (size, align) * align;
1056 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1057 mem = adjust_address (result, mode, size);
1058 savevec[nelts++] = (savep
1059 ? gen_rtx_SET (VOIDmode, mem, reg)
1060 : gen_rtx_SET (VOIDmode, reg, mem));
1061 size += GET_MODE_SIZE (mode);
1063 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1065 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1067 /* Save the state required to perform an untyped call with the same
1068 arguments as were passed to the current function. */
1071 expand_builtin_apply_args_1 (void)
1074 int size, align, regno;
1075 enum machine_mode mode;
1076 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1078 /* Create a block where the arg-pointer, structure value address,
1079 and argument registers can be saved. */
1080 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1082 /* Walk past the arg-pointer and structure value address. */
1083 size = GET_MODE_SIZE (Pmode);
1084 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1085 size += GET_MODE_SIZE (Pmode);
1087 /* Save each register used in calling a function to the block. */
1088 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1089 if ((mode = apply_args_mode[regno]) != VOIDmode)
1091 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1092 if (size % align != 0)
1093 size = CEIL (size, align) * align;
1095 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1097 emit_move_insn (adjust_address (registers, mode, size), tem);
1098 size += GET_MODE_SIZE (mode);
1101 /* Save the arg pointer to the block. */
1102 tem = copy_to_reg (virtual_incoming_args_rtx);
1103 #ifdef STACK_GROWS_DOWNWARD
1104 /* We need the pointer as the caller actually passed them to us, not
1105 as we might have pretended they were passed. Make sure it's a valid
1106 operand, as emit_move_insn isn't expected to handle a PLUS. */
1108 = force_operand (plus_constant (tem, current_function_pretend_args_size),
1111 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1113 size = GET_MODE_SIZE (Pmode);
1115 /* Save the structure value address unless this is passed as an
1116 "invisible" first argument. */
1117 if (struct_incoming_value)
1119 emit_move_insn (adjust_address (registers, Pmode, size),
1120 copy_to_reg (struct_incoming_value));
1121 size += GET_MODE_SIZE (Pmode);
1124 /* Return the address of the block. */
1125 return copy_addr_to_reg (XEXP (registers, 0));
1128 /* __builtin_apply_args returns block of memory allocated on
1129 the stack into which is stored the arg pointer, structure
1130 value address, static chain, and all the registers that might
1131 possibly be used in performing a function call. The code is
1132 moved to the start of the function so the incoming values are
1136 expand_builtin_apply_args (void)
1138 /* Don't do __builtin_apply_args more than once in a function.
1139 Save the result of the first call and reuse it. */
1140 if (apply_args_value != 0)
1141 return apply_args_value;
1143 /* When this function is called, it means that registers must be
1144 saved on entry to this function. So we migrate the
1145 call to the first insn of this function. */
1150 temp = expand_builtin_apply_args_1 ();
1154 apply_args_value = temp;
1156 /* Put the insns after the NOTE that starts the function.
1157 If this is inside a start_sequence, make the outer-level insn
1158 chain current, so the code is placed at the start of the
1160 push_topmost_sequence ();
1161 emit_insn_before (seq, NEXT_INSN (get_insns ()));
1162 pop_topmost_sequence ();
1167 /* Perform an untyped call and save the state required to perform an
1168 untyped return of whatever value was returned by the given function. */
1171 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1173 int size, align, regno;
1174 enum machine_mode mode;
1175 rtx incoming_args, result, reg, dest, src, call_insn;
1176 rtx old_stack_level = 0;
1177 rtx call_fusage = 0;
1178 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1180 arguments = convert_memory_address (Pmode, arguments);
1182 /* Create a block where the return registers can be saved. */
1183 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1185 /* Fetch the arg pointer from the ARGUMENTS block. */
1186 incoming_args = gen_reg_rtx (Pmode);
1187 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1188 #ifndef STACK_GROWS_DOWNWARD
1189 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1190 incoming_args, 0, OPTAB_LIB_WIDEN);
1193 /* Perform postincrements before actually calling the function. */
1196 /* Push a new argument block and copy the arguments. Do not allow
1197 the (potential) memcpy call below to interfere with our stack
1199 do_pending_stack_adjust ();
1202 /* Save the stack with nonlocal if available. */
1203 #ifdef HAVE_save_stack_nonlocal
1204 if (HAVE_save_stack_nonlocal)
1205 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1208 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1210 /* Allocate a block of memory onto the stack and copy the memory
1211 arguments to the outgoing arguments address. */
1212 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1213 dest = virtual_outgoing_args_rtx;
1214 #ifndef STACK_GROWS_DOWNWARD
1215 if (GET_CODE (argsize) == CONST_INT)
1216 dest = plus_constant (dest, -INTVAL (argsize));
1218 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1220 dest = gen_rtx_MEM (BLKmode, dest);
1221 set_mem_align (dest, PARM_BOUNDARY);
1222 src = gen_rtx_MEM (BLKmode, incoming_args);
1223 set_mem_align (src, PARM_BOUNDARY);
1224 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1226 /* Refer to the argument block. */
1228 arguments = gen_rtx_MEM (BLKmode, arguments);
1229 set_mem_align (arguments, PARM_BOUNDARY);
1231 /* Walk past the arg-pointer and structure value address. */
1232 size = GET_MODE_SIZE (Pmode);
1234 size += GET_MODE_SIZE (Pmode);
1236 /* Restore each of the registers previously saved. Make USE insns
1237 for each of these registers for use in making the call. */
1238 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1239 if ((mode = apply_args_mode[regno]) != VOIDmode)
1241 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1242 if (size % align != 0)
1243 size = CEIL (size, align) * align;
1244 reg = gen_rtx_REG (mode, regno);
1245 emit_move_insn (reg, adjust_address (arguments, mode, size));
1246 use_reg (&call_fusage, reg);
1247 size += GET_MODE_SIZE (mode);
1250 /* Restore the structure value address unless this is passed as an
1251 "invisible" first argument. */
1252 size = GET_MODE_SIZE (Pmode);
1255 rtx value = gen_reg_rtx (Pmode);
1256 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1257 emit_move_insn (struct_value, value);
1258 if (GET_CODE (struct_value) == REG)
1259 use_reg (&call_fusage, struct_value);
1260 size += GET_MODE_SIZE (Pmode);
1263 /* All arguments and registers used for the call are set up by now! */
1264 function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
1266 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1267 and we don't want to load it into a register as an optimization,
1268 because prepare_call_address already did it if it should be done. */
1269 if (GET_CODE (function) != SYMBOL_REF)
1270 function = memory_address (FUNCTION_MODE, function);
1272 /* Generate the actual call instruction and save the return value. */
1273 #ifdef HAVE_untyped_call
1274 if (HAVE_untyped_call)
1275 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1276 result, result_vector (1, result)));
1279 #ifdef HAVE_call_value
1280 if (HAVE_call_value)
1284 /* Locate the unique return register. It is not possible to
1285 express a call that sets more than one return register using
1286 call_value; use untyped_call for that. In fact, untyped_call
1287 only needs to save the return registers in the given block. */
1288 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1289 if ((mode = apply_result_mode[regno]) != VOIDmode)
1292 abort (); /* HAVE_untyped_call required. */
1293 valreg = gen_rtx_REG (mode, regno);
1296 emit_call_insn (GEN_CALL_VALUE (valreg,
1297 gen_rtx_MEM (FUNCTION_MODE, function),
1298 const0_rtx, NULL_RTX, const0_rtx));
1300 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1306 /* Find the CALL insn we just emitted, and attach the register usage
1308 call_insn = last_call_insn ();
1309 add_function_usage_to (call_insn, call_fusage);
1311 /* Restore the stack. */
1312 #ifdef HAVE_save_stack_nonlocal
1313 if (HAVE_save_stack_nonlocal)
1314 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1317 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1321 /* Return the address of the result block. */
1322 result = copy_addr_to_reg (XEXP (result, 0));
1323 return convert_memory_address (ptr_mode, result);
1326 /* Perform an untyped return. */
1329 expand_builtin_return (rtx result)
1331 int size, align, regno;
1332 enum machine_mode mode;
1334 rtx call_fusage = 0;
1336 result = convert_memory_address (Pmode, result);
1338 apply_result_size ();
1339 result = gen_rtx_MEM (BLKmode, result);
1341 #ifdef HAVE_untyped_return
1342 if (HAVE_untyped_return)
1344 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1350 /* Restore the return value and note that each value is used. */
1352 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1353 if ((mode = apply_result_mode[regno]) != VOIDmode)
1355 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1356 if (size % align != 0)
1357 size = CEIL (size, align) * align;
1358 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1359 emit_move_insn (reg, adjust_address (result, mode, size));
1361 push_to_sequence (call_fusage);
1362 emit_insn (gen_rtx_USE (VOIDmode, reg));
1363 call_fusage = get_insns ();
1365 size += GET_MODE_SIZE (mode);
1368 /* Put the USE insns before the return. */
1369 emit_insn (call_fusage);
1371 /* Return whatever values was restored by jumping directly to the end
1373 expand_naked_return ();
1376 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1378 static enum type_class
1379 type_to_class (tree type)
1381 switch (TREE_CODE (type))
1383 case VOID_TYPE: return void_type_class;
1384 case INTEGER_TYPE: return integer_type_class;
1385 case CHAR_TYPE: return char_type_class;
1386 case ENUMERAL_TYPE: return enumeral_type_class;
1387 case BOOLEAN_TYPE: return boolean_type_class;
1388 case POINTER_TYPE: return pointer_type_class;
1389 case REFERENCE_TYPE: return reference_type_class;
1390 case OFFSET_TYPE: return offset_type_class;
1391 case REAL_TYPE: return real_type_class;
1392 case COMPLEX_TYPE: return complex_type_class;
1393 case FUNCTION_TYPE: return function_type_class;
1394 case METHOD_TYPE: return method_type_class;
1395 case RECORD_TYPE: return record_type_class;
1397 case QUAL_UNION_TYPE: return union_type_class;
1398 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1399 ? string_type_class : array_type_class);
1400 case SET_TYPE: return set_type_class;
1401 case FILE_TYPE: return file_type_class;
1402 case LANG_TYPE: return lang_type_class;
1403 default: return no_type_class;
1407 /* Expand a call to __builtin_classify_type with arguments found in
1411 expand_builtin_classify_type (tree arglist)
1414 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1415 return GEN_INT (no_type_class);
1418 /* Expand expression EXP, which is a call to __builtin_constant_p. */
1421 expand_builtin_constant_p (tree arglist, enum machine_mode target_mode)
1427 arglist = TREE_VALUE (arglist);
1429 /* We have taken care of the easy cases during constant folding. This
1430 case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE
1431 get a chance to see if it can deduce whether ARGLIST is constant.
1432 If CSE isn't going to run, of course, don't bother waiting. */
1434 if (cse_not_expected)
1437 current_function_calls_constant_p = 1;
1439 tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);
1440 tmp = gen_rtx_CONSTANT_P_RTX (target_mode, tmp);
1444 /* This helper macro, meant to be used in mathfn_built_in below,
1445 determines which among a set of three builtin math functions is
1446 appropriate for a given type mode. The `F' and `L' cases are
1447 automatically generated from the `double' case. */
1448 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1449 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1450 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1451 fcodel = BUILT_IN_MATHFN##L ; break;
1453 /* Return mathematic function equivalent to FN but operating directly
1454 on TYPE, if available. If we can't do the conversion, return zero. */
1456 mathfn_built_in (tree type, enum built_in_function fn)
1458 const enum machine_mode type_mode = TYPE_MODE (type);
1459 enum built_in_function fcode, fcodef, fcodel;
1463 CASE_MATHFN (BUILT_IN_ACOS)
1464 CASE_MATHFN (BUILT_IN_ACOSH)
1465 CASE_MATHFN (BUILT_IN_ASIN)
1466 CASE_MATHFN (BUILT_IN_ASINH)
1467 CASE_MATHFN (BUILT_IN_ATAN)
1468 CASE_MATHFN (BUILT_IN_ATAN2)
1469 CASE_MATHFN (BUILT_IN_ATANH)
1470 CASE_MATHFN (BUILT_IN_CBRT)
1471 CASE_MATHFN (BUILT_IN_CEIL)
1472 CASE_MATHFN (BUILT_IN_COPYSIGN)
1473 CASE_MATHFN (BUILT_IN_COS)
1474 CASE_MATHFN (BUILT_IN_COSH)
1475 CASE_MATHFN (BUILT_IN_DREM)
1476 CASE_MATHFN (BUILT_IN_ERF)
1477 CASE_MATHFN (BUILT_IN_ERFC)
1478 CASE_MATHFN (BUILT_IN_EXP)
1479 CASE_MATHFN (BUILT_IN_EXP10)
1480 CASE_MATHFN (BUILT_IN_EXP2)
1481 CASE_MATHFN (BUILT_IN_EXPM1)
1482 CASE_MATHFN (BUILT_IN_FABS)
1483 CASE_MATHFN (BUILT_IN_FDIM)
1484 CASE_MATHFN (BUILT_IN_FLOOR)
1485 CASE_MATHFN (BUILT_IN_FMA)
1486 CASE_MATHFN (BUILT_IN_FMAX)
1487 CASE_MATHFN (BUILT_IN_FMIN)
1488 CASE_MATHFN (BUILT_IN_FMOD)
1489 CASE_MATHFN (BUILT_IN_FREXP)
1490 CASE_MATHFN (BUILT_IN_GAMMA)
1491 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1492 CASE_MATHFN (BUILT_IN_HYPOT)
1493 CASE_MATHFN (BUILT_IN_ILOGB)
1494 CASE_MATHFN (BUILT_IN_INF)
1495 CASE_MATHFN (BUILT_IN_J0)
1496 CASE_MATHFN (BUILT_IN_J1)
1497 CASE_MATHFN (BUILT_IN_JN)
1498 CASE_MATHFN (BUILT_IN_LDEXP)
1499 CASE_MATHFN (BUILT_IN_LGAMMA)
1500 CASE_MATHFN (BUILT_IN_LLRINT)
1501 CASE_MATHFN (BUILT_IN_LLROUND)
1502 CASE_MATHFN (BUILT_IN_LOG)
1503 CASE_MATHFN (BUILT_IN_LOG10)
1504 CASE_MATHFN (BUILT_IN_LOG1P)
1505 CASE_MATHFN (BUILT_IN_LOG2)
1506 CASE_MATHFN (BUILT_IN_LOGB)
1507 CASE_MATHFN (BUILT_IN_LRINT)
1508 CASE_MATHFN (BUILT_IN_LROUND)
1509 CASE_MATHFN (BUILT_IN_MODF)
1510 CASE_MATHFN (BUILT_IN_NAN)
1511 CASE_MATHFN (BUILT_IN_NANS)
1512 CASE_MATHFN (BUILT_IN_NEARBYINT)
1513 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1514 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1515 CASE_MATHFN (BUILT_IN_POW)
1516 CASE_MATHFN (BUILT_IN_POW10)
1517 CASE_MATHFN (BUILT_IN_REMAINDER)
1518 CASE_MATHFN (BUILT_IN_REMQUO)
1519 CASE_MATHFN (BUILT_IN_RINT)
1520 CASE_MATHFN (BUILT_IN_ROUND)
1521 CASE_MATHFN (BUILT_IN_SCALB)
1522 CASE_MATHFN (BUILT_IN_SCALBLN)
1523 CASE_MATHFN (BUILT_IN_SCALBN)
1524 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1525 CASE_MATHFN (BUILT_IN_SIN)
1526 CASE_MATHFN (BUILT_IN_SINCOS)
1527 CASE_MATHFN (BUILT_IN_SINH)
1528 CASE_MATHFN (BUILT_IN_SQRT)
1529 CASE_MATHFN (BUILT_IN_TAN)
1530 CASE_MATHFN (BUILT_IN_TANH)
1531 CASE_MATHFN (BUILT_IN_TGAMMA)
1532 CASE_MATHFN (BUILT_IN_TRUNC)
1533 CASE_MATHFN (BUILT_IN_Y0)
1534 CASE_MATHFN (BUILT_IN_Y1)
1535 CASE_MATHFN (BUILT_IN_YN)
1541 if (type_mode == TYPE_MODE (double_type_node))
1542 return implicit_built_in_decls[fcode];
1543 else if (type_mode == TYPE_MODE (float_type_node))
1544 return implicit_built_in_decls[fcodef];
1545 else if (type_mode == TYPE_MODE (long_double_type_node))
1546 return implicit_built_in_decls[fcodel];
1551 /* If errno must be maintained, expand the RTL to check if the result,
1552 TARGET, of a built-in function call, EXP, is NaN, and if so set
1556 expand_errno_check (tree exp, rtx target)
1558 rtx lab = gen_label_rtx ();
1560 /* Test the result; if it is NaN, set errno=EDOM because
1561 the argument was not in the domain. */
1562 emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1566 /* If this built-in doesn't throw an exception, set errno directly. */
1567 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
1569 #ifdef GEN_ERRNO_RTX
1570 rtx errno_rtx = GEN_ERRNO_RTX;
1573 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1575 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1581 /* We can't set errno=EDOM directly; let the library call do it.
1582 Pop the arguments right away in case the call gets deleted. */
1584 expand_call (exp, target, 0);
1590 /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
1591 Return 0 if a normal call should be emitted rather than expanding the
1592 function in-line. EXP is the expression that is a call to the builtin
1593 function; if convenient, the result should be placed in TARGET.
1594 SUBTARGET may be used as the target for computing one of EXP's operands. */
1597 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1599 optab builtin_optab;
1600 rtx op0, insns, before_call;
1601 tree fndecl = get_callee_fndecl (exp);
1602 tree arglist = TREE_OPERAND (exp, 1);
1603 enum machine_mode mode;
1604 bool errno_set = false;
1607 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1610 arg = TREE_VALUE (arglist);
1612 switch (DECL_FUNCTION_CODE (fndecl))
1617 builtin_optab = sin_optab; break;
1621 builtin_optab = cos_optab; break;
1623 case BUILT_IN_SQRTF:
1624 case BUILT_IN_SQRTL:
1625 errno_set = ! tree_expr_nonnegative_p (arg);
1626 builtin_optab = sqrt_optab;
1631 errno_set = true; builtin_optab = exp_optab; break;
1635 errno_set = true; builtin_optab = log_optab; break;
1636 case BUILT_IN_LOG10:
1637 case BUILT_IN_LOG10F:
1638 case BUILT_IN_LOG10L:
1639 errno_set = true; builtin_optab = log10_optab; break;
1641 case BUILT_IN_LOG2F:
1642 case BUILT_IN_LOG2L:
1643 errno_set = true; builtin_optab = log2_optab; break;
1647 builtin_optab = tan_optab; break;
1649 case BUILT_IN_ATANF:
1650 case BUILT_IN_ATANL:
1651 builtin_optab = atan_optab; break;
1652 case BUILT_IN_FLOOR:
1653 case BUILT_IN_FLOORF:
1654 case BUILT_IN_FLOORL:
1655 builtin_optab = floor_optab; break;
1657 case BUILT_IN_CEILF:
1658 case BUILT_IN_CEILL:
1659 builtin_optab = ceil_optab; break;
1660 case BUILT_IN_TRUNC:
1661 case BUILT_IN_TRUNCF:
1662 case BUILT_IN_TRUNCL:
1663 builtin_optab = btrunc_optab; break;
1664 case BUILT_IN_ROUND:
1665 case BUILT_IN_ROUNDF:
1666 case BUILT_IN_ROUNDL:
1667 builtin_optab = round_optab; break;
1668 case BUILT_IN_NEARBYINT:
1669 case BUILT_IN_NEARBYINTF:
1670 case BUILT_IN_NEARBYINTL:
1671 builtin_optab = nearbyint_optab; break;
1676 /* Make a suitable register to place result in. */
1677 mode = TYPE_MODE (TREE_TYPE (exp));
1679 if (! flag_errno_math || ! HONOR_NANS (mode))
1682 /* Before working hard, check whether the instruction is available. */
1683 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1685 target = gen_reg_rtx (mode);
1687 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1688 need to expand the argument again. This way, we will not perform
1689 side-effects more the once. */
1690 narg = save_expr (arg);
1693 arglist = build_tree_list (NULL_TREE, arg);
1694 exp = build_function_call_expr (fndecl, arglist);
1697 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1702 /* Compute into TARGET.
1703 Set TARGET to wherever the result comes back. */
1704 target = expand_unop (mode, builtin_optab, op0, target, 0);
1709 expand_errno_check (exp, target);
1711 /* Output the entire sequence. */
1712 insns = get_insns ();
1718 /* If we were unable to expand via the builtin, stop the sequence
1719 (without outputting the insns) and call to the library function
1720 with the stabilized argument list. */
1724 before_call = get_last_insn ();
1726 target = expand_call (exp, target, target == const0_rtx);
1728 /* If this is a sqrt operation and we don't care about errno, try to
1729 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1730 This allows the semantics of the libcall to be visible to the RTL
1732 if (builtin_optab == sqrt_optab && !errno_set)
1734 /* Search backwards through the insns emitted by expand_call looking
1735 for the instruction with the REG_RETVAL note. */
1736 rtx last = get_last_insn ();
1737 while (last != before_call)
1739 if (find_reg_note (last, REG_RETVAL, NULL))
1741 rtx note = find_reg_note (last, REG_EQUAL, NULL);
1742 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1743 two elements, i.e. symbol_ref(sqrt) and the operand. */
1745 && GET_CODE (note) == EXPR_LIST
1746 && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1747 && XEXP (XEXP (note, 0), 1) != NULL_RTX
1748 && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1750 rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1751 /* Check operand is a register with expected mode. */
1753 && GET_CODE (operand) == REG
1754 && GET_MODE (operand) == mode)
1756 /* Replace the REG_EQUAL note with a SQRT rtx. */
1757 rtx equiv = gen_rtx_SQRT (mode, operand);
1758 set_unique_reg_note (last, REG_EQUAL, equiv);
1763 last = PREV_INSN (last);
1770 /* Expand a call to the builtin binary math functions (pow and atan2).
1771 Return 0 if a normal call should be emitted rather than expanding the
1772 function in-line. EXP is the expression that is a call to the builtin
1773 function; if convenient, the result should be placed in TARGET.
1774 SUBTARGET may be used as the target for computing one of EXP's
1778 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1780 optab builtin_optab;
1781 rtx op0, op1, insns;
1782 tree fndecl = get_callee_fndecl (exp);
1783 tree arglist = TREE_OPERAND (exp, 1);
1784 tree arg0, arg1, temp, narg;
1785 enum machine_mode mode;
1786 bool errno_set = true;
1789 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
1792 arg0 = TREE_VALUE (arglist);
1793 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
1795 switch (DECL_FUNCTION_CODE (fndecl))
1800 builtin_optab = pow_optab; break;
1801 case BUILT_IN_ATAN2:
1802 case BUILT_IN_ATAN2F:
1803 case BUILT_IN_ATAN2L:
1804 builtin_optab = atan2_optab; break;
1809 /* Make a suitable register to place result in. */
1810 mode = TYPE_MODE (TREE_TYPE (exp));
1812 /* Before working hard, check whether the instruction is available. */
1813 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
1816 target = gen_reg_rtx (mode);
1818 if (! flag_errno_math || ! HONOR_NANS (mode))
1821 /* Alway stabilize the argument list. */
1822 narg = save_expr (arg1);
1825 temp = build_tree_list (NULL_TREE, narg);
1829 temp = TREE_CHAIN (arglist);
1831 narg = save_expr (arg0);
1834 arglist = tree_cons (NULL_TREE, narg, temp);
1838 arglist = tree_cons (NULL_TREE, arg0, temp);
1841 exp = build_function_call_expr (fndecl, arglist);
1843 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
1844 op1 = expand_expr (arg1, 0, VOIDmode, 0);
1849 /* Compute into TARGET.
1850 Set TARGET to wherever the result comes back. */
1851 target = expand_binop (mode, builtin_optab, op0, op1,
1852 target, 0, OPTAB_DIRECT);
1854 /* If we were unable to expand via the builtin, stop the sequence
1855 (without outputting the insns) and call to the library function
1856 with the stabilized argument list. */
1860 return expand_call (exp, target, target == const0_rtx);
1864 expand_errno_check (exp, target);
1866 /* Output the entire sequence. */
1867 insns = get_insns ();
1874 /* To evaluate powi(x,n), the floating point value x raised to the
1875 constant integer exponent n, we use a hybrid algorithm that
1876 combines the "window method" with look-up tables. For an
1877 introduction to exponentiation algorithms and "addition chains",
1878 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
1879 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
1880 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
1881 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
1883 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
1884 multiplications to inline before calling the system library's pow
1885 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
1886 so this default never requires calling pow, powf or powl. */
1888 #ifndef POWI_MAX_MULTS
1889 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
1892 /* The size of the "optimal power tree" lookup table. All
1893 exponents less than this value are simply looked up in the
1894 powi_table below. This threshold is also used to size the
1895 cache of pseudo registers that hold intermediate results. */
1896 #define POWI_TABLE_SIZE 256
1898 /* The size, in bits of the window, used in the "window method"
1899 exponentiation algorithm. This is equivalent to a radix of
1900 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
1901 #define POWI_WINDOW_SIZE 3
1903 /* The following table is an efficient representation of an
1904 "optimal power tree". For each value, i, the corresponding
1905 value, j, in the table states than an optimal evaluation
1906 sequence for calculating pow(x,i) can be found by evaluating
1907 pow(x,j)*pow(x,i-j). An optimal power tree for the first
1908 100 integers is given in Knuth's "Seminumerical algorithms". */
1910 static const unsigned char powi_table[POWI_TABLE_SIZE] =
1912 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
1913 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
1914 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
1915 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
1916 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
1917 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
1918 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
1919 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
1920 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
1921 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
1922 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
1923 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
1924 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
1925 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
1926 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
1927 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
1928 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
1929 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
1930 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
1931 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
1932 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
1933 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
1934 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
1935 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
1936 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
1937 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
1938 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
1939 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
1940 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
1941 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
1942 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
1943 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
1947 /* Return the number of multiplications required to calculate
1948 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
1949 subroutine of powi_cost. CACHE is an array indicating
1950 which exponents have already been calculated. */
1953 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
1955 /* If we've already calculated this exponent, then this evaluation
1956 doesn't require any additional multiplications. */
1961 return powi_lookup_cost (n - powi_table[n], cache)
1962 + powi_lookup_cost (powi_table[n], cache) + 1;
1965 /* Return the number of multiplications required to calculate
1966 powi(x,n) for an arbitrary x, given the exponent N. This
1967 function needs to be kept in sync with expand_powi below. */
1970 powi_cost (HOST_WIDE_INT n)
1972 bool cache[POWI_TABLE_SIZE];
1973 unsigned HOST_WIDE_INT digit;
1974 unsigned HOST_WIDE_INT val;
1980 /* Ignore the reciprocal when calculating the cost. */
1981 val = (n < 0) ? -n : n;
1983 /* Initialize the exponent cache. */
1984 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
1989 while (val >= POWI_TABLE_SIZE)
1993 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
1994 result += powi_lookup_cost (digit, cache)
1995 + POWI_WINDOW_SIZE + 1;
1996 val >>= POWI_WINDOW_SIZE;
2005 return result + powi_lookup_cost (val, cache);
2008 /* Recursive subroutine of expand_powi. This function takes the array,
2009 CACHE, of already calculated exponents and an exponent N and returns
2010 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2013 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2015 unsigned HOST_WIDE_INT digit;
2019 if (n < POWI_TABLE_SIZE)
2024 target = gen_reg_rtx (mode);
2027 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2028 op1 = expand_powi_1 (mode, powi_table[n], cache);
2032 target = gen_reg_rtx (mode);
2033 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2034 op0 = expand_powi_1 (mode, n - digit, cache);
2035 op1 = expand_powi_1 (mode, digit, cache);
2039 target = gen_reg_rtx (mode);
2040 op0 = expand_powi_1 (mode, n >> 1, cache);
2044 result = expand_mult (mode, op0, op1, target, 0);
2045 if (result != target)
2046 emit_move_insn (target, result);
2050 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2051 floating point operand in mode MODE, and N is the exponent. This
2052 function needs to be kept in sync with powi_cost above. */
2055 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2057 unsigned HOST_WIDE_INT val;
2058 rtx cache[POWI_TABLE_SIZE];
2062 return CONST1_RTX (mode);
2064 val = (n < 0) ? -n : n;
2066 memset (cache, 0, sizeof (cache));
2069 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2071 /* If the original exponent was negative, reciprocate the result. */
2073 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2074 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2079 /* Expand a call to the pow built-in mathematical function. Return 0 if
2080 a normal call should be emitted rather than expanding the function
2081 in-line. EXP is the expression that is a call to the builtin
2082 function; if convenient, the result should be placed in TARGET. */
2085 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2087 tree arglist = TREE_OPERAND (exp, 1);
2090 if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2093 arg0 = TREE_VALUE (arglist);
2094 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2096 if (TREE_CODE (arg1) == REAL_CST
2097 && ! TREE_CONSTANT_OVERFLOW (arg1))
2099 REAL_VALUE_TYPE cint;
2103 c = TREE_REAL_CST (arg1);
2104 n = real_to_integer (&c);
2105 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2106 if (real_identical (&c, &cint))
2108 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2109 Otherwise, check the number of multiplications required.
2110 Note that pow never sets errno for an integer exponent. */
2111 if ((n >= -1 && n <= 2)
2112 || (flag_unsafe_math_optimizations
2114 && powi_cost (n) <= POWI_MAX_MULTS))
2116 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2117 rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
2118 op = force_reg (mode, op);
2119 return expand_powi (op, mode, n);
2124 if (! flag_unsafe_math_optimizations)
2126 return expand_builtin_mathfn_2 (exp, target, subtarget);
2129 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2130 if we failed the caller should emit a normal call, otherwise
2131 try to get the result in TARGET, if convenient. */
2134 expand_builtin_strlen (tree arglist, rtx target,
2135 enum machine_mode target_mode)
2137 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
2142 tree len, src = TREE_VALUE (arglist);
2143 rtx result, src_reg, char_rtx, before_strlen;
2144 enum machine_mode insn_mode = target_mode, char_mode;
2145 enum insn_code icode = CODE_FOR_nothing;
2148 /* If the length can be computed at compile-time, return it. */
2149 len = c_strlen (src, 0);
2151 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2153 /* If the length can be computed at compile-time and is constant
2154 integer, but there are side-effects in src, evaluate
2155 src for side-effects, then return len.
2156 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2157 can be optimized into: i++; x = 3; */
2158 len = c_strlen (src, 1);
2159 if (len && TREE_CODE (len) == INTEGER_CST)
2161 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2162 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2165 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2167 /* If SRC is not a pointer type, don't do this operation inline. */
2171 /* Bail out if we can't compute strlen in the right mode. */
2172 while (insn_mode != VOIDmode)
2174 icode = strlen_optab->handlers[(int) insn_mode].insn_code;
2175 if (icode != CODE_FOR_nothing)
2178 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2180 if (insn_mode == VOIDmode)
2183 /* Make a place to write the result of the instruction. */
2186 && GET_CODE (result) == REG
2187 && GET_MODE (result) == insn_mode
2188 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2189 result = gen_reg_rtx (insn_mode);
2191 /* Make a place to hold the source address. We will not expand
2192 the actual source until we are sure that the expansion will
2193 not fail -- there are trees that cannot be expanded twice. */
2194 src_reg = gen_reg_rtx (Pmode);
2196 /* Mark the beginning of the strlen sequence so we can emit the
2197 source operand later. */
2198 before_strlen = get_last_insn ();
2200 char_rtx = const0_rtx;
2201 char_mode = insn_data[(int) icode].operand[2].mode;
2202 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
2204 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
2206 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
2207 char_rtx, GEN_INT (align));
2212 /* Now that we are assured of success, expand the source. */
2214 pat = memory_address (BLKmode,
2215 expand_expr (src, src_reg, ptr_mode, EXPAND_SUM));
2217 emit_move_insn (src_reg, pat);
2222 emit_insn_after (pat, before_strlen);
2224 emit_insn_before (pat, get_insns ());
2226 /* Return the value in the proper mode for this function. */
2227 if (GET_MODE (result) == target_mode)
2229 else if (target != 0)
2230 convert_move (target, result, 0);
2232 target = convert_to_mode (target_mode, result, 0);
2238 /* Expand a call to the strstr builtin. Return 0 if we failed the
2239 caller should emit a normal call, otherwise try to get the result
2240 in TARGET, if convenient (and in mode MODE if that's convenient). */
2243 expand_builtin_strstr (tree arglist, rtx target, enum machine_mode mode)
2245 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2249 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2251 const char *p1, *p2;
2260 const char *r = strstr (p1, p2);
2265 /* Return an offset into the constant string argument. */
2266 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2267 s1, convert (TREE_TYPE (s1),
2268 ssize_int (r - p1)))),
2269 target, mode, EXPAND_NORMAL);
2273 return expand_expr (s1, target, mode, EXPAND_NORMAL);
2278 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2282 /* New argument list transforming strstr(s1, s2) to
2283 strchr(s1, s2[0]). */
2285 build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
2286 arglist = tree_cons (NULL_TREE, s1, arglist);
2287 return expand_expr (build_function_call_expr (fn, arglist),
2288 target, mode, EXPAND_NORMAL);
2292 /* Expand a call to the strchr builtin. Return 0 if we failed the
2293 caller should emit a normal call, otherwise try to get the result
2294 in TARGET, if convenient (and in mode MODE if that's convenient). */
2297 expand_builtin_strchr (tree arglist, rtx target, enum machine_mode mode)
2299 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2303 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2306 if (TREE_CODE (s2) != INTEGER_CST)
2315 if (target_char_cast (s2, &c))
2323 /* Return an offset into the constant string argument. */
2324 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2325 s1, convert (TREE_TYPE (s1),
2326 ssize_int (r - p1)))),
2327 target, mode, EXPAND_NORMAL);
2330 /* FIXME: Should use here strchrM optab so that ports can optimize
2336 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2337 caller should emit a normal call, otherwise try to get the result
2338 in TARGET, if convenient (and in mode MODE if that's convenient). */
2341 expand_builtin_strrchr (tree arglist, rtx target, enum machine_mode mode)
2343 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2347 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2351 if (TREE_CODE (s2) != INTEGER_CST)
2360 if (target_char_cast (s2, &c))
2363 r = strrchr (p1, c);
2368 /* Return an offset into the constant string argument. */
2369 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2370 s1, convert (TREE_TYPE (s1),
2371 ssize_int (r - p1)))),
2372 target, mode, EXPAND_NORMAL);
2375 if (! integer_zerop (s2))
2378 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2382 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
2383 return expand_expr (build_function_call_expr (fn, arglist),
2384 target, mode, EXPAND_NORMAL);
2388 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2389 caller should emit a normal call, otherwise try to get the result
2390 in TARGET, if convenient (and in mode MODE if that's convenient). */
2393 expand_builtin_strpbrk (tree arglist, rtx target, enum machine_mode mode)
2395 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2399 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2401 const char *p1, *p2;
2410 const char *r = strpbrk (p1, p2);
2415 /* Return an offset into the constant string argument. */
2416 return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
2417 s1, convert (TREE_TYPE (s1),
2418 ssize_int (r - p1)))),
2419 target, mode, EXPAND_NORMAL);
2424 /* strpbrk(x, "") == NULL.
2425 Evaluate and ignore the arguments in case they had
2427 expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
2432 return 0; /* Really call strpbrk. */
2434 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
2438 /* New argument list transforming strpbrk(s1, s2) to
2439 strchr(s1, s2[0]). */
2441 build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
2442 arglist = tree_cons (NULL_TREE, s1, arglist);
2443 return expand_expr (build_function_call_expr (fn, arglist),
2444 target, mode, EXPAND_NORMAL);
2448 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2449 bytes from constant string DATA + OFFSET and return it as target
2453 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2454 enum machine_mode mode)
2456 const char *str = (const char *) data;
2459 || ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2460 > strlen (str) + 1))
2461 abort (); /* Attempt to read past the end of constant string. */
2463 return c_readstr (str + offset, mode);
2466 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2467 Return 0 if we failed, the caller should emit a normal call,
2468 otherwise try to get the result in TARGET, if convenient (and in
2469 mode MODE if that's convenient). */
2471 expand_builtin_memcpy (tree arglist, rtx target, enum machine_mode mode)
2473 if (!validate_arglist (arglist,
2474 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2478 tree dest = TREE_VALUE (arglist);
2479 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2480 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2481 const char *src_str;
2482 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2483 unsigned int dest_align
2484 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2485 rtx dest_mem, src_mem, dest_addr, len_rtx;
2487 /* If DEST is not a pointer type, call the normal function. */
2488 if (dest_align == 0)
2491 /* If the LEN parameter is zero, return DEST. */
2492 if (integer_zerop (len))
2494 /* Evaluate and ignore SRC in case it has side-effects. */
2495 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2496 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2499 /* If SRC and DEST are the same (and not volatile), return DEST. */
2500 if (operand_equal_p (src, dest, 0))
2502 /* Evaluate and ignore LEN in case it has side-effects. */
2503 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2504 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2507 /* If either SRC is not a pointer type, don't do this
2508 operation in-line. */
2512 dest_mem = get_memory_rtx (dest);
2513 set_mem_align (dest_mem, dest_align);
2514 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2515 src_str = c_getstr (src);
2517 /* If SRC is a string constant and block move would be done
2518 by pieces, we can avoid loading the string from memory
2519 and only stored the computed constants. */
2521 && GET_CODE (len_rtx) == CONST_INT
2522 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2523 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2524 (void *) src_str, dest_align))
2526 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2527 builtin_memcpy_read_str,
2528 (void *) src_str, dest_align, 0);
2529 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2530 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2534 src_mem = get_memory_rtx (src);
2535 set_mem_align (src_mem, src_align);
2537 /* Copy word part most expediently. */
2538 dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
2543 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2544 dest_addr = convert_memory_address (ptr_mode, dest_addr);
2550 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2551 Return 0 if we failed the caller should emit a normal call,
2552 otherwise try to get the result in TARGET, if convenient (and in
2553 mode MODE if that's convenient). If ENDP is 0 return the
2554 destination pointer, if ENDP is 1 return the end pointer ala
2555 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2559 expand_builtin_mempcpy (tree arglist, rtx target, enum machine_mode mode,
2562 if (!validate_arglist (arglist,
2563 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2565 /* If return value is ignored, transform mempcpy into memcpy. */
2566 else if (target == const0_rtx)
2568 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2573 return expand_expr (build_function_call_expr (fn, arglist),
2574 target, mode, EXPAND_NORMAL);
2578 tree dest = TREE_VALUE (arglist);
2579 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2580 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2581 const char *src_str;
2582 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2583 unsigned int dest_align
2584 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2585 rtx dest_mem, src_mem, len_rtx;
2587 /* If DEST is not a pointer type, call the normal function. */
2588 if (dest_align == 0)
2591 /* If SRC and DEST are the same (and not volatile), do nothing. */
2592 if (operand_equal_p (src, dest, 0))
2598 /* Evaluate and ignore LEN in case it has side-effects. */
2599 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2600 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2604 len = fold (build (MINUS_EXPR, TREE_TYPE (len), dest,
2606 len = convert (TREE_TYPE (dest), len);
2607 expr = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
2608 return expand_expr (expr, target, mode, EXPAND_NORMAL);
2611 /* If LEN is not constant, call the normal function. */
2612 if (! host_integerp (len, 1))
2615 /* If the LEN parameter is zero, return DEST. */
2616 if (tree_low_cst (len, 1) == 0)
2618 /* Evaluate and ignore SRC in case it has side-effects. */
2619 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2620 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2623 /* If either SRC is not a pointer type, don't do this
2624 operation in-line. */
2628 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2629 src_str = c_getstr (src);
2631 /* If SRC is a string constant and block move would be done
2632 by pieces, we can avoid loading the string from memory
2633 and only stored the computed constants. */
2635 && GET_CODE (len_rtx) == CONST_INT
2636 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2637 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2638 (void *) src_str, dest_align))
2640 dest_mem = get_memory_rtx (dest);
2641 set_mem_align (dest_mem, dest_align);
2642 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2643 builtin_memcpy_read_str,
2644 (void *) src_str, dest_align, endp);
2645 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2646 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2650 if (GET_CODE (len_rtx) == CONST_INT
2651 && can_move_by_pieces (INTVAL (len_rtx),
2652 MIN (dest_align, src_align)))
2654 dest_mem = get_memory_rtx (dest);
2655 set_mem_align (dest_mem, dest_align);
2656 src_mem = get_memory_rtx (src);
2657 set_mem_align (src_mem, src_align);
2658 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
2659 MIN (dest_align, src_align), endp);
2660 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2661 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2669 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2670 if we failed the caller should emit a normal call. */
2673 expand_builtin_memmove (tree arglist, rtx target, enum machine_mode mode)
2675 if (!validate_arglist (arglist,
2676 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2680 tree dest = TREE_VALUE (arglist);
2681 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2682 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2684 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2685 unsigned int dest_align
2686 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2688 /* If DEST is not a pointer type, call the normal function. */
2689 if (dest_align == 0)
2692 /* If the LEN parameter is zero, return DEST. */
2693 if (integer_zerop (len))
2695 /* Evaluate and ignore SRC in case it has side-effects. */
2696 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2697 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2700 /* If SRC and DEST are the same (and not volatile), return DEST. */
2701 if (operand_equal_p (src, dest, 0))
2703 /* Evaluate and ignore LEN in case it has side-effects. */
2704 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2705 return expand_expr (dest, target, mode, EXPAND_NORMAL);
2708 /* If either SRC is not a pointer type, don't do this
2709 operation in-line. */
2713 /* If src is categorized for a readonly section we can use
2715 if (readonly_data_expr (src))
2717 tree const fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2720 return expand_expr (build_function_call_expr (fn, arglist),
2721 target, mode, EXPAND_NORMAL);
2724 /* Otherwise, call the normal function. */
2729 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
2730 if we failed the caller should emit a normal call. */
2733 expand_builtin_bcopy (tree arglist)
2735 tree src, dest, size, newarglist;
2737 if (!validate_arglist (arglist,
2738 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2741 src = TREE_VALUE (arglist);
2742 dest = TREE_VALUE (TREE_CHAIN (arglist));
2743 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2745 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
2746 memmove(ptr y, ptr x, size_t z). This is done this way
2747 so that if it isn't expanded inline, we fallback to
2748 calling bcopy instead of memmove. */
2750 newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
2751 newarglist = tree_cons (NULL_TREE, src, newarglist);
2752 newarglist = tree_cons (NULL_TREE, dest, newarglist);
2754 return expand_builtin_memmove (newarglist, const0_rtx, VOIDmode);
2757 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
2758 if we failed the caller should emit a normal call, otherwise try to get
2759 the result in TARGET, if convenient (and in mode MODE if that's
2763 expand_builtin_strcpy (tree arglist, rtx target, enum machine_mode mode)
2765 tree fn, len, src, dst;
2767 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2770 src = TREE_VALUE (TREE_CHAIN (arglist));
2771 dst = TREE_VALUE (arglist);
2773 /* If SRC and DST are equal (and not volatile), return DST. */
2774 if (operand_equal_p (src, dst, 0))
2775 return expand_expr (dst, target, mode, EXPAND_NORMAL);
2777 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2781 len = c_strlen (src, 1);
2782 if (len == 0 || TREE_SIDE_EFFECTS (len))
2785 len = size_binop (PLUS_EXPR, len, ssize_int (1));
2786 arglist = build_tree_list (NULL_TREE, len);
2787 arglist = tree_cons (NULL_TREE, src, arglist);
2788 arglist = tree_cons (NULL_TREE, dst, arglist);
2789 return expand_expr (build_function_call_expr (fn, arglist),
2790 target, mode, EXPAND_NORMAL);
2793 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
2794 Return 0 if we failed the caller should emit a normal call,
2795 otherwise try to get the result in TARGET, if convenient (and in
2796 mode MODE if that's convenient). */
2799 expand_builtin_stpcpy (tree arglist, rtx target, enum machine_mode mode)
2801 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2807 /* If return value is ignored, transform stpcpy into strcpy. */
2808 if (target == const0_rtx)
2810 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
2814 return expand_expr (build_function_call_expr (fn, arglist),
2815 target, mode, EXPAND_NORMAL);
2818 /* Ensure we get an actual string whose length can be evaluated at
2819 compile-time, not an expression containing a string. This is
2820 because the latter will potentially produce pessimized code
2821 when used to produce the return value. */
2822 src = TREE_VALUE (TREE_CHAIN (arglist));
2823 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
2826 dst = TREE_VALUE (arglist);
2827 len = fold (size_binop (PLUS_EXPR, len, ssize_int (1)));
2828 arglist = build_tree_list (NULL_TREE, len);
2829 arglist = tree_cons (NULL_TREE, src, arglist);
2830 arglist = tree_cons (NULL_TREE, dst, arglist);
2831 return expand_builtin_mempcpy (arglist, target, mode, /*endp=*/2);
2835 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2836 bytes from constant string DATA + OFFSET and return it as target
2840 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
2841 enum machine_mode mode)
2843 const char *str = (const char *) data;
2845 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
2848 return c_readstr (str + offset, mode);
2851 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
2852 if we failed the caller should emit a normal call. */
2855 expand_builtin_strncpy (tree arglist, rtx target, enum machine_mode mode)
2857 if (!validate_arglist (arglist,
2858 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2862 tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
2863 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2866 /* We must be passed a constant len parameter. */
2867 if (TREE_CODE (len) != INTEGER_CST)
2870 /* If the len parameter is zero, return the dst parameter. */
2871 if (integer_zerop (len))
2873 /* Evaluate and ignore the src argument in case it has
2875 expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
2876 VOIDmode, EXPAND_NORMAL);
2877 /* Return the dst parameter. */
2878 return expand_expr (TREE_VALUE (arglist), target, mode,
2882 /* Now, we must be passed a constant src ptr parameter. */
2883 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
2886 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
2888 /* We're required to pad with trailing zeros if the requested
2889 len is greater than strlen(s2)+1. In that case try to
2890 use store_by_pieces, if it fails, punt. */
2891 if (tree_int_cst_lt (slen, len))
2893 tree dest = TREE_VALUE (arglist);
2894 unsigned int dest_align
2895 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2896 const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
2899 if (!p || dest_align == 0 || !host_integerp (len, 1)
2900 || !can_store_by_pieces (tree_low_cst (len, 1),
2901 builtin_strncpy_read_str,
2902 (void *) p, dest_align))
2905 dest_mem = get_memory_rtx (dest);
2906 store_by_pieces (dest_mem, tree_low_cst (len, 1),
2907 builtin_strncpy_read_str,
2908 (void *) p, dest_align, 0);
2909 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2910 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2914 /* OK transform into builtin memcpy. */
2915 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2918 return expand_expr (build_function_call_expr (fn, arglist),
2919 target, mode, EXPAND_NORMAL);
2923 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2924 bytes from constant string DATA + OFFSET and return it as target
2928 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2929 enum machine_mode mode)
2931 const char *c = (const char *) data;
2932 char *p = alloca (GET_MODE_SIZE (mode));
2934 memset (p, *c, GET_MODE_SIZE (mode));
2936 return c_readstr (p, mode);
2939 /* Callback routine for store_by_pieces. Return the RTL of a register
2940 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
2941 char value given in the RTL register data. For example, if mode is
2942 4 bytes wide, return the RTL for 0x01010101*data. */
2945 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2946 enum machine_mode mode)
2952 size = GET_MODE_SIZE (mode);
2957 memset (p, 1, size);
2958 coeff = c_readstr (p, mode);
2960 target = convert_to_mode (mode, (rtx) data, 1);
2961 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
2962 return force_reg (mode, target);
2965 /* Expand expression EXP, which is a call to the memset builtin. Return 0
2966 if we failed the caller should emit a normal call, otherwise try to get
2967 the result in TARGET, if convenient (and in mode MODE if that's
2971 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode)
2973 if (!validate_arglist (arglist,
2974 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
2978 tree dest = TREE_VALUE (arglist);
2979 tree val = TREE_VALUE (TREE_CHAIN (arglist));
2980 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2983 unsigned int dest_align
2984 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2985 rtx dest_mem, dest_addr, len_rtx;
2987 /* If DEST is not a pointer type, don't do this
2988 operation in-line. */
2989 if (dest_align == 0)
2992 /* If the LEN parameter is zero, return DEST. */
2993 if (integer_zerop (len))
2995 /* Evaluate and ignore VAL in case it has side-effects. */
2996 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
2997 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3000 if (TREE_CODE (val) != INTEGER_CST)
3004 if (!host_integerp (len, 1))
3007 if (optimize_size && tree_low_cst (len, 1) > 1)
3010 /* Assume that we can memset by pieces if we can store the
3011 * the coefficients by pieces (in the required modes).
3012 * We can't pass builtin_memset_gen_str as that emits RTL. */
3014 if (!can_store_by_pieces (tree_low_cst (len, 1),
3015 builtin_memset_read_str,
3019 val = fold (build1 (CONVERT_EXPR, unsigned_char_type_node, val));
3020 val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
3021 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3023 dest_mem = get_memory_rtx (dest);
3024 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3025 builtin_memset_gen_str,
3026 val_rtx, dest_align, 0);
3027 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3028 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3032 if (target_char_cast (val, &c))
3037 if (!host_integerp (len, 1))
3039 if (!can_store_by_pieces (tree_low_cst (len, 1),
3040 builtin_memset_read_str, &c,
3044 dest_mem = get_memory_rtx (dest);
3045 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3046 builtin_memset_read_str,
3048 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3049 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3053 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3055 dest_mem = get_memory_rtx (dest);
3056 set_mem_align (dest_mem, dest_align);
3057 dest_addr = clear_storage (dest_mem, len_rtx);
3061 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3062 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3069 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3070 if we failed the caller should emit a normal call. */
3073 expand_builtin_bzero (tree arglist)
3075 tree dest, size, newarglist;
3077 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3080 dest = TREE_VALUE (arglist);
3081 size = TREE_VALUE (TREE_CHAIN (arglist));
3083 /* New argument list transforming bzero(ptr x, int y) to
3084 memset(ptr x, int 0, size_t y). This is done this way
3085 so that if it isn't expanded inline, we fallback to
3086 calling bzero instead of memset. */
3088 newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
3089 newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
3090 newarglist = tree_cons (NULL_TREE, dest, newarglist);
3092 return expand_builtin_memset (newarglist, const0_rtx, VOIDmode);
3095 /* Expand expression EXP, which is a call to the memcmp built-in function.
3096 ARGLIST is the argument list for this call. Return 0 if we failed and the
3097 caller should emit a normal call, otherwise try to get the result in
3098 TARGET, if convenient (and in mode MODE, if that's convenient). */
3101 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED, tree arglist, rtx target,
3102 enum machine_mode mode)
3104 tree arg1, arg2, len;
3105 const char *p1, *p2;
3107 if (!validate_arglist (arglist,
3108 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3111 arg1 = TREE_VALUE (arglist);
3112 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3113 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3115 /* If the len parameter is zero, return zero. */
3116 if (integer_zerop (len))
3118 /* Evaluate and ignore arg1 and arg2 in case they have
3120 expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3121 expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3125 /* If both arguments are equal (and not volatile), return zero. */
3126 if (operand_equal_p (arg1, arg2, 0))
3128 /* Evaluate and ignore len in case it has side-effects. */
3129 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
3133 p1 = c_getstr (arg1);
3134 p2 = c_getstr (arg2);
3136 /* If all arguments are constant, and the value of len is not greater
3137 than the lengths of arg1 and arg2, evaluate at compile-time. */
3138 if (host_integerp (len, 1) && p1 && p2
3139 && compare_tree_int (len, strlen (p1) + 1) <= 0
3140 && compare_tree_int (len, strlen (p2) + 1) <= 0)
3142 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
3144 return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
3147 /* If len parameter is one, return an expression corresponding to
3148 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3149 if (integer_onep (len))
3151 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3152 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3154 fold (build1 (CONVERT_EXPR, integer_type_node,
3155 build1 (INDIRECT_REF, cst_uchar_node,
3156 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3158 fold (build1 (CONVERT_EXPR, integer_type_node,
3159 build1 (INDIRECT_REF, cst_uchar_node,
3160 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3161 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3162 return expand_expr (result, target, mode, EXPAND_NORMAL);
3165 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
3167 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3172 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3174 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3175 enum machine_mode insn_mode;
3177 #ifdef HAVE_cmpmemsi
3179 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3182 #ifdef HAVE_cmpstrsi
3184 insn_mode = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3189 /* If we don't have POINTER_TYPE, call the function. */
3190 if (arg1_align == 0 || arg2_align == 0)
3193 /* Make a place to write the result of the instruction. */
3196 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3197 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3198 result = gen_reg_rtx (insn_mode);
3200 arg1_rtx = get_memory_rtx (arg1);
3201 arg2_rtx = get_memory_rtx (arg2);
3202 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3203 #ifdef HAVE_cmpmemsi
3205 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3206 GEN_INT (MIN (arg1_align, arg2_align)));
3209 #ifdef HAVE_cmpstrsi
3211 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3212 GEN_INT (MIN (arg1_align, arg2_align)));
3220 emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
3221 TYPE_MODE (integer_type_node), 3,
3222 XEXP (arg1_rtx, 0), Pmode,
3223 XEXP (arg2_rtx, 0), Pmode,
3224 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3225 TREE_UNSIGNED (sizetype)),
3226 TYPE_MODE (sizetype));
3228 /* Return the value in the proper mode for this function. */
3229 mode = TYPE_MODE (TREE_TYPE (exp));
3230 if (GET_MODE (result) == mode)
3232 else if (target != 0)
3234 convert_move (target, result, 0);
3238 return convert_to_mode (mode, result, 0);
3245 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3246 if we failed the caller should emit a normal call, otherwise try to get
3247 the result in TARGET, if convenient. */
3250 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
3252 tree arglist = TREE_OPERAND (exp, 1);
3254 const char *p1, *p2;
3256 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3259 arg1 = TREE_VALUE (arglist);
3260 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3262 /* If both arguments are equal (and not volatile), return zero. */
3263 if (operand_equal_p (arg1, arg2, 0))
3266 p1 = c_getstr (arg1);
3267 p2 = c_getstr (arg2);
3271 const int i = strcmp (p1, p2);
3272 return (i < 0 ? constm1_rtx : (i > 0 ? const1_rtx : const0_rtx));
3275 /* If either arg is "", return an expression corresponding to
3276 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
3277 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
3279 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3280 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3282 fold (build1 (CONVERT_EXPR, integer_type_node,
3283 build1 (INDIRECT_REF, cst_uchar_node,
3284 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3286 fold (build1 (CONVERT_EXPR, integer_type_node,
3287 build1 (INDIRECT_REF, cst_uchar_node,
3288 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3289 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3290 return expand_expr (result, target, mode, EXPAND_NORMAL);
3293 #ifdef HAVE_cmpstrsi
3296 tree len, len1, len2;
3297 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3302 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3304 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3305 enum machine_mode insn_mode
3306 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3308 len1 = c_strlen (arg1, 1);
3309 len2 = c_strlen (arg2, 1);
3312 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3314 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3316 /* If we don't have a constant length for the first, use the length
3317 of the second, if we know it. We don't require a constant for
3318 this case; some cost analysis could be done if both are available
3319 but neither is constant. For now, assume they're equally cheap,
3320 unless one has side effects. If both strings have constant lengths,
3327 else if (TREE_SIDE_EFFECTS (len1))
3329 else if (TREE_SIDE_EFFECTS (len2))
3331 else if (TREE_CODE (len1) != INTEGER_CST)
3333 else if (TREE_CODE (len2) != INTEGER_CST)
3335 else if (tree_int_cst_lt (len1, len2))
3340 /* If both arguments have side effects, we cannot optimize. */
3341 if (!len || TREE_SIDE_EFFECTS (len))
3344 /* If we don't have POINTER_TYPE, call the function. */
3345 if (arg1_align == 0 || arg2_align == 0)
3348 /* Make a place to write the result of the instruction. */
3351 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3352 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3353 result = gen_reg_rtx (insn_mode);
3355 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3356 arg1 = save_expr (arg1);
3357 arg2 = save_expr (arg2);
3359 arg1_rtx = get_memory_rtx (arg1);
3360 arg2_rtx = get_memory_rtx (arg2);
3361 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3362 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3363 GEN_INT (MIN (arg1_align, arg2_align)));
3368 /* Return the value in the proper mode for this function. */
3369 mode = TYPE_MODE (TREE_TYPE (exp));
3370 if (GET_MODE (result) == mode)
3373 return convert_to_mode (mode, result, 0);
3374 convert_move (target, result, 0);
3378 /* Expand the library call ourselves using a stabilized argument
3379 list to avoid re-evaluating the function's arguments twice. */
3380 arglist = build_tree_list (NULL_TREE, arg2);
3381 arglist = tree_cons (NULL_TREE, arg1, arglist);
3382 fndecl = get_callee_fndecl (exp);
3383 exp = build_function_call_expr (fndecl, arglist);
3384 return expand_call (exp, target, target == const0_rtx);
3390 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3391 if we failed the caller should emit a normal call, otherwise try to get
3392 the result in TARGET, if convenient. */
3395 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
3397 tree arglist = TREE_OPERAND (exp, 1);
3398 tree arg1, arg2, arg3;
3399 const char *p1, *p2;
3401 if (!validate_arglist (arglist,
3402 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3405 arg1 = TREE_VALUE (arglist);
3406 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3407 arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3409 /* If the len parameter is zero, return zero. */
3410 if (integer_zerop (arg3))
3412 /* Evaluate and ignore arg1 and arg2 in case they have
3414 expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3415 expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3419 /* If arg1 and arg2 are equal (and not volatile), return zero. */
3420 if (operand_equal_p (arg1, arg2, 0))
3422 /* Evaluate and ignore arg3 in case it has side-effects. */
3423 expand_expr (arg3, const0_rtx, VOIDmode, EXPAND_NORMAL);
3427 p1 = c_getstr (arg1);
3428 p2 = c_getstr (arg2);
3430 /* If all arguments are constant, evaluate at compile-time. */
3431 if (host_integerp (arg3, 1) && p1 && p2)
3433 const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
3434 return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
3437 /* If len == 1 or (either string parameter is "" and (len >= 1)),
3438 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
3439 if (host_integerp (arg3, 1)
3440 && (tree_low_cst (arg3, 1) == 1
3441 || (tree_low_cst (arg3, 1) > 1
3442 && ((p1 && *p1 == '\0') || (p2 && *p2 == '\0')))))
3444 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
3445 tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
3447 fold (build1 (CONVERT_EXPR, integer_type_node,
3448 build1 (INDIRECT_REF, cst_uchar_node,
3449 build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
3451 fold (build1 (CONVERT_EXPR, integer_type_node,
3452 build1 (INDIRECT_REF, cst_uchar_node,
3453 build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
3454 tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
3455 return expand_expr (result, target, mode, EXPAND_NORMAL);
3458 /* If c_strlen can determine an expression for one of the string
3459 lengths, and it doesn't have side effects, then emit cmpstrsi
3460 using length MIN(strlen(string)+1, arg3). */
3461 #ifdef HAVE_cmpstrsi
3464 tree len, len1, len2;
3465 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3470 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3472 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3473 enum machine_mode insn_mode
3474 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3476 len1 = c_strlen (arg1, 1);
3477 len2 = c_strlen (arg2, 1);
3480 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3482 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3484 /* If we don't have a constant length for the first, use the length
3485 of the second, if we know it. We don't require a constant for
3486 this case; some cost analysis could be done if both are available
3487 but neither is constant. For now, assume they're equally cheap,
3488 unless one has side effects. If both strings have constant lengths,
3495 else if (TREE_SIDE_EFFECTS (len1))
3497 else if (TREE_SIDE_EFFECTS (len2))
3499 else if (TREE_CODE (len1) != INTEGER_CST)
3501 else if (TREE_CODE (len2) != INTEGER_CST)
3503 else if (tree_int_cst_lt (len1, len2))
3508 /* If both arguments have side effects, we cannot optimize. */
3509 if (!len || TREE_SIDE_EFFECTS (len))
3512 /* The actual new length parameter is MIN(len,arg3). */
3513 len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
3515 /* If we don't have POINTER_TYPE, call the function. */
3516 if (arg1_align == 0 || arg2_align == 0)
3519 /* Make a place to write the result of the instruction. */
3522 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
3523 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3524 result = gen_reg_rtx (insn_mode);
3526 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3527 arg1 = save_expr (arg1);
3528 arg2 = save_expr (arg2);
3529 len = save_expr (len);
3531 arg1_rtx = get_memory_rtx (arg1);
3532 arg2_rtx = get_memory_rtx (arg2);
3533 arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3534 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3535 GEN_INT (MIN (arg1_align, arg2_align)));
3540 /* Return the value in the proper mode for this function. */
3541 mode = TYPE_MODE (TREE_TYPE (exp));
3542 if (GET_MODE (result) == mode)
3545 return convert_to_mode (mode, result, 0);
3546 convert_move (target, result, 0);
3550 /* Expand the library call ourselves using a stabilized argument
3551 list to avoid re-evaluating the function's arguments twice. */
3552 arglist = build_tree_list (NULL_TREE, len);
3553 arglist = tree_cons (NULL_TREE, arg2, arglist);
3554 arglist = tree_cons (NULL_TREE, arg1, arglist);
3555 fndecl = get_callee_fndecl (exp);
3556 exp = build_function_call_expr (fndecl, arglist);
3557 return expand_call (exp, target, target == const0_rtx);
3563 /* Expand expression EXP, which is a call to the strcat builtin.
3564 Return 0 if we failed the caller should emit a normal call,
3565 otherwise try to get the result in TARGET, if convenient. */
3568 expand_builtin_strcat (tree arglist, rtx target, enum machine_mode mode)
3570 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3574 tree dst = TREE_VALUE (arglist),
3575 src = TREE_VALUE (TREE_CHAIN (arglist));
3576 const char *p = c_getstr (src);
3580 /* If the string length is zero, return the dst parameter. */
3582 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3583 else if (!optimize_size)
3585 /* Otherwise if !optimize_size, see if we can store by
3586 pieces into (dst + strlen(dst)). */
3587 tree newdst, arglist,
3588 strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3590 /* This is the length argument. */
3591 arglist = build_tree_list (NULL_TREE,
3592 fold (size_binop (PLUS_EXPR,
3595 /* Prepend src argument. */
3596 arglist = tree_cons (NULL_TREE, src, arglist);
3598 /* We're going to use dst more than once. */
3599 dst = save_expr (dst);
3601 /* Create strlen (dst). */
3603 fold (build_function_call_expr (strlen_fn,
3604 build_tree_list (NULL_TREE,
3606 /* Create (dst + strlen (dst)). */
3607 newdst = fold (build (PLUS_EXPR, TREE_TYPE (dst), dst, newdst));
3609 /* Prepend the new dst argument. */
3610 arglist = tree_cons (NULL_TREE, newdst, arglist);
3612 /* We don't want to get turned into a memcpy if the
3613 target is const0_rtx, i.e. when the return value
3614 isn't used. That would produce pessimized code so
3615 pass in a target of zero, it should never actually be
3616 used. If this was successful return the original
3617 dst, not the result of mempcpy. */
3618 if (expand_builtin_mempcpy (arglist, /*target=*/0, mode, /*endp=*/0))
3619 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3629 /* Expand expression EXP, which is a call to the strncat builtin.
3630 Return 0 if we failed the caller should emit a normal call,
3631 otherwise try to get the result in TARGET, if convenient. */
3634 expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
3636 if (!validate_arglist (arglist,
3637 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3641 tree dst = TREE_VALUE (arglist),
3642 src = TREE_VALUE (TREE_CHAIN (arglist)),
3643 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3644 const char *p = c_getstr (src);
3646 /* If the requested length is zero, or the src parameter string
3647 length is zero, return the dst parameter. */
3648 if (integer_zerop (len) || (p && *p == '\0'))
3650 /* Evaluate and ignore the src and len parameters in case
3651 they have side-effects. */
3652 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3653 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
3654 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3657 /* If the requested len is greater than or equal to the string
3658 length, call strcat. */
3659 if (TREE_CODE (len) == INTEGER_CST && p
3660 && compare_tree_int (len, strlen (p)) >= 0)
3663 = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
3664 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
3666 /* If the replacement _DECL isn't initialized, don't do the
3671 return expand_expr (build_function_call_expr (fn, newarglist),
3672 target, mode, EXPAND_NORMAL);
3678 /* Expand expression EXP, which is a call to the strspn builtin.
3679 Return 0 if we failed the caller should emit a normal call,
3680 otherwise try to get the result in TARGET, if convenient. */
3683 expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
3685 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3689 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
3690 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
3692 /* If both arguments are constants, evaluate at compile-time. */
3695 const size_t r = strspn (p1, p2);
3696 return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
3699 /* If either argument is "", return 0. */
3700 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
3702 /* Evaluate and ignore both arguments in case either one has
3704 expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
3705 expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3712 /* Expand expression EXP, which is a call to the strcspn builtin.
3713 Return 0 if we failed the caller should emit a normal call,
3714 otherwise try to get the result in TARGET, if convenient. */
3717 expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
3719 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3723 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
3724 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
3726 /* If both arguments are constants, evaluate at compile-time. */
3729 const size_t r = strcspn (p1, p2);
3730 return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
3733 /* If the first argument is "", return 0. */
3734 if (p1 && *p1 == '\0')
3736 /* Evaluate and ignore argument s2 in case it has
3738 expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
3742 /* If the second argument is "", return __builtin_strlen(s1). */
3743 if (p2 && *p2 == '\0')
3745 tree newarglist = build_tree_list (NULL_TREE, s1),
3746 fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3748 /* If the replacement _DECL isn't initialized, don't do the
3753 return expand_expr (build_function_call_expr (fn, newarglist),
3754 target, mode, EXPAND_NORMAL);
3760 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
3761 if that's convenient. */
3764 expand_builtin_saveregs (void)
3768 /* Don't do __builtin_saveregs more than once in a function.
3769 Save the result of the first call and reuse it. */
3770 if (saveregs_value != 0)
3771 return saveregs_value;
3773 /* When this function is called, it means that registers must be
3774 saved on entry to this function. So we migrate the call to the
3775 first insn of this function. */
3779 /* Do whatever the machine needs done in this case. */
3780 val = targetm.calls.expand_builtin_saveregs ();
3785 saveregs_value = val;
3787 /* Put the insns after the NOTE that starts the function. If this
3788 is inside a start_sequence, make the outer-level insn chain current, so
3789 the code is placed at the start of the function. */
3790 push_topmost_sequence ();
3791 emit_insn_after (seq, get_insns ());
3792 pop_topmost_sequence ();
3797 /* __builtin_args_info (N) returns word N of the arg space info
3798 for the current function. The number and meanings of words
3799 is controlled by the definition of CUMULATIVE_ARGS. */
3802 expand_builtin_args_info (tree arglist)
3804 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
3805 int *word_ptr = (int *) ¤t_function_args_info;
3807 if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
3812 if (!host_integerp (TREE_VALUE (arglist), 0))
3813 error ("argument of `__builtin_args_info' must be constant");
3816 HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
3818 if (wordnum < 0 || wordnum >= nwords)
3819 error ("argument of `__builtin_args_info' out of range");
3821 return GEN_INT (word_ptr[wordnum]);
3825 error ("missing argument in `__builtin_args_info'");
3830 /* Expand ARGLIST, from a call to __builtin_next_arg. */
3833 expand_builtin_next_arg (tree arglist)
3835 tree fntype = TREE_TYPE (current_function_decl);
3837 if (TYPE_ARG_TYPES (fntype) == 0
3838 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
3841 error ("`va_start' used in function with fixed args");
3847 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
3848 tree arg = TREE_VALUE (arglist);
3850 /* Strip off all nops for the sake of the comparison. This
3851 is not quite the same as STRIP_NOPS. It does more.
3852 We must also strip off INDIRECT_EXPR for C++ reference
3854 while (TREE_CODE (arg) == NOP_EXPR
3855 || TREE_CODE (arg) == CONVERT_EXPR
3856 || TREE_CODE (arg) == NON_LVALUE_EXPR
3857 || TREE_CODE (arg) == INDIRECT_REF)
3858 arg = TREE_OPERAND (arg, 0);
3859 if (arg != last_parm)
3860 warning ("second parameter of `va_start' not last named argument");
3863 /* Evidently an out of date version of <stdarg.h>; can't validate
3864 va_start's second argument, but can still work as intended. */
3865 warning ("`__builtin_next_arg' called without an argument");
3867 return expand_binop (Pmode, add_optab,
3868 current_function_internal_arg_pointer,
3869 current_function_arg_offset_rtx,
3870 NULL_RTX, 0, OPTAB_LIB_WIDEN);
3873 /* Make it easier for the backends by protecting the valist argument
3874 from multiple evaluations. */
3877 stabilize_va_list (tree valist, int needs_lvalue)
3879 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3881 if (TREE_SIDE_EFFECTS (valist))
3882 valist = save_expr (valist);
3884 /* For this case, the backends will be expecting a pointer to
3885 TREE_TYPE (va_list_type_node), but it's possible we've
3886 actually been given an array (an actual va_list_type_node).
3888 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
3890 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
3891 tree p2 = build_pointer_type (va_list_type_node);
3893 valist = build1 (ADDR_EXPR, p2, valist);
3894 valist = fold (build1 (NOP_EXPR, p1, valist));
3903 if (! TREE_SIDE_EFFECTS (valist))
3906 pt = build_pointer_type (va_list_type_node);
3907 valist = fold (build1 (ADDR_EXPR, pt, valist));
3908 TREE_SIDE_EFFECTS (valist) = 1;
3911 if (TREE_SIDE_EFFECTS (valist))
3912 valist = save_expr (valist);
3913 valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
3920 /* The "standard" definition of va_list is void*. */
3923 std_build_builtin_va_list (void)
3925 return ptr_type_node;
3928 /* The "standard" implementation of va_start: just assign `nextarg' to
3932 std_expand_builtin_va_start (tree valist, rtx nextarg)
3936 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3937 make_tree (ptr_type_node, nextarg));
3938 TREE_SIDE_EFFECTS (t) = 1;
3940 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3943 /* Expand ARGLIST, from a call to __builtin_va_start. */
3946 expand_builtin_va_start (tree arglist)
3951 chain = TREE_CHAIN (arglist);
3953 if (TREE_CHAIN (chain))
3954 error ("too many arguments to function `va_start'");
3956 nextarg = expand_builtin_next_arg (chain);
3957 valist = stabilize_va_list (TREE_VALUE (arglist), 1);
3959 #ifdef EXPAND_BUILTIN_VA_START
3960 EXPAND_BUILTIN_VA_START (valist, nextarg);
3962 std_expand_builtin_va_start (valist, nextarg);
3968 /* The "standard" implementation of va_arg: read the value from the
3969 current (padded) address and increment by the (padded) size. */
3972 std_expand_builtin_va_arg (tree valist, tree type)
3974 tree addr_tree, t, type_size = NULL;
3975 tree align, alignm1;
3978 HOST_WIDE_INT boundary;
3980 /* Compute the rounded size of the type. */
3981 align = size_int (PARM_BOUNDARY / BITS_PER_UNIT);
3982 alignm1 = size_int (PARM_BOUNDARY / BITS_PER_UNIT - 1);
3983 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
3985 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
3986 requires greater alignment, we must perform dynamic alignment. */
3988 if (boundary > PARM_BOUNDARY)
3990 if (!PAD_VARARGS_DOWN)
3992 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3993 build (PLUS_EXPR, TREE_TYPE (valist), valist,
3994 build_int_2 (boundary / BITS_PER_UNIT - 1, 0)));
3995 TREE_SIDE_EFFECTS (t) = 1;
3996 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3998 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3999 build (BIT_AND_EXPR, TREE_TYPE (valist), valist,
4000 build_int_2 (~(boundary / BITS_PER_UNIT - 1), -1)));
4001 TREE_SIDE_EFFECTS (t) = 1;
4002 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4004 if (type == error_mark_node
4005 || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
4006 || TREE_OVERFLOW (type_size))
4007 rounded_size = size_zero_node;
4009 rounded_size = fold (build (MULT_EXPR, sizetype,
4010 fold (build (TRUNC_DIV_EXPR, sizetype,
4011 fold (build (PLUS_EXPR, sizetype,
4012 type_size, alignm1)),
4018 if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
4020 /* Small args are padded downward. */
4021 addr_tree = fold (build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
4022 fold (build (COND_EXPR, sizetype,
4023 fold (build (GT_EXPR, sizetype,
4027 fold (build (MINUS_EXPR, sizetype,
4032 addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
4033 addr = copy_to_reg (addr);
4035 /* Compute new value for AP. */
4036 if (! integer_zerop (rounded_size))
4038 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
4039 build (PLUS_EXPR, TREE_TYPE (valist), valist,
4041 TREE_SIDE_EFFECTS (t) = 1;
4042 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4048 /* Expand __builtin_va_arg, which is not really a builtin function, but
4049 a very special sort of operator. */
4052 expand_builtin_va_arg (tree valist, tree type)
4055 tree promoted_type, want_va_type, have_va_type;
4057 /* Verify that valist is of the proper type. */
4059 want_va_type = va_list_type_node;
4060 have_va_type = TREE_TYPE (valist);
4061 if (TREE_CODE (want_va_type) == ARRAY_TYPE)
4063 /* If va_list is an array type, the argument may have decayed
4064 to a pointer type, e.g. by being passed to another function.
4065 In that case, unwrap both types so that we can compare the
4066 underlying records. */
4067 if (TREE_CODE (have_va_type) == ARRAY_TYPE
4068 || TREE_CODE (have_va_type) == POINTER_TYPE)
4070 want_va_type = TREE_TYPE (want_va_type);
4071 have_va_type = TREE_TYPE (have_va_type);
4074 if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
4076 error ("first argument to `va_arg' not of type `va_list'");
4080 /* Generate a diagnostic for requesting data of a type that cannot
4081 be passed through `...' due to type promotion at the call site. */
4082 else if ((promoted_type = (*lang_hooks.types.type_promotes_to) (type))
4085 const char *name = "<anonymous type>", *pname = 0;
4086 static bool gave_help;
4088 if (TYPE_NAME (type))
4090 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
4091 name = IDENTIFIER_POINTER (TYPE_NAME (type));
4092 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4093 && DECL_NAME (TYPE_NAME (type)))
4094 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
4096 if (TYPE_NAME (promoted_type))
4098 if (TREE_CODE (TYPE_NAME (promoted_type)) == IDENTIFIER_NODE)
4099 pname = IDENTIFIER_POINTER (TYPE_NAME (promoted_type));
4100 else if (TREE_CODE (TYPE_NAME (promoted_type)) == TYPE_DECL
4101 && DECL_NAME (TYPE_NAME (promoted_type)))
4102 pname = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type)));
4105 /* Unfortunately, this is merely undefined, rather than a constraint
4106 violation, so we cannot make this an error. If this call is never
4107 executed, the program is still strictly conforming. */
4108 warning ("`%s' is promoted to `%s' when passed through `...'",
4113 warning ("(so you should pass `%s' not `%s' to `va_arg')",
4117 /* We can, however, treat "undefined" any way we please.
4118 Call abort to encourage the user to fix the program. */
4119 inform ("if this code is reached, the program will abort");
4120 expand_builtin_trap ();
4122 /* This is dead code, but go ahead and finish so that the
4123 mode of the result comes out right. */
4128 /* Make it easier for the backends by protecting the valist argument
4129 from multiple evaluations. */
4130 valist = stabilize_va_list (valist, 0);
4132 #ifdef EXPAND_BUILTIN_VA_ARG
4133 addr = EXPAND_BUILTIN_VA_ARG (valist, type);
4135 addr = std_expand_builtin_va_arg (valist, type);
4139 addr = convert_memory_address (Pmode, addr);
4141 result = gen_rtx_MEM (TYPE_MODE (type), addr);
4142 set_mem_alias_set (result, get_varargs_alias_set ());
4147 /* Expand ARGLIST, from a call to __builtin_va_end. */
4150 expand_builtin_va_end (tree arglist)
4152 tree valist = TREE_VALUE (arglist);
4154 /* Evaluate for side effects, if needed. I hate macros that don't
4156 if (TREE_SIDE_EFFECTS (valist))
4157 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4162 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4163 builtin rather than just as an assignment in stdarg.h because of the
4164 nastiness of array-type va_list types. */
4167 expand_builtin_va_copy (tree arglist)
4171 dst = TREE_VALUE (arglist);
4172 src = TREE_VALUE (TREE_CHAIN (arglist));
4174 dst = stabilize_va_list (dst, 1);
4175 src = stabilize_va_list (src, 0);
4177 if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
4179 t = build (MODIFY_EXPR, va_list_type_node, dst, src);
4180 TREE_SIDE_EFFECTS (t) = 1;
4181 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4185 rtx dstb, srcb, size;
4187 /* Evaluate to pointers. */
4188 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4189 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4190 size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
4191 VOIDmode, EXPAND_NORMAL);
4193 dstb = convert_memory_address (Pmode, dstb);
4194 srcb = convert_memory_address (Pmode, srcb);
4196 /* "Dereference" to BLKmode memories. */
4197 dstb = gen_rtx_MEM (BLKmode, dstb);
4198 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4199 set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
4200 srcb = gen_rtx_MEM (BLKmode, srcb);
4201 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4202 set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
4205 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4211 /* Expand a call to one of the builtin functions __builtin_frame_address or
4212 __builtin_return_address. */
4215 expand_builtin_frame_address (tree fndecl, tree arglist)
4217 /* The argument must be a nonnegative integer constant.
4218 It counts the number of frames to scan up the stack.
4219 The value is the return address saved in that frame. */
4221 /* Warning about missing arg was already issued. */
4223 else if (! host_integerp (TREE_VALUE (arglist), 1))
4225 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4226 error ("invalid arg to `__builtin_frame_address'");
4228 error ("invalid arg to `__builtin_return_address'");
4234 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4235 tree_low_cst (TREE_VALUE (arglist), 1),
4236 hard_frame_pointer_rtx);
4238 /* Some ports cannot access arbitrary stack frames. */
4241 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4242 warning ("unsupported arg to `__builtin_frame_address'");
4244 warning ("unsupported arg to `__builtin_return_address'");
4248 /* For __builtin_frame_address, return what we've got. */
4249 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4252 if (GET_CODE (tem) != REG
4253 && ! CONSTANT_P (tem))
4254 tem = copy_to_mode_reg (Pmode, tem);
4259 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4260 we failed and the caller should emit a normal call, otherwise try to get
4261 the result in TARGET, if convenient. */
4264 expand_builtin_alloca (tree arglist, rtx target)
4269 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4272 /* Compute the argument. */
4273 op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
4275 /* Allocate the desired space. */
4276 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4277 result = convert_memory_address (ptr_mode, result);
4282 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4283 Return 0 if a normal call should be emitted rather than expanding the
4284 function in-line. If convenient, the result should be placed in TARGET.
4285 SUBTARGET may be used as the target for computing one of EXP's operands. */
4288 expand_builtin_unop (enum machine_mode target_mode, tree arglist, rtx target,
4289 rtx subtarget, optab op_optab)
4292 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4295 /* Compute the argument. */
4296 op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
4297 /* Compute op, into TARGET if possible.
4298 Set TARGET to wherever the result comes back. */
4299 target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
4300 op_optab, op0, target, 1);
4304 return convert_to_mode (target_mode, target, 0);
4307 /* If the string passed to fputs is a constant and is one character
4308 long, we attempt to transform this call into __builtin_fputc(). */
4311 expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
4314 tree fn_fputc = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4315 : implicit_built_in_decls[BUILT_IN_FPUTC];
4316 tree fn_fwrite = unlocked ? implicit_built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
4317 : implicit_built_in_decls[BUILT_IN_FWRITE];
4319 /* If the return value is used, or the replacement _DECL isn't
4320 initialized, don't do the transformation. */
4321 if (target != const0_rtx || !fn_fputc || !fn_fwrite)
4324 /* Verify the arguments in the original call. */
4325 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4328 /* Get the length of the string passed to fputs. If the length
4329 can't be determined, punt. */
4330 if (!(len = c_strlen (TREE_VALUE (arglist), 1))
4331 || TREE_CODE (len) != INTEGER_CST)
4334 switch (compare_tree_int (len, 1))
4336 case -1: /* length is 0, delete the call entirely . */
4338 /* Evaluate and ignore the argument in case it has
4340 expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
4341 VOIDmode, EXPAND_NORMAL);
4344 case 0: /* length is 1, call fputc. */
4346 const char *p = c_getstr (TREE_VALUE (arglist));
4350 /* New argument list transforming fputs(string, stream) to
4351 fputc(string[0], stream). */
4353 build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
4355 tree_cons (NULL_TREE, build_int_2 (p[0], 0), arglist);
4361 case 1: /* length is greater than 1, call fwrite. */
4365 /* If optimizing for size keep fputs. */
4368 string_arg = TREE_VALUE (arglist);
4369 /* New argument list transforming fputs(string, stream) to
4370 fwrite(string, 1, len, stream). */
4371 arglist = build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
4372 arglist = tree_cons (NULL_TREE, len, arglist);
4373 arglist = tree_cons (NULL_TREE, size_one_node, arglist);
4374 arglist = tree_cons (NULL_TREE, string_arg, arglist);
4382 return expand_expr (build_function_call_expr (fn, arglist),
4383 const0_rtx, VOIDmode, EXPAND_NORMAL);
4386 /* Expand a call to __builtin_expect. We return our argument and emit a
4387 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4388 a non-jump context. */
4391 expand_builtin_expect (tree arglist, rtx target)
4396 if (arglist == NULL_TREE
4397 || TREE_CHAIN (arglist) == NULL_TREE)
4399 exp = TREE_VALUE (arglist);
4400 c = TREE_VALUE (TREE_CHAIN (arglist));
4402 if (TREE_CODE (c) != INTEGER_CST)
4404 error ("second arg to `__builtin_expect' must be a constant");
4405 c = integer_zero_node;
4408 target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
4410 /* Don't bother with expected value notes for integral constants. */
4411 if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
4413 /* We do need to force this into a register so that we can be
4414 moderately sure to be able to correctly interpret the branch
4416 target = force_reg (GET_MODE (target), target);
4418 rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
4420 note = emit_note (NOTE_INSN_EXPECTED_VALUE);
4421 NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
4427 /* Like expand_builtin_expect, except do this in a jump context. This is
4428 called from do_jump if the conditional is a __builtin_expect. Return either
4429 a list of insns to emit the jump or NULL if we cannot optimize
4430 __builtin_expect. We need to optimize this at jump time so that machines
4431 like the PowerPC don't turn the test into a SCC operation, and then jump
4432 based on the test being 0/1. */
4435 expand_builtin_expect_jump (tree exp, rtx if_false_label, rtx if_true_label)
4437 tree arglist = TREE_OPERAND (exp, 1);
4438 tree arg0 = TREE_VALUE (arglist);
4439 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
4442 /* Only handle __builtin_expect (test, 0) and
4443 __builtin_expect (test, 1). */
4444 if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
4445 && (integer_zerop (arg1) || integer_onep (arg1)))
4447 rtx insn, drop_through_label, temp;
4449 /* Expand the jump insns. */
4451 do_jump (arg0, if_false_label, if_true_label);
4454 drop_through_label = get_last_insn ();
4455 if (drop_through_label && GET_CODE (drop_through_label) == NOTE)
4456 drop_through_label = prev_nonnote_insn (drop_through_label);
4457 if (drop_through_label && GET_CODE (drop_through_label) != CODE_LABEL)
4458 drop_through_label = NULL_RTX;
4461 if (! if_true_label)
4462 if_true_label = drop_through_label;
4463 if (! if_false_label)
4464 if_false_label = drop_through_label;
4466 /* Go through and add the expect's to each of the conditional jumps. */
4468 while (insn != NULL_RTX)
4470 rtx next = NEXT_INSN (insn);
4472 if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn))
4474 rtx ifelse = SET_SRC (pc_set (insn));
4475 rtx then_dest = XEXP (ifelse, 1);
4476 rtx else_dest = XEXP (ifelse, 2);
4479 /* First check if we recognize any of the labels. */
4480 if (GET_CODE (then_dest) == LABEL_REF
4481 && XEXP (then_dest, 0) == if_true_label)
4483 else if (GET_CODE (then_dest) == LABEL_REF
4484 && XEXP (then_dest, 0) == if_false_label)
4486 else if (GET_CODE (else_dest) == LABEL_REF
4487 && XEXP (else_dest, 0) == if_false_label)
4489 else if (GET_CODE (else_dest) == LABEL_REF
4490 && XEXP (else_dest, 0) == if_true_label)
4492 /* Otherwise check where we drop through. */
4493 else if (else_dest == pc_rtx)
4495 if (next && GET_CODE (next) == NOTE)
4496 next = next_nonnote_insn (next);
4498 if (next && GET_CODE (next) == JUMP_INSN
4499 && any_uncondjump_p (next))
4500 temp = XEXP (SET_SRC (pc_set (next)), 0);
4504 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4505 else that can't possibly match either target label. */
4506 if (temp == if_false_label)
4508 else if (temp == if_true_label)
4511 else if (then_dest == pc_rtx)
4513 if (next && GET_CODE (next) == NOTE)
4514 next = next_nonnote_insn (next);
4516 if (next && GET_CODE (next) == JUMP_INSN
4517 && any_uncondjump_p (next))
4518 temp = XEXP (SET_SRC (pc_set (next)), 0);
4522 if (temp == if_false_label)
4524 else if (temp == if_true_label)
4530 /* If the test is expected to fail, reverse the
4532 if (integer_zerop (arg1))
4534 predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
4546 expand_builtin_trap (void)
4550 emit_insn (gen_trap ());
4553 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4557 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4558 Return 0 if a normal call should be emitted rather than expanding
4559 the function inline. If convenient, the result should be placed
4560 in TARGET. SUBTARGET may be used as the target for computing
4564 expand_builtin_fabs (tree arglist, rtx target, rtx subtarget)
4566 enum machine_mode mode;
4570 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4573 arg = TREE_VALUE (arglist);
4574 mode = TYPE_MODE (TREE_TYPE (arg));
4575 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
4576 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4579 /* Expand a call to cabs, cabsf or cabsl with arguments ARGLIST.
4580 Return 0 if a normal call should be emitted rather than expanding
4581 the function inline. If convenient, the result should be placed
4585 expand_builtin_cabs (tree arglist, rtx target)
4587 enum machine_mode mode;
4591 if (arglist == 0 || TREE_CHAIN (arglist))
4593 arg = TREE_VALUE (arglist);
4594 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
4595 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
4598 mode = TYPE_MODE (TREE_TYPE (arg));
4599 op0 = expand_expr (arg, NULL_RTX, VOIDmode, 0);
4600 return expand_complex_abs (mode, op0, target, 0);
4603 /* Create a new constant string literal and return a char* pointer to it.
4604 The STRING_CST value is the LEN characters at STR. */
4606 build_string_literal (int len, const char *str)
4608 tree t, elem, index, type;
4610 t = build_string (len, str);
4611 elem = build_type_variant (char_type_node, 1, 0);
4612 index = build_index_type (build_int_2 (len - 1, 0));
4613 type = build_array_type (elem, index);
4614 TREE_TYPE (t) = type;
4615 TREE_CONSTANT (t) = 1;
4616 TREE_READONLY (t) = 1;
4617 TREE_STATIC (t) = 1;
4619 type = build_pointer_type (type);
4620 t = build1 (ADDR_EXPR, type, t);
4622 type = build_pointer_type (elem);
4623 t = build1 (NOP_EXPR, type, t);
4627 /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
4628 Return 0 if a normal call should be emitted rather than transforming
4629 the function inline. If convenient, the result should be placed in
4630 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4633 expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode,
4636 tree fn_putchar = unlocked
4637 ? implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
4638 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4639 tree fn_puts = unlocked ? implicit_built_in_decls[BUILT_IN_PUTS_UNLOCKED]
4640 : implicit_built_in_decls[BUILT_IN_PUTS];
4641 const char *fmt_str;
4644 /* If the return value is used, don't do the transformation. */
4645 if (target != const0_rtx)
4648 /* Verify the required arguments in the original call. */
4651 fmt = TREE_VALUE (arglist);
4652 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4654 arglist = TREE_CHAIN (arglist);
4656 /* Check whether the format is a literal string constant. */
4657 fmt_str = c_getstr (fmt);
4658 if (fmt_str == NULL)
4661 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4662 if (strcmp (fmt_str, "%s\n") == 0)
4665 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
4666 || TREE_CHAIN (arglist))
4670 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4671 else if (strcmp (fmt_str, "%c") == 0)
4674 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4675 || TREE_CHAIN (arglist))
4681 /* We can't handle anything else with % args or %% ... yet. */
4682 if (strchr (fmt_str, '%'))
4688 /* If the format specifier was "", printf does nothing. */
4689 if (fmt_str[0] == '\0')
4691 /* If the format specifier has length of 1, call putchar. */
4692 if (fmt_str[1] == '\0')
4694 /* Given printf("c"), (where c is any one character,)
4695 convert "c"[0] to an int and pass that to the replacement
4697 arg = build_int_2 (fmt_str[0], 0);
4698 arglist = build_tree_list (NULL_TREE, arg);
4703 /* If the format specifier was "string\n", call puts("string"). */
4704 size_t len = strlen (fmt_str);
4705 if (fmt_str[len - 1] == '\n')
4707 /* Create a NUL-terminated string that's one char shorter
4708 than the original, stripping off the trailing '\n'. */
4709 char *newstr = (char *) alloca (len);
4710 memcpy (newstr, fmt_str, len - 1);
4711 newstr[len - 1] = 0;
4713 arg = build_string_literal (len, newstr);
4714 arglist = build_tree_list (NULL_TREE, arg);
4718 /* We'd like to arrange to call fputs(string,stdout) here,
4719 but we need stdout and don't have a way to get it yet. */
4726 return expand_expr (build_function_call_expr (fn, arglist),
4727 target, mode, EXPAND_NORMAL);
4730 /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
4731 Return 0 if a normal call should be emitted rather than transforming
4732 the function inline. If convenient, the result should be placed in
4733 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4736 expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode,
4739 tree fn_fputc = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4740 : implicit_built_in_decls[BUILT_IN_FPUTC];
4741 tree fn_fputs = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
4742 : implicit_built_in_decls[BUILT_IN_FPUTS];
4743 const char *fmt_str;
4744 tree fn, fmt, fp, arg;
4746 /* If the return value is used, don't do the transformation. */
4747 if (target != const0_rtx)
4750 /* Verify the required arguments in the original call. */
4753 fp = TREE_VALUE (arglist);
4754 if (TREE_CODE (TREE_TYPE (fp)) != POINTER_TYPE)
4756 arglist = TREE_CHAIN (arglist);
4759 fmt = TREE_VALUE (arglist);
4760 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4762 arglist = TREE_CHAIN (arglist);
4764 /* Check whether the format is a literal string constant. */
4765 fmt_str = c_getstr (fmt);
4766 if (fmt_str == NULL)
4769 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
4770 if (strcmp (fmt_str, "%s") == 0)
4773 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
4774 || TREE_CHAIN (arglist))
4776 arg = TREE_VALUE (arglist);
4777 arglist = build_tree_list (NULL_TREE, fp);
4778 arglist = tree_cons (NULL_TREE, arg, arglist);
4781 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
4782 else if (strcmp (fmt_str, "%c") == 0)
4785 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4786 || TREE_CHAIN (arglist))
4788 arg = TREE_VALUE (arglist);
4789 arglist = build_tree_list (NULL_TREE, fp);
4790 arglist = tree_cons (NULL_TREE, arg, arglist);
4795 /* We can't handle anything else with % args or %% ... yet. */
4796 if (strchr (fmt_str, '%'))
4802 /* If the format specifier was "", fprintf does nothing. */
4803 if (fmt_str[0] == '\0')
4805 /* Evaluate and ignore FILE* argument for side-effects. */
4806 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
4810 /* When "string" doesn't contain %, replace all cases of
4811 fprintf(stream,string) with fputs(string,stream). The fputs
4812 builtin will take care of special cases like length == 1. */
4813 arglist = build_tree_list (NULL_TREE, fp);
4814 arglist = tree_cons (NULL_TREE, fmt, arglist);
4820 return expand_expr (build_function_call_expr (fn, arglist),
4821 target, mode, EXPAND_NORMAL);
4824 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
4825 a normal call should be emitted rather than expanding the function
4826 inline. If convenient, the result should be placed in TARGET with
4830 expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
4832 tree orig_arglist, dest, fmt;
4833 const char *fmt_str;
4835 orig_arglist = arglist;
4837 /* Verify the required arguments in the original call. */
4840 dest = TREE_VALUE (arglist);
4841 if (TREE_CODE (TREE_TYPE (dest)) != POINTER_TYPE)
4843 arglist = TREE_CHAIN (arglist);
4846 fmt = TREE_VALUE (arglist);
4847 if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
4849 arglist = TREE_CHAIN (arglist);
4851 /* Check whether the format is a literal string constant. */
4852 fmt_str = c_getstr (fmt);
4853 if (fmt_str == NULL)
4856 /* If the format doesn't contain % args or %%, use strcpy. */
4857 if (strchr (fmt_str, '%') == 0)
4859 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
4862 if (arglist || ! fn)
4864 expand_expr (build_function_call_expr (fn, orig_arglist),
4865 const0_rtx, VOIDmode, EXPAND_NORMAL);
4866 if (target == const0_rtx)
4868 exp = build_int_2 (strlen (fmt_str), 0);
4869 exp = fold (build1 (NOP_EXPR, integer_type_node, exp));
4870 return expand_expr (exp, target, mode, EXPAND_NORMAL);
4872 /* If the format is "%s", use strcpy if the result isn't used. */
4873 else if (strcmp (fmt_str, "%s") == 0)
4876 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
4881 if (! arglist || TREE_CHAIN (arglist))
4883 arg = TREE_VALUE (arglist);
4884 if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
4887 if (target != const0_rtx)
4889 len = c_strlen (arg, 1);
4890 if (! len || TREE_CODE (len) != INTEGER_CST)
4896 arglist = build_tree_list (NULL_TREE, arg);
4897 arglist = tree_cons (NULL_TREE, dest, arglist);
4898 expand_expr (build_function_call_expr (fn, arglist),
4899 const0_rtx, VOIDmode, EXPAND_NORMAL);
4901 if (target == const0_rtx)
4903 return expand_expr (len, target, mode, EXPAND_NORMAL);
4909 /* Expand a call to the built-in signbit, signbitf or signbitl function.
4910 Return NULL_RTX if a normal call should be emitted rather than expanding
4911 the function in-line. EXP is the expression that is a call to the builtin
4912 function; if convenient, the result should be placed in TARGET. */
4915 expand_builtin_signbit (tree exp, rtx target)
4917 const struct real_format *fmt;
4918 enum machine_mode fmode, imode, rmode;
4919 HOST_WIDE_INT hi, lo;
4924 arglist = TREE_OPERAND (exp, 1);
4925 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4928 arg = TREE_VALUE (arglist);
4929 fmode = TYPE_MODE (TREE_TYPE (arg));
4930 rmode = TYPE_MODE (TREE_TYPE (exp));
4931 fmt = REAL_MODE_FORMAT (fmode);
4933 /* For floating point formats without a sign bit, implement signbit
4935 if (fmt->signbit < 0)
4937 /* But we can't do this if the format supports signed zero. */
4938 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
4941 arg = fold (build (LT_EXPR, TREE_TYPE (exp), arg,
4942 build_real (TREE_TYPE (arg), dconst0)));
4943 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4946 imode = int_mode_for_mode (fmode);
4947 if (imode == BLKmode)
4950 bitpos = fmt->signbit;
4951 /* Handle targets with different FP word orders. */
4952 if (FLOAT_WORDS_BIG_ENDIAN != WORDS_BIG_ENDIAN)
4954 int nwords = GET_MODE_BITSIZE (fmode) / BITS_PER_WORD;
4955 int word = nwords - (bitpos / BITS_PER_WORD) - 1;
4956 bitpos = word * BITS_PER_WORD + bitpos % BITS_PER_WORD;
4959 /* If the sign bit is not in the lowpart and the floating point format
4960 is wider than an integer, check that is twice the size of an integer
4961 so that we can use gen_highpart below. */
4962 if (bitpos >= GET_MODE_BITSIZE (rmode)
4963 && GET_MODE_BITSIZE (imode) != 2 * GET_MODE_BITSIZE (rmode))
4966 temp = expand_expr (arg, NULL_RTX, VOIDmode, 0);
4967 temp = gen_lowpart (imode, temp);
4969 if (GET_MODE_BITSIZE (imode) > GET_MODE_BITSIZE (rmode))
4971 if (BITS_BIG_ENDIAN)
4972 bitpos = GET_MODE_BITSIZE (imode) - 1 - bitpos;
4973 temp = copy_to_mode_reg (imode, temp);
4974 temp = extract_bit_field (temp, 1, bitpos, 1,
4975 NULL_RTX, rmode, rmode,
4976 GET_MODE_SIZE (imode));
4980 if (GET_MODE_BITSIZE (imode) < GET_MODE_BITSIZE (rmode))
4981 temp = gen_lowpart (rmode, temp);
4982 if (bitpos < HOST_BITS_PER_WIDE_INT)
4985 lo = (HOST_WIDE_INT) 1 << bitpos;
4989 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
4993 temp = force_reg (rmode, temp);
4994 temp = expand_binop (rmode, and_optab, temp,
4995 immed_double_const (lo, hi, rmode),
4996 target, 1, OPTAB_LIB_WIDEN);
5001 /* Expand an expression EXP that calls a built-in function,
5002 with result going to TARGET if that's convenient
5003 (and in mode MODE if that's convenient).
5004 SUBTARGET may be used as the target for computing one of EXP's operands.
5005 IGNORE is nonzero if the value is to be ignored. */
5008 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5011 tree fndecl = get_callee_fndecl (exp);
5012 tree arglist = TREE_OPERAND (exp, 1);
5013 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5014 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5016 /* Perform postincrements before expanding builtin functions. */
5019 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5020 return (*targetm.expand_builtin) (exp, target, subtarget, mode, ignore);
5022 /* When not optimizing, generate calls to library functions for a certain
5025 && !CALLED_AS_BUILT_IN (fndecl)
5026 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5027 && fcode != BUILT_IN_ALLOCA)
5028 return expand_call (exp, target, ignore);
5030 /* The built-in function expanders test for target == const0_rtx
5031 to determine whether the function's result will be ignored. */
5033 target = const0_rtx;
5035 /* If the result of a pure or const built-in function is ignored, and
5036 none of its arguments are volatile, we can avoid expanding the
5037 built-in call and just evaluate the arguments for side-effects. */
5038 if (target == const0_rtx
5039 && (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
5041 bool volatilep = false;
5044 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5045 if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
5053 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5054 expand_expr (TREE_VALUE (arg), const0_rtx,
5055 VOIDmode, EXPAND_NORMAL);
5064 case BUILT_IN_LLABS:
5065 case BUILT_IN_IMAXABS:
5066 /* build_function_call changes these into ABS_EXPR. */
5070 case BUILT_IN_FABSF:
5071 case BUILT_IN_FABSL:
5072 target = expand_builtin_fabs (arglist, target, subtarget);
5078 case BUILT_IN_CABSF:
5079 case BUILT_IN_CABSL:
5080 if (flag_unsafe_math_optimizations)
5082 target = expand_builtin_cabs (arglist, target);
5089 case BUILT_IN_CONJF:
5090 case BUILT_IN_CONJL:
5091 case BUILT_IN_CREAL:
5092 case BUILT_IN_CREALF:
5093 case BUILT_IN_CREALL:
5094 case BUILT_IN_CIMAG:
5095 case BUILT_IN_CIMAGF:
5096 case BUILT_IN_CIMAGL:
5097 /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
5098 and IMAGPART_EXPR. */
5113 case BUILT_IN_LOG10:
5114 case BUILT_IN_LOG10F:
5115 case BUILT_IN_LOG10L:
5117 case BUILT_IN_LOG2F:
5118 case BUILT_IN_LOG2L:
5123 case BUILT_IN_ATANF:
5124 case BUILT_IN_ATANL:
5125 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5126 because of possible accuracy problems. */
5127 if (! flag_unsafe_math_optimizations)
5130 case BUILT_IN_SQRTF:
5131 case BUILT_IN_SQRTL:
5132 case BUILT_IN_FLOOR:
5133 case BUILT_IN_FLOORF:
5134 case BUILT_IN_FLOORL:
5136 case BUILT_IN_CEILF:
5137 case BUILT_IN_CEILL:
5138 case BUILT_IN_TRUNC:
5139 case BUILT_IN_TRUNCF:
5140 case BUILT_IN_TRUNCL:
5141 case BUILT_IN_ROUND:
5142 case BUILT_IN_ROUNDF:
5143 case BUILT_IN_ROUNDL:
5144 case BUILT_IN_NEARBYINT:
5145 case BUILT_IN_NEARBYINTF:
5146 case BUILT_IN_NEARBYINTL:
5147 target = expand_builtin_mathfn (exp, target, subtarget);
5155 target = expand_builtin_pow (exp, target, subtarget);
5160 case BUILT_IN_ATAN2:
5161 case BUILT_IN_ATAN2F:
5162 case BUILT_IN_ATAN2L:
5163 if (! flag_unsafe_math_optimizations)
5165 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5170 case BUILT_IN_APPLY_ARGS:
5171 return expand_builtin_apply_args ();
5173 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5174 FUNCTION with a copy of the parameters described by
5175 ARGUMENTS, and ARGSIZE. It returns a block of memory
5176 allocated on the stack into which is stored all the registers
5177 that might possibly be used for returning the result of a
5178 function. ARGUMENTS is the value returned by
5179 __builtin_apply_args. ARGSIZE is the number of bytes of
5180 arguments that must be copied. ??? How should this value be
5181 computed? We'll also need a safe worst case value for varargs
5183 case BUILT_IN_APPLY:
5184 if (!validate_arglist (arglist, POINTER_TYPE,
5185 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5186 && !validate_arglist (arglist, REFERENCE_TYPE,
5187 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5195 for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
5196 ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
5198 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5201 /* __builtin_return (RESULT) causes the function to return the
5202 value described by RESULT. RESULT is address of the block of
5203 memory returned by __builtin_apply. */
5204 case BUILT_IN_RETURN:
5205 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5206 expand_builtin_return (expand_expr (TREE_VALUE (arglist),
5207 NULL_RTX, VOIDmode, 0));
5210 case BUILT_IN_SAVEREGS:
5211 return expand_builtin_saveregs ();
5213 case BUILT_IN_ARGS_INFO:
5214 return expand_builtin_args_info (arglist);
5216 /* Return the address of the first anonymous stack arg. */
5217 case BUILT_IN_NEXT_ARG:
5218 return expand_builtin_next_arg (arglist);
5220 case BUILT_IN_CLASSIFY_TYPE:
5221 return expand_builtin_classify_type (arglist);
5223 case BUILT_IN_CONSTANT_P:
5224 return expand_builtin_constant_p (arglist, target_mode);
5226 case BUILT_IN_FRAME_ADDRESS:
5227 case BUILT_IN_RETURN_ADDRESS:
5228 return expand_builtin_frame_address (fndecl, arglist);
5230 /* Returns the address of the area where the structure is returned.
5232 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5234 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5235 || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
5238 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5240 case BUILT_IN_ALLOCA:
5241 target = expand_builtin_alloca (arglist, target);
5248 case BUILT_IN_FFSLL:
5249 target = expand_builtin_unop (target_mode, arglist, target,
5250 subtarget, ffs_optab);
5257 case BUILT_IN_CLZLL:
5258 target = expand_builtin_unop (target_mode, arglist, target,
5259 subtarget, clz_optab);
5266 case BUILT_IN_CTZLL:
5267 target = expand_builtin_unop (target_mode, arglist, target,
5268 subtarget, ctz_optab);
5273 case BUILT_IN_POPCOUNT:
5274 case BUILT_IN_POPCOUNTL:
5275 case BUILT_IN_POPCOUNTLL:
5276 target = expand_builtin_unop (target_mode, arglist, target,
5277 subtarget, popcount_optab);
5282 case BUILT_IN_PARITY:
5283 case BUILT_IN_PARITYL:
5284 case BUILT_IN_PARITYLL:
5285 target = expand_builtin_unop (target_mode, arglist, target,
5286 subtarget, parity_optab);
5291 case BUILT_IN_STRLEN:
5292 target = expand_builtin_strlen (arglist, target, target_mode);
5297 case BUILT_IN_STRCPY:
5298 target = expand_builtin_strcpy (arglist, target, mode);
5303 case BUILT_IN_STRNCPY:
5304 target = expand_builtin_strncpy (arglist, target, mode);
5309 case BUILT_IN_STPCPY:
5310 target = expand_builtin_stpcpy (arglist, target, mode);
5315 case BUILT_IN_STRCAT:
5316 target = expand_builtin_strcat (arglist, target, mode);
5321 case BUILT_IN_STRNCAT:
5322 target = expand_builtin_strncat (arglist, target, mode);
5327 case BUILT_IN_STRSPN:
5328 target = expand_builtin_strspn (arglist, target, mode);
5333 case BUILT_IN_STRCSPN:
5334 target = expand_builtin_strcspn (arglist, target, mode);
5339 case BUILT_IN_STRSTR:
5340 target = expand_builtin_strstr (arglist, target, mode);
5345 case BUILT_IN_STRPBRK:
5346 target = expand_builtin_strpbrk (arglist, target, mode);
5351 case BUILT_IN_INDEX:
5352 case BUILT_IN_STRCHR:
5353 target = expand_builtin_strchr (arglist, target, mode);
5358 case BUILT_IN_RINDEX:
5359 case BUILT_IN_STRRCHR:
5360 target = expand_builtin_strrchr (arglist, target, mode);
5365 case BUILT_IN_MEMCPY:
5366 target = expand_builtin_memcpy (arglist, target, mode);
5371 case BUILT_IN_MEMPCPY:
5372 target = expand_builtin_mempcpy (arglist, target, mode, /*endp=*/ 1);
5377 case BUILT_IN_MEMMOVE:
5378 target = expand_builtin_memmove (arglist, target, mode);
5383 case BUILT_IN_BCOPY:
5384 target = expand_builtin_bcopy (arglist);
5389 case BUILT_IN_MEMSET:
5390 target = expand_builtin_memset (arglist, target, mode);
5395 case BUILT_IN_BZERO:
5396 target = expand_builtin_bzero (arglist);
5401 case BUILT_IN_STRCMP:
5402 target = expand_builtin_strcmp (exp, target, mode);
5407 case BUILT_IN_STRNCMP:
5408 target = expand_builtin_strncmp (exp, target, mode);
5414 case BUILT_IN_MEMCMP:
5415 target = expand_builtin_memcmp (exp, arglist, target, mode);
5420 case BUILT_IN_SETJMP:
5421 target = expand_builtin_setjmp (arglist, target);
5426 /* __builtin_longjmp is passed a pointer to an array of five words.
5427 It's similar to the C library longjmp function but works with
5428 __builtin_setjmp above. */
5429 case BUILT_IN_LONGJMP:
5430 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5434 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
5436 rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
5437 NULL_RTX, VOIDmode, 0);
5439 if (value != const1_rtx)
5441 error ("__builtin_longjmp second argument must be 1");
5445 expand_builtin_longjmp (buf_addr, value);
5450 expand_builtin_trap ();
5453 case BUILT_IN_PRINTF:
5454 target = expand_builtin_printf (arglist, target, mode, false);
5459 case BUILT_IN_PRINTF_UNLOCKED:
5460 target = expand_builtin_printf (arglist, target, mode, true);
5465 case BUILT_IN_FPUTS:
5466 target = expand_builtin_fputs (arglist, target, false);
5471 case BUILT_IN_FPUTS_UNLOCKED:
5472 target = expand_builtin_fputs (arglist, target, true);
5477 case BUILT_IN_FPRINTF:
5478 target = expand_builtin_fprintf (arglist, target, mode, false);
5483 case BUILT_IN_FPRINTF_UNLOCKED:
5484 target = expand_builtin_fprintf (arglist, target, mode, true);
5489 case BUILT_IN_SPRINTF:
5490 target = expand_builtin_sprintf (arglist, target, mode);
5495 case BUILT_IN_SIGNBIT:
5496 case BUILT_IN_SIGNBITF:
5497 case BUILT_IN_SIGNBITL:
5498 target = expand_builtin_signbit (exp, target);
5503 /* Various hooks for the DWARF 2 __throw routine. */
5504 case BUILT_IN_UNWIND_INIT:
5505 expand_builtin_unwind_init ();
5507 case BUILT_IN_DWARF_CFA:
5508 return virtual_cfa_rtx;
5509 #ifdef DWARF2_UNWIND_INFO
5510 case BUILT_IN_DWARF_SP_COLUMN:
5511 return expand_builtin_dwarf_sp_column ();
5512 case BUILT_IN_INIT_DWARF_REG_SIZES:
5513 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
5516 case BUILT_IN_FROB_RETURN_ADDR:
5517 return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
5518 case BUILT_IN_EXTRACT_RETURN_ADDR:
5519 return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
5520 case BUILT_IN_EH_RETURN:
5521 expand_builtin_eh_return (TREE_VALUE (arglist),
5522 TREE_VALUE (TREE_CHAIN (arglist)));
5524 #ifdef EH_RETURN_DATA_REGNO
5525 case BUILT_IN_EH_RETURN_DATA_REGNO:
5526 return expand_builtin_eh_return_data_regno (arglist);
5528 case BUILT_IN_EXTEND_POINTER:
5529 return expand_builtin_extend_pointer (TREE_VALUE (arglist));
5531 case BUILT_IN_VA_START:
5532 case BUILT_IN_STDARG_START:
5533 return expand_builtin_va_start (arglist);
5534 case BUILT_IN_VA_END:
5535 return expand_builtin_va_end (arglist);
5536 case BUILT_IN_VA_COPY:
5537 return expand_builtin_va_copy (arglist);
5538 case BUILT_IN_EXPECT:
5539 return expand_builtin_expect (arglist, target);
5540 case BUILT_IN_PREFETCH:
5541 expand_builtin_prefetch (arglist);
5545 default: /* just do library call, if unknown builtin */
5546 if (!DECL_ASSEMBLER_NAME_SET_P (fndecl))
5547 error ("built-in function `%s' not currently supported",
5548 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
5551 /* The switch statement above can drop through to cause the function
5552 to be called normally. */
5553 return expand_call (exp, target, ignore);
5556 /* Determine whether a tree node represents a call to a built-in
5557 function. If the tree T is a call to a built-in function with
5558 the right number of arguments of the appropriate types, return
5559 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
5560 Otherwise the return value is END_BUILTINS. */
5562 enum built_in_function
5563 builtin_mathfn_code (tree t)
5565 tree fndecl, arglist, parmlist;
5566 tree argtype, parmtype;
5568 if (TREE_CODE (t) != CALL_EXPR
5569 || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
5570 return END_BUILTINS;
5572 fndecl = get_callee_fndecl (t);
5573 if (fndecl == NULL_TREE
5574 || TREE_CODE (fndecl) != FUNCTION_DECL
5575 || ! DECL_BUILT_IN (fndecl)
5576 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5577 return END_BUILTINS;
5579 arglist = TREE_OPERAND (t, 1);
5580 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5581 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
5583 /* If a function doesn't take a variable number of arguments,
5584 the last element in the list will have type `void'. */
5585 parmtype = TREE_VALUE (parmlist);
5586 if (VOID_TYPE_P (parmtype))
5589 return END_BUILTINS;
5590 return DECL_FUNCTION_CODE (fndecl);
5594 return END_BUILTINS;
5596 argtype = TREE_TYPE (TREE_VALUE (arglist));
5598 if (SCALAR_FLOAT_TYPE_P (parmtype))
5600 if (! SCALAR_FLOAT_TYPE_P (argtype))
5601 return END_BUILTINS;
5603 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
5605 if (! COMPLEX_FLOAT_TYPE_P (argtype))
5606 return END_BUILTINS;
5608 else if (POINTER_TYPE_P (parmtype))
5610 if (! POINTER_TYPE_P (argtype))
5611 return END_BUILTINS;
5613 else if (INTEGRAL_TYPE_P (parmtype))
5615 if (! INTEGRAL_TYPE_P (argtype))
5616 return END_BUILTINS;
5619 return END_BUILTINS;
5621 arglist = TREE_CHAIN (arglist);
5624 /* Variable-length argument list. */
5625 return DECL_FUNCTION_CODE (fndecl);
5628 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
5629 constant. ARGLIST is the argument list of the call. */
5632 fold_builtin_constant_p (tree arglist)
5637 arglist = TREE_VALUE (arglist);
5639 /* We return 1 for a numeric type that's known to be a constant
5640 value at compile-time or for an aggregate type that's a
5641 literal constant. */
5642 STRIP_NOPS (arglist);
5644 /* If we know this is a constant, emit the constant of one. */
5645 if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
5646 || (TREE_CODE (arglist) == CONSTRUCTOR
5647 && TREE_CONSTANT (arglist))
5648 || (TREE_CODE (arglist) == ADDR_EXPR
5649 && TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST))
5650 return integer_one_node;
5652 /* If this expression has side effects, show we don't know it to be a
5653 constant. Likewise if it's a pointer or aggregate type since in
5654 those case we only want literals, since those are only optimized
5655 when generating RTL, not later.
5656 And finally, if we are compiling an initializer, not code, we
5657 need to return a definite result now; there's not going to be any
5658 more optimization done. */
5659 if (TREE_SIDE_EFFECTS (arglist)
5660 || AGGREGATE_TYPE_P (TREE_TYPE (arglist))
5661 || POINTER_TYPE_P (TREE_TYPE (arglist))
5663 return integer_zero_node;
5668 /* Fold a call to __builtin_classify_type. */
5671 fold_builtin_classify_type (tree arglist)
5674 return build_int_2 (no_type_class, 0);
5676 return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
5679 /* Fold a call to __builtin_inf or __builtin_huge_val. */
5682 fold_builtin_inf (tree type, int warn)
5684 REAL_VALUE_TYPE real;
5686 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
5687 warning ("target format does not support infinity");
5690 return build_real (type, real);
5693 /* Fold a call to __builtin_nan or __builtin_nans. */
5696 fold_builtin_nan (tree arglist, tree type, int quiet)
5698 REAL_VALUE_TYPE real;
5701 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5703 str = c_getstr (TREE_VALUE (arglist));
5707 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
5710 return build_real (type, real);
5713 /* Return true if the floating point expression T has an integer value.
5714 We also allow +Inf, -Inf and NaN to be considered integer values. */
5717 integer_valued_real_p (tree t)
5719 switch (TREE_CODE (t))
5726 case NON_LVALUE_EXPR:
5727 return integer_valued_real_p (TREE_OPERAND (t, 0));
5732 return integer_valued_real_p (TREE_OPERAND (t, 1));
5739 return integer_valued_real_p (TREE_OPERAND (t, 0))
5740 && integer_valued_real_p (TREE_OPERAND (t, 1));
5743 return integer_valued_real_p (TREE_OPERAND (t, 1))
5744 && integer_valued_real_p (TREE_OPERAND (t, 2));
5747 if (! TREE_CONSTANT_OVERFLOW (t))
5749 REAL_VALUE_TYPE c, cint;
5751 c = TREE_REAL_CST (t);
5752 real_trunc (&cint, TYPE_MODE (TREE_TYPE (t)), &c);
5753 return real_identical (&c, &cint);
5758 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
5759 if (TREE_CODE (type) == INTEGER_TYPE)
5761 if (TREE_CODE (type) == REAL_TYPE)
5762 return integer_valued_real_p (TREE_OPERAND (t, 0));
5767 switch (builtin_mathfn_code (t))
5770 case BUILT_IN_CEILF:
5771 case BUILT_IN_CEILL:
5772 case BUILT_IN_FLOOR:
5773 case BUILT_IN_FLOORF:
5774 case BUILT_IN_FLOORL:
5775 case BUILT_IN_NEARBYINT:
5776 case BUILT_IN_NEARBYINTF:
5777 case BUILT_IN_NEARBYINTL:
5778 case BUILT_IN_ROUND:
5779 case BUILT_IN_ROUNDF:
5780 case BUILT_IN_ROUNDL:
5781 case BUILT_IN_TRUNC:
5782 case BUILT_IN_TRUNCF:
5783 case BUILT_IN_TRUNCL:
5797 /* EXP is assumed to be builtin call where truncation can be propagated
5798 across (for instance floor((double)f) == (double)floorf (f).
5799 Do the transformation. */
5802 fold_trunc_transparent_mathfn (tree exp)
5804 tree fndecl = get_callee_fndecl (exp);
5805 tree arglist = TREE_OPERAND (exp, 1);
5806 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5809 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5812 arg = TREE_VALUE (arglist);
5813 /* Integer rounding functions are idempotent. */
5814 if (fcode == builtin_mathfn_code (arg))
5817 /* If argument is already integer valued, and we don't need to worry
5818 about setting errno, there's no need to perform rounding. */
5819 if (! flag_errno_math && integer_valued_real_p (arg))
5824 tree arg0 = strip_float_extensions (arg);
5825 tree ftype = TREE_TYPE (exp);
5826 tree newtype = TREE_TYPE (arg0);
5829 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
5830 && (decl = mathfn_built_in (newtype, fcode)))
5833 build_tree_list (NULL_TREE, fold (convert (newtype, arg0)));
5834 return convert (ftype,
5835 build_function_call_expr (decl, arglist));
5841 /* Fold function call to builtin cabs, cabsf or cabsl. FNDECL is the
5842 function's DECL, ARGLIST is the argument list and TYPE is the return
5843 type. Return NULL_TREE if no simplification can be made. */
5846 fold_builtin_cabs (tree fndecl, tree arglist, tree type)
5850 if (!arglist || TREE_CHAIN (arglist))
5853 arg = TREE_VALUE (arglist);
5854 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
5855 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
5858 /* Evaluate cabs of a constant at compile-time. */
5859 if (flag_unsafe_math_optimizations
5860 && TREE_CODE (arg) == COMPLEX_CST
5861 && TREE_CODE (TREE_REALPART (arg)) == REAL_CST
5862 && TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
5863 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
5864 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
5866 REAL_VALUE_TYPE r, i;
5868 r = TREE_REAL_CST (TREE_REALPART (arg));
5869 i = TREE_REAL_CST (TREE_IMAGPART (arg));
5871 real_arithmetic (&r, MULT_EXPR, &r, &r);
5872 real_arithmetic (&i, MULT_EXPR, &i, &i);
5873 real_arithmetic (&r, PLUS_EXPR, &r, &i);
5874 if (real_sqrt (&r, TYPE_MODE (type), &r)
5875 || ! flag_trapping_math)
5876 return build_real (type, r);
5879 /* If either part is zero, cabs is fabs of the other. */
5880 if (TREE_CODE (arg) == COMPLEX_EXPR
5881 && real_zerop (TREE_OPERAND (arg, 0)))
5882 return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1)));
5883 if (TREE_CODE (arg) == COMPLEX_EXPR
5884 && real_zerop (TREE_OPERAND (arg, 1)))
5885 return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0)));
5887 if (flag_unsafe_math_optimizations)
5889 enum built_in_function fcode;
5892 fcode = DECL_FUNCTION_CODE (fndecl);
5893 if (fcode == BUILT_IN_CABS)
5894 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
5895 else if (fcode == BUILT_IN_CABSF)
5896 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
5897 else if (fcode == BUILT_IN_CABSL)
5898 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
5902 if (sqrtfn != NULL_TREE)
5904 tree rpart, ipart, result, arglist;
5906 arg = save_expr (arg);
5908 rpart = fold (build1 (REALPART_EXPR, type, arg));
5909 ipart = fold (build1 (IMAGPART_EXPR, type, arg));
5911 rpart = save_expr (rpart);
5912 ipart = save_expr (ipart);
5914 result = fold (build (PLUS_EXPR, type,
5915 fold (build (MULT_EXPR, type,
5917 fold (build (MULT_EXPR, type,
5920 arglist = build_tree_list (NULL_TREE, result);
5921 return build_function_call_expr (sqrtfn, arglist);
5928 /* Fold function call to builtin trunc, truncf or truncl. Return
5929 NULL_TREE if no simplification can be made. */
5932 fold_builtin_trunc (tree exp)
5934 tree arglist = TREE_OPERAND (exp, 1);
5937 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5940 /* Optimize trunc of constant value. */
5941 arg = TREE_VALUE (arglist);
5942 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5944 REAL_VALUE_TYPE r, x;
5945 tree type = TREE_TYPE (exp);
5947 x = TREE_REAL_CST (arg);
5948 real_trunc (&r, TYPE_MODE (type), &x);
5949 return build_real (type, r);
5952 return fold_trunc_transparent_mathfn (exp);
5955 /* Fold function call to builtin floor, floorf or floorl. Return
5956 NULL_TREE if no simplification can be made. */
5959 fold_builtin_floor (tree exp)
5961 tree arglist = TREE_OPERAND (exp, 1);
5964 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5967 /* Optimize floor of constant value. */
5968 arg = TREE_VALUE (arglist);
5969 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
5973 x = TREE_REAL_CST (arg);
5974 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
5976 tree type = TREE_TYPE (exp);
5979 real_floor (&r, TYPE_MODE (type), &x);
5980 return build_real (type, r);
5984 return fold_trunc_transparent_mathfn (exp);
5987 /* Fold function call to builtin ceil, ceilf or ceill. Return
5988 NULL_TREE if no simplification can be made. */
5991 fold_builtin_ceil (tree exp)
5993 tree arglist = TREE_OPERAND (exp, 1);
5996 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5999 /* Optimize ceil of constant value. */
6000 arg = TREE_VALUE (arglist);
6001 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
6005 x = TREE_REAL_CST (arg);
6006 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
6008 tree type = TREE_TYPE (exp);
6011 real_ceil (&r, TYPE_MODE (type), &x);
6012 return build_real (type, r);
6016 return fold_trunc_transparent_mathfn (exp);
6019 /* Fold function call to builtin round, roundf or roundl. Return
6020 NULL_TREE if no simplification can be made. */
6023 fold_builtin_round (tree exp)
6025 tree arglist = TREE_OPERAND (exp, 1);
6028 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6031 /* Optimize ceil of constant value. */
6032 arg = TREE_VALUE (arglist);
6033 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
6037 x = TREE_REAL_CST (arg);
6038 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
6040 tree type = TREE_TYPE (exp);
6043 real_round (&r, TYPE_MODE (type), &x);
6044 return build_real (type, r);
6048 return fold_trunc_transparent_mathfn (exp);
6051 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
6052 and their long and long long variants (i.e. ffsl and ffsll).
6053 Return NULL_TREE if no simplification can be made. */
6056 fold_builtin_bitop (tree exp)
6058 tree fndecl = get_callee_fndecl (exp);
6059 tree arglist = TREE_OPERAND (exp, 1);
6062 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
6065 /* Optimize for constant argument. */
6066 arg = TREE_VALUE (arglist);
6067 if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
6069 HOST_WIDE_INT hi, width, result;
6070 unsigned HOST_WIDE_INT lo;
6073 type = TREE_TYPE (arg);
6074 width = TYPE_PRECISION (type);
6075 lo = TREE_INT_CST_LOW (arg);
6077 /* Clear all the bits that are beyond the type's precision. */
6078 if (width > HOST_BITS_PER_WIDE_INT)
6080 hi = TREE_INT_CST_HIGH (arg);
6081 if (width < 2 * HOST_BITS_PER_WIDE_INT)
6082 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
6087 if (width < HOST_BITS_PER_WIDE_INT)
6088 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
6091 switch (DECL_FUNCTION_CODE (fndecl))
6095 case BUILT_IN_FFSLL:
6097 result = exact_log2 (lo & -lo) + 1;
6099 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
6106 case BUILT_IN_CLZLL:
6108 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
6110 result = width - floor_log2 (lo) - 1;
6111 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
6117 case BUILT_IN_CTZLL:
6119 result = exact_log2 (lo & -lo);
6121 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
6122 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
6126 case BUILT_IN_POPCOUNT:
6127 case BUILT_IN_POPCOUNTL:
6128 case BUILT_IN_POPCOUNTLL:
6131 result++, lo &= lo - 1;
6133 result++, hi &= hi - 1;
6136 case BUILT_IN_PARITY:
6137 case BUILT_IN_PARITYL:
6138 case BUILT_IN_PARITYLL:
6141 result++, lo &= lo - 1;
6143 result++, hi &= hi - 1;
6151 t = build_int_2 (result, 0);
6152 TREE_TYPE (t) = TREE_TYPE (exp);
6159 /* Return true if EXPR is the real constant contained in VALUE. */
6162 real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
6166 return ((TREE_CODE (expr) == REAL_CST
6167 && ! TREE_CONSTANT_OVERFLOW (expr)
6168 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
6169 || (TREE_CODE (expr) == COMPLEX_CST
6170 && real_dconstp (TREE_REALPART (expr), value)
6171 && real_zerop (TREE_IMAGPART (expr))));
6174 /* A subroutine of fold_builtin to fold the various logarithmic
6175 functions. EXP is the CALL_EXPR of a call to a builtin logN
6176 function. VALUE is the base of the logN function. */
6179 fold_builtin_logarithm (tree exp, const REAL_VALUE_TYPE *value)
6181 tree arglist = TREE_OPERAND (exp, 1);
6183 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6185 tree fndecl = get_callee_fndecl (exp);
6186 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6187 tree arg = TREE_VALUE (arglist);
6188 const enum built_in_function fcode = builtin_mathfn_code (arg);
6190 /* Optimize logN(1.0) = 0.0. */
6191 if (real_onep (arg))
6192 return build_real (type, dconst0);
6194 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
6195 exactly, then only do this if flag_unsafe_math_optimizations. */
6196 if (exact_real_truncate (TYPE_MODE (type), value)
6197 || flag_unsafe_math_optimizations)
6199 const REAL_VALUE_TYPE value_truncate =
6200 real_value_truncate (TYPE_MODE (type), *value);
6201 if (real_dconstp (arg, &value_truncate))
6202 return build_real (type, dconst1);
6205 /* Special case, optimize logN(expN(x)) = x. */
6206 if (flag_unsafe_math_optimizations
6207 && ((value == &dconste
6208 && (fcode == BUILT_IN_EXP
6209 || fcode == BUILT_IN_EXPF
6210 || fcode == BUILT_IN_EXPL))
6211 || (value == &dconst2
6212 && (fcode == BUILT_IN_EXP2
6213 || fcode == BUILT_IN_EXP2F
6214 || fcode == BUILT_IN_EXP2L))
6215 || (value == &dconst10
6216 && (fcode == BUILT_IN_EXP10
6217 || fcode == BUILT_IN_EXP10F
6218 || fcode == BUILT_IN_EXP10L))))
6219 return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6221 /* Optimize logN(func()) for various exponential functions. We
6222 want to determine the value "x" and the power "exponent" in
6223 order to transform logN(x**exponent) into exponent*logN(x). */
6224 if (flag_unsafe_math_optimizations)
6226 tree exponent = 0, x = 0;
6233 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
6234 x = build_real (type,
6235 real_value_truncate (TYPE_MODE (type), dconste));
6236 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6239 case BUILT_IN_EXP2F:
6240 case BUILT_IN_EXP2L:
6241 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
6242 x = build_real (type, dconst2);
6243 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6245 case BUILT_IN_EXP10:
6246 case BUILT_IN_EXP10F:
6247 case BUILT_IN_EXP10L:
6248 case BUILT_IN_POW10:
6249 case BUILT_IN_POW10F:
6250 case BUILT_IN_POW10L:
6251 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
6252 x = build_real (type, dconst10);
6253 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
6256 case BUILT_IN_SQRTF:
6257 case BUILT_IN_SQRTL:
6258 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
6259 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6260 exponent = build_real (type, dconsthalf);
6263 case BUILT_IN_CBRTF:
6264 case BUILT_IN_CBRTL:
6265 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
6266 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6267 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
6273 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
6274 x = TREE_VALUE (TREE_OPERAND (arg, 1));
6275 exponent = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6281 /* Now perform the optimization. */
6285 arglist = build_tree_list (NULL_TREE, x);
6286 logfn = build_function_call_expr (fndecl, arglist);
6287 return fold (build (MULT_EXPR, type, exponent, logfn));
6295 /* A subroutine of fold_builtin to fold the various exponent
6296 functions. EXP is the CALL_EXPR of a call to a builtin function.
6297 VALUE is the value which will be raised to a power. */
6300 fold_builtin_exponent (tree exp, const REAL_VALUE_TYPE *value)
6302 tree arglist = TREE_OPERAND (exp, 1);
6304 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6306 tree fndecl = get_callee_fndecl (exp);
6307 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6308 tree arg = TREE_VALUE (arglist);
6310 /* Optimize exp*(0.0) = 1.0. */
6311 if (real_zerop (arg))
6312 return build_real (type, dconst1);
6314 /* Optimize expN(1.0) = N. */
6315 if (real_onep (arg))
6317 REAL_VALUE_TYPE cst;
6319 real_convert (&cst, TYPE_MODE (type), value);
6320 return build_real (type, cst);
6323 /* Attempt to evaluate expN(integer) at compile-time. */
6324 if (flag_unsafe_math_optimizations
6325 && TREE_CODE (arg) == REAL_CST
6326 && ! TREE_CONSTANT_OVERFLOW (arg))
6328 REAL_VALUE_TYPE cint;
6332 c = TREE_REAL_CST (arg);
6333 n = real_to_integer (&c);
6334 real_from_integer (&cint, VOIDmode, n,
6336 if (real_identical (&c, &cint))
6340 real_powi (&x, TYPE_MODE (type), value, n);
6341 return build_real (type, x);
6345 /* Optimize expN(logN(x)) = x. */
6346 if (flag_unsafe_math_optimizations)
6348 const enum built_in_function fcode = builtin_mathfn_code (arg);
6350 if ((value == &dconste
6351 && (fcode == BUILT_IN_LOG
6352 || fcode == BUILT_IN_LOGF
6353 || fcode == BUILT_IN_LOGL))
6354 || (value == &dconst2
6355 && (fcode == BUILT_IN_LOG2
6356 || fcode == BUILT_IN_LOG2F
6357 || fcode == BUILT_IN_LOG2L))
6358 || (value == &dconst10
6359 && (fcode == BUILT_IN_LOG10
6360 || fcode == BUILT_IN_LOG10F
6361 || fcode == BUILT_IN_LOG10L)))
6362 return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6369 /* Fold function call to builtin memcpy. Return
6370 NULL_TREE if no simplification can be made. */
6373 fold_builtin_memcpy (tree exp)
6375 tree arglist = TREE_OPERAND (exp, 1);
6376 tree dest, src, len;
6378 if (!validate_arglist (arglist,
6379 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6382 dest = TREE_VALUE (arglist);
6383 src = TREE_VALUE (TREE_CHAIN (arglist));
6384 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6386 /* If the LEN parameter is zero, return DEST. */
6387 if (integer_zerop (len))
6388 return omit_one_operand (TREE_TYPE (exp), dest, src);
6390 /* If SRC and DEST are the same (and not volatile), return DEST. */
6391 if (operand_equal_p (src, dest, 0))
6392 return omit_one_operand (TREE_TYPE (exp), dest, len);
6397 /* Fold function call to builtin mempcpy. Return
6398 NULL_TREE if no simplification can be made. */
6401 fold_builtin_mempcpy (tree exp)
6403 tree arglist = TREE_OPERAND (exp, 1);
6404 tree dest, src, len;
6406 if (!validate_arglist (arglist,
6407 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6410 dest = TREE_VALUE (arglist);
6411 src = TREE_VALUE (TREE_CHAIN (arglist));
6412 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6414 /* If the LEN parameter is zero, return DEST. */
6415 if (integer_zerop (len))
6416 return omit_one_operand (TREE_TYPE (exp), dest, src);
6418 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
6419 if (operand_equal_p (src, dest, 0))
6421 tree temp = convert (TREE_TYPE (dest), len);
6422 temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
6423 return convert (TREE_TYPE (exp), temp);
6429 /* Fold function call to builtin memmove. Return
6430 NULL_TREE if no simplification can be made. */
6433 fold_builtin_memmove (tree exp)
6435 tree arglist = TREE_OPERAND (exp, 1);
6436 tree dest, src, len;
6438 if (!validate_arglist (arglist,
6439 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6442 dest = TREE_VALUE (arglist);
6443 src = TREE_VALUE (TREE_CHAIN (arglist));
6444 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6446 /* If the LEN parameter is zero, return DEST. */
6447 if (integer_zerop (len))
6448 return omit_one_operand (TREE_TYPE (exp), dest, src);
6450 /* If SRC and DEST are the same (and not volatile), return DEST. */
6451 if (operand_equal_p (src, dest, 0))
6452 return omit_one_operand (TREE_TYPE (exp), dest, len);
6457 /* Fold function call to builtin strcpy. Return
6458 NULL_TREE if no simplification can be made. */
6461 fold_builtin_strcpy (tree exp)
6463 tree arglist = TREE_OPERAND (exp, 1);
6466 if (!validate_arglist (arglist,
6467 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6470 dest = TREE_VALUE (arglist);
6471 src = TREE_VALUE (TREE_CHAIN (arglist));
6473 /* If SRC and DEST are the same (and not volatile), return DEST. */
6474 if (operand_equal_p (src, dest, 0))
6475 return convert (TREE_TYPE (exp), dest);
6480 /* Fold function call to builtin strncpy. Return
6481 NULL_TREE if no simplification can be made. */
6484 fold_builtin_strncpy (tree exp)
6486 tree arglist = TREE_OPERAND (exp, 1);
6487 tree dest, src, len;
6489 if (!validate_arglist (arglist,
6490 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6493 dest = TREE_VALUE (arglist);
6494 src = TREE_VALUE (TREE_CHAIN (arglist));
6495 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6497 /* If the LEN parameter is zero, return DEST. */
6498 if (integer_zerop (len))
6499 return omit_one_operand (TREE_TYPE (exp), dest, src);
6504 /* Fold function call to builtin memcmp. Return
6505 NULL_TREE if no simplification can be made. */
6508 fold_builtin_memcmp (tree exp)
6510 tree arglist = TREE_OPERAND (exp, 1);
6511 tree arg1, arg2, len;
6513 if (!validate_arglist (arglist,
6514 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6517 arg1 = TREE_VALUE (arglist);
6518 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6519 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6521 /* If the LEN parameter is zero, return zero. */
6522 if (integer_zerop (len))
6524 tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
6525 return omit_one_operand (TREE_TYPE (exp), temp, arg1);
6528 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6529 if (operand_equal_p (arg1, arg2, 0))
6530 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
6535 /* Fold function call to builtin strcmp. Return
6536 NULL_TREE if no simplification can be made. */
6539 fold_builtin_strcmp (tree exp)
6541 tree arglist = TREE_OPERAND (exp, 1);
6543 const char *p1, *p2;
6545 if (!validate_arglist (arglist,
6546 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6549 arg1 = TREE_VALUE (arglist);
6550 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6552 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6553 if (operand_equal_p (arg1, arg2, 0))
6554 return convert (TREE_TYPE (exp), integer_zero_node);
6556 p1 = c_getstr (arg1);
6557 p2 = c_getstr (arg2);
6562 const int i = strcmp (p1, p2);
6564 temp = integer_minus_one_node;
6566 temp = integer_one_node;
6568 temp = integer_zero_node;
6569 return convert (TREE_TYPE (exp), temp);
6575 /* Fold function call to builtin strncmp. Return
6576 NULL_TREE if no simplification can be made. */
6579 fold_builtin_strncmp (tree exp)
6581 tree arglist = TREE_OPERAND (exp, 1);
6582 tree arg1, arg2, len;
6583 const char *p1, *p2;
6585 if (!validate_arglist (arglist,
6586 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6589 arg1 = TREE_VALUE (arglist);
6590 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
6591 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6593 /* If the LEN parameter is zero, return zero. */
6594 if (integer_zerop (len))
6596 tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
6597 return omit_one_operand (TREE_TYPE (exp), temp, arg1);
6600 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
6601 if (operand_equal_p (arg1, arg2, 0))
6602 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
6604 p1 = c_getstr (arg1);
6605 p2 = c_getstr (arg2);
6607 if (host_integerp (len, 1) && p1 && p2)
6610 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
6612 temp = integer_minus_one_node;
6614 temp = integer_one_node;
6616 temp = integer_zero_node;
6617 return convert (TREE_TYPE (exp), temp);
6623 /* Fold function call to builtin signbit, signbitf or signbitl. Return
6624 NULL_TREE if no simplification can be made. */
6627 fold_builtin_signbit (tree exp)
6629 tree arglist = TREE_OPERAND (exp, 1);
6632 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6635 arg = TREE_VALUE (arglist);
6637 /* If ARG is a compile-time constant, determine the result. */
6638 if (TREE_CODE (arg) == REAL_CST
6639 && !TREE_CONSTANT_OVERFLOW (arg))
6643 c = TREE_REAL_CST (arg);
6644 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
6645 return convert (TREE_TYPE (exp), temp);
6648 /* If ARG is non-negative, the result is always zero. */
6649 if (tree_expr_nonnegative_p (arg))
6650 return omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg);
6652 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
6653 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
6654 return fold (build (LT_EXPR, TREE_TYPE (exp), arg,
6655 build_real (TREE_TYPE (arg), dconst0)));
6661 /* Used by constant folding to eliminate some builtin calls early. EXP is
6662 the CALL_EXPR of a call to a builtin function. */
6665 fold_builtin (tree exp)
6667 tree fndecl = get_callee_fndecl (exp);
6668 tree arglist = TREE_OPERAND (exp, 1);
6669 tree type = TREE_TYPE (TREE_TYPE (fndecl));
6671 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6674 switch (DECL_FUNCTION_CODE (fndecl))
6676 case BUILT_IN_CONSTANT_P:
6677 return fold_builtin_constant_p (arglist);
6679 case BUILT_IN_CLASSIFY_TYPE:
6680 return fold_builtin_classify_type (arglist);
6682 case BUILT_IN_STRLEN:
6683 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6685 tree len = c_strlen (TREE_VALUE (arglist), 0);
6688 /* Convert from the internal "sizetype" type to "size_t". */
6690 len = convert (size_type_node, len);
6697 case BUILT_IN_FABSF:
6698 case BUILT_IN_FABSL:
6699 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6700 return fold (build1 (ABS_EXPR, type, TREE_VALUE (arglist)));
6704 case BUILT_IN_CABSF:
6705 case BUILT_IN_CABSL:
6706 return fold_builtin_cabs (fndecl, arglist, type);
6709 case BUILT_IN_SQRTF:
6710 case BUILT_IN_SQRTL:
6711 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6713 enum built_in_function fcode;
6714 tree arg = TREE_VALUE (arglist);
6716 /* Optimize sqrt of constant value. */
6717 if (TREE_CODE (arg) == REAL_CST
6718 && ! TREE_CONSTANT_OVERFLOW (arg))
6720 REAL_VALUE_TYPE r, x;
6722 x = TREE_REAL_CST (arg);
6723 if (real_sqrt (&r, TYPE_MODE (type), &x)
6724 || (!flag_trapping_math && !flag_errno_math))
6725 return build_real (type, r);
6728 /* Optimize sqrt(exp(x)) = exp(x*0.5). */
6729 fcode = builtin_mathfn_code (arg);
6730 if (flag_unsafe_math_optimizations
6731 && (fcode == BUILT_IN_EXP
6732 || fcode == BUILT_IN_EXPF
6733 || fcode == BUILT_IN_EXPL))
6735 tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6736 arg = fold (build (MULT_EXPR, type,
6737 TREE_VALUE (TREE_OPERAND (arg, 1)),
6738 build_real (type, dconsthalf)));
6739 arglist = build_tree_list (NULL_TREE, arg);
6740 return build_function_call_expr (expfn, arglist);
6743 /* Optimize sqrt(pow(x,y)) = pow(x,y*0.5). */
6744 if (flag_unsafe_math_optimizations
6745 && (fcode == BUILT_IN_POW
6746 || fcode == BUILT_IN_POWF
6747 || fcode == BUILT_IN_POWL))
6749 tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6750 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6751 tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6752 tree narg1 = fold (build (MULT_EXPR, type, arg1,
6753 build_real (type, dconsthalf)));
6754 arglist = tree_cons (NULL_TREE, arg0,
6755 build_tree_list (NULL_TREE, narg1));
6756 return build_function_call_expr (powfn, arglist);
6764 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6766 tree arg = TREE_VALUE (arglist);
6768 /* Optimize sin(0.0) = 0.0. */
6769 if (real_zerop (arg))
6777 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6779 tree arg = TREE_VALUE (arglist);
6781 /* Optimize cos(0.0) = 1.0. */
6782 if (real_zerop (arg))
6783 return build_real (type, dconst1);
6785 /* Optimize cos(-x) into cos(x). */
6786 if (TREE_CODE (arg) == NEGATE_EXPR)
6788 tree arglist = build_tree_list (NULL_TREE,
6789 TREE_OPERAND (arg, 0));
6790 return build_function_call_expr (fndecl, arglist);
6798 return fold_builtin_exponent (exp, &dconste);
6800 case BUILT_IN_EXP2F:
6801 case BUILT_IN_EXP2L:
6802 return fold_builtin_exponent (exp, &dconst2);
6803 case BUILT_IN_EXP10:
6804 case BUILT_IN_EXP10F:
6805 case BUILT_IN_EXP10L:
6806 case BUILT_IN_POW10:
6807 case BUILT_IN_POW10F:
6808 case BUILT_IN_POW10L:
6809 return fold_builtin_exponent (exp, &dconst10);
6813 return fold_builtin_logarithm (exp, &dconste);
6816 case BUILT_IN_LOG2F:
6817 case BUILT_IN_LOG2L:
6818 return fold_builtin_logarithm (exp, &dconst2);
6820 case BUILT_IN_LOG10:
6821 case BUILT_IN_LOG10F:
6822 case BUILT_IN_LOG10L:
6823 return fold_builtin_logarithm (exp, &dconst10);
6829 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6831 enum built_in_function fcode;
6832 tree arg = TREE_VALUE (arglist);
6834 /* Optimize tan(0.0) = 0.0. */
6835 if (real_zerop (arg))
6838 /* Optimize tan(atan(x)) = x. */
6839 fcode = builtin_mathfn_code (arg);
6840 if (flag_unsafe_math_optimizations
6841 && (fcode == BUILT_IN_ATAN
6842 || fcode == BUILT_IN_ATANF
6843 || fcode == BUILT_IN_ATANL))
6844 return TREE_VALUE (TREE_OPERAND (arg, 1));
6849 case BUILT_IN_ATANF:
6850 case BUILT_IN_ATANL:
6851 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6853 tree arg = TREE_VALUE (arglist);
6855 /* Optimize atan(0.0) = 0.0. */
6856 if (real_zerop (arg))
6859 /* Optimize atan(1.0) = pi/4. */
6860 if (real_onep (arg))
6862 REAL_VALUE_TYPE cst;
6864 real_convert (&cst, TYPE_MODE (type), &dconstpi);
6866 return build_real (type, cst);
6874 if (validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
6876 enum built_in_function fcode;
6877 tree arg0 = TREE_VALUE (arglist);
6878 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
6880 /* Optimize pow(1.0,y) = 1.0. */
6881 if (real_onep (arg0))
6882 return omit_one_operand (type, build_real (type, dconst1), arg1);
6884 if (TREE_CODE (arg1) == REAL_CST
6885 && ! TREE_CONSTANT_OVERFLOW (arg1))
6888 c = TREE_REAL_CST (arg1);
6890 /* Optimize pow(x,0.0) = 1.0. */
6891 if (REAL_VALUES_EQUAL (c, dconst0))
6892 return omit_one_operand (type, build_real (type, dconst1),
6895 /* Optimize pow(x,1.0) = x. */
6896 if (REAL_VALUES_EQUAL (c, dconst1))
6899 /* Optimize pow(x,-1.0) = 1.0/x. */
6900 if (REAL_VALUES_EQUAL (c, dconstm1))
6901 return fold (build (RDIV_EXPR, type,
6902 build_real (type, dconst1),
6905 /* Optimize pow(x,0.5) = sqrt(x). */
6906 if (flag_unsafe_math_optimizations
6907 && REAL_VALUES_EQUAL (c, dconsthalf))
6911 fcode = DECL_FUNCTION_CODE (fndecl);
6912 if (fcode == BUILT_IN_POW)
6913 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
6914 else if (fcode == BUILT_IN_POWF)
6915 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
6916 else if (fcode == BUILT_IN_POWL)
6917 sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
6921 if (sqrtfn != NULL_TREE)
6923 tree arglist = build_tree_list (NULL_TREE, arg0);
6924 return build_function_call_expr (sqrtfn, arglist);
6928 /* Attempt to evaluate pow at compile-time. */
6929 if (TREE_CODE (arg0) == REAL_CST
6930 && ! TREE_CONSTANT_OVERFLOW (arg0))
6932 REAL_VALUE_TYPE cint;
6935 n = real_to_integer (&c);
6936 real_from_integer (&cint, VOIDmode, n,
6938 if (real_identical (&c, &cint))
6943 x = TREE_REAL_CST (arg0);
6944 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
6945 if (flag_unsafe_math_optimizations || !inexact)
6946 return build_real (type, x);
6951 /* Optimize pow(exp(x),y) = exp(x*y). */
6952 fcode = builtin_mathfn_code (arg0);
6953 if (flag_unsafe_math_optimizations
6954 && (fcode == BUILT_IN_EXP
6955 || fcode == BUILT_IN_EXPF
6956 || fcode == BUILT_IN_EXPL))
6958 tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6959 tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
6960 arg = fold (build (MULT_EXPR, type, arg, arg1));
6961 arglist = build_tree_list (NULL_TREE, arg);
6962 return build_function_call_expr (expfn, arglist);
6965 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
6966 if (flag_unsafe_math_optimizations
6967 && (fcode == BUILT_IN_SQRT
6968 || fcode == BUILT_IN_SQRTF
6969 || fcode == BUILT_IN_SQRTL))
6971 tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
6972 tree narg1 = fold (build (MULT_EXPR, type, arg1,
6973 build_real (type, dconsthalf)));
6975 arglist = tree_cons (NULL_TREE, narg0,
6976 build_tree_list (NULL_TREE, narg1));
6977 return build_function_call_expr (fndecl, arglist);
6980 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
6981 if (flag_unsafe_math_optimizations
6982 && (fcode == BUILT_IN_POW
6983 || fcode == BUILT_IN_POWF
6984 || fcode == BUILT_IN_POWL))
6986 tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
6987 tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
6988 tree narg1 = fold (build (MULT_EXPR, type, arg01, arg1));
6989 arglist = tree_cons (NULL_TREE, arg00,
6990 build_tree_list (NULL_TREE, narg1));
6991 return build_function_call_expr (fndecl, arglist);
6999 return fold_builtin_inf (type, true);
7001 case BUILT_IN_HUGE_VAL:
7002 case BUILT_IN_HUGE_VALF:
7003 case BUILT_IN_HUGE_VALL:
7004 return fold_builtin_inf (type, false);
7009 return fold_builtin_nan (arglist, type, true);
7012 case BUILT_IN_NANSF:
7013 case BUILT_IN_NANSL:
7014 return fold_builtin_nan (arglist, type, false);
7016 case BUILT_IN_FLOOR:
7017 case BUILT_IN_FLOORF:
7018 case BUILT_IN_FLOORL:
7019 return fold_builtin_floor (exp);
7022 case BUILT_IN_CEILF:
7023 case BUILT_IN_CEILL:
7024 return fold_builtin_ceil (exp);
7026 case BUILT_IN_TRUNC:
7027 case BUILT_IN_TRUNCF:
7028 case BUILT_IN_TRUNCL:
7029 return fold_builtin_trunc (exp);
7031 case BUILT_IN_ROUND:
7032 case BUILT_IN_ROUNDF:
7033 case BUILT_IN_ROUNDL:
7034 return fold_builtin_round (exp);
7036 case BUILT_IN_NEARBYINT:
7037 case BUILT_IN_NEARBYINTF:
7038 case BUILT_IN_NEARBYINTL:
7039 return fold_trunc_transparent_mathfn (exp);
7043 case BUILT_IN_FFSLL:
7046 case BUILT_IN_CLZLL:
7049 case BUILT_IN_CTZLL:
7050 case BUILT_IN_POPCOUNT:
7051 case BUILT_IN_POPCOUNTL:
7052 case BUILT_IN_POPCOUNTLL:
7053 case BUILT_IN_PARITY:
7054 case BUILT_IN_PARITYL:
7055 case BUILT_IN_PARITYLL:
7056 return fold_builtin_bitop (exp);
7058 case BUILT_IN_MEMCPY:
7059 return fold_builtin_memcpy (exp);
7061 case BUILT_IN_MEMPCPY:
7062 return fold_builtin_mempcpy (exp);
7064 case BUILT_IN_MEMMOVE:
7065 return fold_builtin_memmove (exp);
7067 case BUILT_IN_STRCPY:
7068 return fold_builtin_strcpy (exp);
7070 case BUILT_IN_STRNCPY:
7071 return fold_builtin_strncpy (exp);
7073 case BUILT_IN_MEMCMP:
7074 return fold_builtin_memcmp (exp);
7076 case BUILT_IN_STRCMP:
7077 return fold_builtin_strcmp (exp);
7079 case BUILT_IN_STRNCMP:
7080 return fold_builtin_strncmp (exp);
7082 case BUILT_IN_SIGNBIT:
7083 case BUILT_IN_SIGNBITF:
7084 case BUILT_IN_SIGNBITL:
7085 return fold_builtin_signbit (exp);
7094 /* Conveniently construct a function call expression. */
7097 build_function_call_expr (tree fn, tree arglist)
7101 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
7102 call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
7103 call_expr, arglist);
7104 return fold (call_expr);
7107 /* This function validates the types of a function call argument list
7108 represented as a tree chain of parameters against a specified list
7109 of tree_codes. If the last specifier is a 0, that represents an
7110 ellipses, otherwise the last specifier must be a VOID_TYPE. */
7113 validate_arglist (tree arglist, ...)
7115 enum tree_code code;
7119 va_start (ap, arglist);
7123 code = va_arg (ap, enum tree_code);
7127 /* This signifies an ellipses, any further arguments are all ok. */
7131 /* This signifies an endlink, if no arguments remain, return
7132 true, otherwise return false. */
7136 /* If no parameters remain or the parameter's code does not
7137 match the specified code, return false. Otherwise continue
7138 checking any remaining arguments. */
7140 || code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
7144 arglist = TREE_CHAIN (arglist);
7148 /* We need gotos here since we can only have one VA_CLOSE in a
7156 /* Default target-specific builtin expander that does nothing. */
7159 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
7160 rtx target ATTRIBUTE_UNUSED,
7161 rtx subtarget ATTRIBUTE_UNUSED,
7162 enum machine_mode mode ATTRIBUTE_UNUSED,
7163 int ignore ATTRIBUTE_UNUSED)
7168 /* Instantiate all remaining CONSTANT_P_RTX nodes. */
7171 purge_builtin_constant_p (void)
7173 rtx insn, set, arg, new, note;
7175 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
7177 && (set = single_set (insn)) != NULL_RTX
7178 && (GET_CODE (arg = SET_SRC (set)) == CONSTANT_P_RTX
7179 || (GET_CODE (arg) == SUBREG
7180 && (GET_CODE (arg = SUBREG_REG (arg))
7181 == CONSTANT_P_RTX))))
7183 arg = XEXP (arg, 0);
7184 new = CONSTANT_P (arg) ? const1_rtx : const0_rtx;
7185 validate_change (insn, &SET_SRC (set), new, 0);
7187 /* Remove the REG_EQUAL note from the insn. */
7188 if ((note = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
7189 remove_note (insn, note);
7193 /* Returns true is EXP represents data that would potentially reside
7194 in a readonly section. */
7197 readonly_data_expr (tree exp)
7201 if (TREE_CODE (exp) == ADDR_EXPR)
7202 return decl_readonly_section (TREE_OPERAND (exp, 0), 0);