3c3
< 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
---
> 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
19,20c19,20
< Software Foundation, 59 Temple Place - Suite 330, Boston, MA
< 02111-1307, USA. */
---
> Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
> 02110-1301, USA. */
29a30
> #include "tree-gimple.h"
46a48,49
> #include "basic-block.h"
> #include "tree-mudflap.h"
48,58d50
< #define CALLED_AS_BUILT_IN(NODE) \
< (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
<
< /* Register mappings for target machines without register windows. */
< #ifndef INCOMING_REGNO
< #define INCOMING_REGNO(OUT) (OUT)
< #endif
< #ifndef OUTGOING_REGNO
< #define OUTGOING_REGNO(IN) (IN)
< #endif
<
67,68c59,60
< #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM) #X,
< const char *const built_in_names[(int) END_BUILTINS] =
---
> #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
> const char * built_in_names[(int) END_BUILTINS] =
79c71
< required to implement the function call in all cases. */
---
> required to implement the function call in all cases). */
83d74
< static tree c_strlen (tree, int);
87,88c78
< static rtx get_memory_rtx (tree);
< static tree build_string_literal (int, const char *);
---
> static rtx get_memory_rtx (tree, tree);
94c84
< static rtx expand_builtin_setjmp (tree, rtx);
---
> static void expand_builtin_update_setjmp_buf (rtx);
105c95,97
< static rtx expand_builtin_constant_p (tree, enum machine_mode);
---
> static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
> static rtx expand_builtin_sincos (tree);
> static rtx expand_builtin_int_roundingfn (tree, rtx, rtx);
107c99
< static rtx expand_builtin_next_arg (tree);
---
> static rtx expand_builtin_next_arg (void);
115c107
< static rtx expand_builtin_strcat (tree, rtx, enum machine_mode);
---
> static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
120,121c112,113
< static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode, int);
< static rtx expand_builtin_memmove (tree, rtx, enum machine_mode);
---
> static rtx expand_builtin_mempcpy (tree, tree, rtx, enum machine_mode, int);
> static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode, tree);
123c115
< static rtx expand_builtin_strcpy (tree, rtx, enum machine_mode);
---
> static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
129c121
< static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
---
> static rtx expand_builtin_memset (tree, rtx, enum machine_mode, tree);
132,135c124,127
< static rtx expand_builtin_strstr (tree, rtx, enum machine_mode);
< static rtx expand_builtin_strpbrk (tree, rtx, enum machine_mode);
< static rtx expand_builtin_strchr (tree, rtx, enum machine_mode);
< static rtx expand_builtin_strrchr (tree, rtx, enum machine_mode);
---
> static rtx expand_builtin_strstr (tree, tree, rtx, enum machine_mode);
> static rtx expand_builtin_strpbrk (tree, tree, rtx, enum machine_mode);
> static rtx expand_builtin_strchr (tree, tree, rtx, enum machine_mode);
> static rtx expand_builtin_strrchr (tree, tree, rtx, enum machine_mode);
146a139
> static tree fold_builtin_strlen (tree);
151c144
< static tree fold_trunc_transparent_mathfn (tree);
---
> static tree fold_trunc_transparent_mathfn (tree, tree);
154,164c147,163
< static rtx expand_builtin_cabs (tree, rtx);
< static tree fold_builtin_cabs (tree, tree, tree);
< static tree fold_builtin_trunc (tree);
< static tree fold_builtin_floor (tree);
< static tree fold_builtin_ceil (tree);
< static tree fold_builtin_bitop (tree);
< static tree fold_builtin_memcpy (tree);
< static tree fold_builtin_mempcpy (tree);
< static tree fold_builtin_memmove (tree);
< static tree fold_builtin_strcpy (tree);
< static tree fold_builtin_strncpy (tree);
---
> static rtx expand_builtin_signbit (tree, rtx);
> static tree fold_builtin_sqrt (tree, tree);
> static tree fold_builtin_cbrt (tree, tree);
> static tree fold_builtin_pow (tree, tree, tree);
> static tree fold_builtin_powi (tree, tree, tree);
> static tree fold_builtin_sin (tree);
> static tree fold_builtin_cos (tree, tree, tree);
> static tree fold_builtin_tan (tree);
> static tree fold_builtin_atan (tree, tree);
> static tree fold_builtin_trunc (tree, tree);
> static tree fold_builtin_floor (tree, tree);
> static tree fold_builtin_ceil (tree, tree);
> static tree fold_builtin_round (tree, tree);
> static tree fold_builtin_int_roundingfn (tree, tree);
> static tree fold_builtin_bitop (tree, tree);
> static tree fold_builtin_memory_op (tree, tree, bool, int);
> static tree fold_builtin_strchr (tree, tree);
167a167,176
> static tree fold_builtin_signbit (tree, tree);
> static tree fold_builtin_copysign (tree, tree, tree);
> static tree fold_builtin_isascii (tree);
> static tree fold_builtin_toascii (tree);
> static tree fold_builtin_isdigit (tree);
> static tree fold_builtin_fabs (tree, tree);
> static tree fold_builtin_abs (tree, tree);
> static tree fold_builtin_unordered_cmp (tree, tree, enum tree_code,
> enum tree_code);
> static tree fold_builtin_1 (tree, tree, bool);
168a178,221
> static tree fold_builtin_strpbrk (tree, tree);
> static tree fold_builtin_strstr (tree, tree);
> static tree fold_builtin_strrchr (tree, tree);
> static tree fold_builtin_strcat (tree);
> static tree fold_builtin_strncat (tree);
> static tree fold_builtin_strspn (tree);
> static tree fold_builtin_strcspn (tree);
> static tree fold_builtin_sprintf (tree, int);
>
> static rtx expand_builtin_object_size (tree);
> static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
> enum built_in_function);
> static void maybe_emit_chk_warning (tree, enum built_in_function);
> static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
> static tree fold_builtin_object_size (tree);
> static tree fold_builtin_strcat_chk (tree, tree);
> static tree fold_builtin_strncat_chk (tree, tree);
> static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
> static tree fold_builtin_printf (tree, tree, bool, enum built_in_function);
> static tree fold_builtin_fprintf (tree, tree, bool, enum built_in_function);
> static bool init_target_chars (void);
>
> static unsigned HOST_WIDE_INT target_newline;
> static unsigned HOST_WIDE_INT target_percent;
> static unsigned HOST_WIDE_INT target_c;
> static unsigned HOST_WIDE_INT target_s;
> static char target_percent_c[3];
> static char target_percent_s[3];
> static char target_percent_s_newline[4];
>
> /* Return true if NODE should be considered for inline expansion regardless
> of the optimization level. This means whenever a function is invoked with
> its "internal" name, which normally contains the prefix "__builtin". */
>
> static bool called_as_built_in (tree node)
> {
> const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
> if (strncmp (name, "__builtin_", 10) == 0)
> return true;
> if (strncmp (name, "__sync_", 7) == 0)
> return true;
> return false;
> }
>
182c235,236
< if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
---
> /* We rely on TER to compute accurate alignment information. */
> if (!(optimize && flag_tree_ter))
184a239,241
> if (!POINTER_TYPE_P (TREE_TYPE (exp)))
> return 0;
>
196c253
< if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (exp)))
220a278,317
> inner = max_align;
> if (handled_component_p (exp))
> {
> HOST_WIDE_INT bitsize, bitpos;
> tree offset;
> enum machine_mode mode;
> int unsignedp, volatilep;
>
> exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
> &mode, &unsignedp, &volatilep, true);
> if (bitpos)
> inner = MIN (inner, (unsigned) (bitpos & -bitpos));
> if (offset && TREE_CODE (offset) == PLUS_EXPR
> && host_integerp (TREE_OPERAND (offset, 1), 1))
> {
> /* Any overflow in calculating offset_bits won't change
> the alignment. */
> unsigned offset_bits
> = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
> * BITS_PER_UNIT);
>
> if (offset_bits)
> inner = MIN (inner, (offset_bits & -offset_bits));
> offset = TREE_OPERAND (offset, 0);
> }
> if (offset && TREE_CODE (offset) == MULT_EXPR
> && host_integerp (TREE_OPERAND (offset, 1), 1))
> {
> /* Any overflow in calculating offset_factor won't change
> the alignment. */
> unsigned offset_factor
> = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
> * BITS_PER_UNIT);
>
> if (offset_factor)
> inner = MIN (inner, (offset_factor & -offset_factor));
> }
> else if (offset)
> inner = MIN (inner, BITS_PER_UNIT);
> }
224c321
< align = DECL_ALIGN (exp);
---
> align = MIN (inner, DECL_ALIGN (exp));
226,227c323,324
< else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
< align = CONSTANT_ALIGNMENT (exp, align);
---
> else if (CONSTANT_CLASS_P (exp))
> align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
228a326,330
> else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
> || TREE_CODE (exp) == INDIRECT_REF)
> align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
> else
> align = MIN (align, inner);
253c355
< static tree
---
> tree
269c371
< if (tree_int_cst_equal (len1, len2))
---
> if (tree_int_cst_equal (len1, len2))
318c420
< warning ("offset outside bounds of constant string");
---
> warning (0, "offset outside bounds of constant string");
362,363c464,465
< if (GET_MODE_CLASS (mode) != MODE_INT)
< abort ();
---
> gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
>
376,377c478,479
< if (j > 2 * HOST_BITS_PER_WIDE_INT)
< abort ();
---
> gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
>
386c488
< host char type, return zero and put that value into variable pointed by
---
> host char type, return zero and put that value into variable pointed to by
412a515,529
> /* Similar to save_expr, but assumes that arbitrary code is not executed
> in between the multiple evaluations. In particular, we assume that a
> non-addressable local variable will not be modified. */
>
> static tree
> builtin_save_expr (tree exp)
> {
> if (TREE_ADDRESSABLE (exp) == 0
> && (TREE_CODE (exp) == PARM_DECL
> || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
> return exp;
>
> return save_expr (exp);
> }
>
417,419c534,535
< rtx
< expand_builtin_return_addr (enum built_in_function fndecl_code, int count,
< rtx tem)
---
> static rtx
> expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
422a539,563
> #ifdef INITIAL_FRAME_ADDRESS_RTX
> rtx tem = INITIAL_FRAME_ADDRESS_RTX;
> #else
> rtx tem;
>
> /* For a zero count with __builtin_return_address, we don't care what
> frame address we return, because target-specific definitions will
> override us. Therefore frame pointer elimination is OK, and using
> the soft frame pointer is OK.
>
> For a non-zero count, or a zero count with __builtin_frame_address,
> we require a stable offset from the current frame pointer to the
> previous one, so we must use the hard frame pointer, and
> we must disable frame pointer elimination. */
> if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
> tem = frame_pointer_rtx;
> else
> {
> tem = hard_frame_pointer_rtx;
>
> /* Tell reload not to eliminate the frame pointer. */
> current_function_accesses_prior_frames = 1;
> }
> #endif
>
424c565
< arbitrary frames. For example, on the sparc, we must first flush
---
> arbitrary frames. For example, on the SPARC, we must first flush
431c572
< /* On the sparc, the return address is not in the frame, it is in a
---
> /* On the SPARC, the return address is not in the frame, it is in a
449,450c590
< tem = gen_rtx_MEM (Pmode, tem);
< set_mem_alias_set (tem, get_frame_alias_set ());
---
> tem = gen_frame_mem (Pmode, tem);
454c594,595
< /* For __builtin_frame_address, return what we've got. */
---
> /* For __builtin_frame_address, return what we've got. But, on
> the SPARC for example, we may have to add a bias. */
455a597,599
> #ifdef FRAME_ADDR_RTX
> return FRAME_ADDR_RTX (tem);
> #else
456a601
> #endif
458,459c603
< /* For __builtin_return_address, Get the return address from that
< frame. */
---
> /* For __builtin_return_address, get the return address from that frame. */
465,466c609
< tem = gen_rtx_MEM (Pmode, tem);
< set_mem_alias_set (tem, get_frame_alias_set ());
---
> tem = gen_frame_mem (Pmode, tem);
475,476c618,619
< return to RECEIVER_LABEL. This is used directly by sjlj exception
< handling code. */
---
> return to RECEIVER_LABEL. This is also called directly by the SJLJ
> exception handling code. */
492,493d634
< emit_queue ();
<
498,501d638
< #ifndef BUILTIN_SETJMP_FRAME_VALUE
< #define BUILTIN_SETJMP_FRAME_VALUE virtual_stack_vars_rtx
< #endif
<
504c641
< emit_move_insn (mem, BUILTIN_SETJMP_FRAME_VALUE);
---
> emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
533,534c670,671
< /* Construct the trailing part of a __builtin_setjmp call.
< This is used directly by sjlj exception handling code. */
---
> /* Construct the trailing part of a __builtin_setjmp call. This is
> also called directly by the SJLJ exception handling code. */
548,549c685
< pointer, if needed. The code below is from expand_end_bindings
< in stmt.c; see detailed documentation there. */
---
> pointer, if needed. */
553c689,694
< emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
---
> {
> emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
> /* This might change the hard frame pointer in ways that aren't
> apparent to early optimization passes, so force a clobber. */
> emit_insn (gen_rtx_CLOBBER (VOIDmode, hard_frame_pointer_rtx));
> }
598,650d738
< /* __builtin_setjmp is passed a pointer to an array of five words (not
< all will be used on all machines). It operates similarly to the C
< library function of the same name, but is more efficient. Much of
< the code below (and for longjmp) is copied from the handling of
< non-local gotos.
<
< NOTE: This is intended for use by GNAT and the exception handling
< scheme in the compiler and will only work in the method used by
< them. */
<
< static rtx
< expand_builtin_setjmp (tree arglist, rtx target)
< {
< rtx buf_addr, next_lab, cont_lab;
<
< if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
< return NULL_RTX;
<
< if (target == 0 || GET_CODE (target) != REG
< || REGNO (target) < FIRST_PSEUDO_REGISTER)
< target = gen_reg_rtx (TYPE_MODE (integer_type_node));
<
< buf_addr = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
<
< next_lab = gen_label_rtx ();
< cont_lab = gen_label_rtx ();
<
< expand_builtin_setjmp_setup (buf_addr, next_lab);
<
< /* Set TARGET to zero and branch to the continue label. Use emit_jump to
< ensure that pending stack adjustments are flushed. */
< emit_move_insn (target, const0_rtx);
< emit_jump (cont_lab);
<
< emit_label (next_lab);
<
< expand_builtin_setjmp_receiver (next_lab);
<
< /* Set TARGET to one. */
< emit_move_insn (target, const1_rtx);
< emit_label (cont_lab);
<
< /* Tell flow about the strange goings on. Putting `next_lab' on
< `nonlocal_goto_handler_labels' to indicates that function
< calls may traverse the arc back to this label. */
<
< current_function_has_nonlocal_label = 1;
< nonlocal_goto_handler_labels
< = gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
<
< return target;
< }
<
654c742
< the code below is copied from the handling of non-local gotos.
---
> the code below is copied from the handling of non-local gotos. */
656,660c744
< NOTE: This is intended for use by GNAT and the exception handling
< scheme in the compiler and will only work in the method used by
< them. */
<
< void
---
> static void
678,679c762
< if (value != const1_rtx)
< abort ();
---
> gcc_assert (value == const1_rtx);
681,682d763
< current_function_calls_longjmp = 1;
<
702c783
< #if HAVE_nonlocal_goto
---
> #ifdef HAVE_nonlocal_goto
736,738c817,819
< if (insn == last)
< abort ();
< if (GET_CODE (insn) == JUMP_INSN)
---
> gcc_assert (insn != last);
>
> if (JUMP_P (insn))
744c825
< else if (GET_CODE (insn) == CALL_INSN)
---
> else if (CALL_P (insn))
748a830,938
> /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
> and the address of the save area. */
>
> static rtx
> expand_builtin_nonlocal_goto (tree arglist)
> {
> tree t_label, t_save_area;
> rtx r_label, r_save_area, r_fp, r_sp, insn;
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return NULL_RTX;
>
> t_label = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> t_save_area = TREE_VALUE (arglist);
>
> r_label = expand_normal (t_label);
> r_label = convert_memory_address (Pmode, r_label);
> r_save_area = expand_normal (t_save_area);
> r_save_area = convert_memory_address (Pmode, r_save_area);
> r_fp = gen_rtx_MEM (Pmode, r_save_area);
> r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
> plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
>
> current_function_has_nonlocal_goto = 1;
>
> #ifdef HAVE_nonlocal_goto
> /* ??? We no longer need to pass the static chain value, afaik. */
> if (HAVE_nonlocal_goto)
> emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
> else
> #endif
> {
> r_label = copy_to_reg (r_label);
>
> emit_insn (gen_rtx_CLOBBER (VOIDmode,
> gen_rtx_MEM (BLKmode,
> gen_rtx_SCRATCH (VOIDmode))));
>
> emit_insn (gen_rtx_CLOBBER (VOIDmode,
> gen_rtx_MEM (BLKmode,
> hard_frame_pointer_rtx)));
>
> /* Restore frame pointer for containing function.
> This sets the actual hard register used for the frame pointer
> to the location of the function's incoming static chain info.
> The non-local goto handler will then adjust it to contain the
> proper value and reload the argument pointer, if needed. */
> emit_move_insn (hard_frame_pointer_rtx, r_fp);
> emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
>
> /* USE of hard_frame_pointer_rtx added for consistency;
> not clear if really needed. */
> emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
> emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
> emit_indirect_jump (r_label);
> }
>
> /* Search backwards to the jump insn and mark it as a
> non-local goto. */
> for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
> {
> if (JUMP_P (insn))
> {
> REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO,
> const0_rtx, REG_NOTES (insn));
> break;
> }
> else if (CALL_P (insn))
> break;
> }
>
> return const0_rtx;
> }
>
> /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
> (not all will be used on all machines) that was passed to __builtin_setjmp.
> It updates the stack pointer in that block to correspond to the current
> stack pointer. */
>
> static void
> expand_builtin_update_setjmp_buf (rtx buf_addr)
> {
> enum machine_mode sa_mode = Pmode;
> rtx stack_save;
>
>
> #ifdef HAVE_save_stack_nonlocal
> if (HAVE_save_stack_nonlocal)
> sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
> #endif
> #ifdef STACK_SAVEAREA_MODE
> sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
> #endif
>
> stack_save
> = gen_rtx_MEM (sa_mode,
> memory_address
> (sa_mode,
> plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
>
> #ifdef HAVE_setjmp
> if (HAVE_setjmp)
> emit_insn (gen_setjmp ());
> #endif
>
> emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
> }
>
772c962
< arg2 = build_int_2 (3, 0);
---
> arg2 = build_int_cst (NULL_TREE, 3);
777c967
< arg2 = build_int_2 (3, 0);
---
> arg2 = build_int_cst (NULL_TREE, 3);
786c976
< error ("second arg to `__builtin_prefetch' must be a constant");
---
> error ("second argument to %<__builtin_prefetch%> must be a constant");
789c979
< op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
---
> op1 = expand_normal (arg1);
793c983,984
< warning ("invalid second arg to __builtin_prefetch; using zero");
---
> warning (0, "invalid second argument to %<__builtin_prefetch%>;"
> " using zero");
800c991
< error ("third arg to `__builtin_prefetch' must be a constant");
---
> error ("third argument to %<__builtin_prefetch%> must be a constant");
803c994
< op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
---
> op2 = expand_normal (arg2);
807c998
< warning ("invalid third arg to __builtin_prefetch; using zero");
---
> warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
824d1014
< else
826c1016
< op0 = protect_from_queue (op0, 0);
---
>
829c1019
< if (GET_CODE (op0) != MEM && side_effects_p (op0))
---
> if (!MEM_P (op0) && side_effects_p (op0))
834c1024,1026
< to be used to be used in a string instruction (cmpstrsi, movstrsi, ..). */
---
> to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
> the maximum length of the block of memory that might be accessed or
> NULL if unknown. */
837c1029
< get_memory_rtx (tree exp)
---
> get_memory_rtx (tree exp, tree len)
839,840c1031,1032
< rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_SUM);
< rtx mem;
---
> rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
> rtx mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
842,845d1033
< addr = convert_memory_address (Pmode, addr);
<
< mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
<
855,858c1043
< {
< exp = TREE_OPERAND (exp, 0);
< set_mem_attributes (mem, exp, 0);
< }
---
> exp = TREE_OPERAND (exp, 0);
859a1045,1052
> exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
> else
> exp = NULL;
>
> /* Honor attributes derived from exp, except for the alias set
> (as builtin stringops may alias with anything) and the size
> (as stringops may access multiple array elements). */
> if (exp)
861,862c1054,1128
< exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
< /* memcpy, memset and other builtin stringops can alias with anything. */
---
> set_mem_attributes (mem, exp, 0);
>
> /* Allow the string and memory builtins to overflow from one
> field into another, see http://gcc.gnu.org/PR23561.
> Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
> memory accessed by the string or memory builtin will fit
> within the field. */
> if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
> {
> tree mem_expr = MEM_EXPR (mem);
> HOST_WIDE_INT offset = -1, length = -1;
> tree inner = exp;
>
> while (TREE_CODE (inner) == ARRAY_REF
> || TREE_CODE (inner) == NOP_EXPR
> || TREE_CODE (inner) == CONVERT_EXPR
> || TREE_CODE (inner) == NON_LVALUE_EXPR
> || TREE_CODE (inner) == VIEW_CONVERT_EXPR
> || TREE_CODE (inner) == SAVE_EXPR)
> inner = TREE_OPERAND (inner, 0);
>
> gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
>
> if (MEM_OFFSET (mem)
> && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
> offset = INTVAL (MEM_OFFSET (mem));
>
> if (offset >= 0 && len && host_integerp (len, 0))
> length = tree_low_cst (len, 0);
>
> while (TREE_CODE (inner) == COMPONENT_REF)
> {
> tree field = TREE_OPERAND (inner, 1);
> gcc_assert (! DECL_BIT_FIELD (field));
> gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
> gcc_assert (field == TREE_OPERAND (mem_expr, 1));
>
> if (length >= 0
> && TYPE_SIZE_UNIT (TREE_TYPE (inner))
> && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0))
> {
> HOST_WIDE_INT size
> = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0);
> /* If we can prove the memory starting at XEXP (mem, 0)
> and ending at XEXP (mem, 0) + LENGTH will fit into
> this field, we can keep that COMPONENT_REF in MEM_EXPR. */
> if (offset <= size
> && length <= size
> && offset + length <= size)
> break;
> }
>
> if (offset >= 0
> && host_integerp (DECL_FIELD_OFFSET (field), 0))
> offset += tree_low_cst (DECL_FIELD_OFFSET (field), 0)
> + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
> / BITS_PER_UNIT;
> else
> {
> offset = -1;
> length = -1;
> }
>
> mem_expr = TREE_OPERAND (mem_expr, 0);
> inner = TREE_OPERAND (inner, 0);
> }
>
> if (mem_expr == NULL)
> offset = -1;
> if (mem_expr != MEM_EXPR (mem))
> {
> set_mem_expr (mem, mem_expr);
> set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
> }
> }
863a1130
> set_mem_size (mem, NULL_RTX);
891,907d1157
< /* Return the offset of register REGNO into the block returned by
< __builtin_apply_args. This is not declared static, since it is
< needed in objc-act.c. */
<
< int
< apply_args_register_offset (int regno)
< {
< apply_args_size ();
<
< /* Arguments are always put in outgoing registers (in the argument
< block) if such make sense. */
< #ifdef OUTGOING_REGNO
< regno = OUTGOING_REGNO (regno);
< #endif
< return apply_args_reg_offset[regno];
< }
<
933,935c1183
< /* Search for the proper mode for copying this register's
< value. I'm not sure this is right, but it works so far. */
< enum machine_mode best_mode = VOIDmode;
---
> mode = reg_raw_mode[regno];
937,942c1185
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && HARD_REGNO_NREGS (regno, mode) == 1)
< best_mode = mode;
---
> gcc_assert (mode != VOIDmode);
944,971d1186
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< mode = best_mode;
< if (mode == VOIDmode)
< abort ();
<
1006,1008c1221
< /* Search for the proper mode for copying this register's
< value. I'm not sure this is right, but it works so far. */
< enum machine_mode best_mode = VOIDmode;
---
> mode = reg_raw_mode[regno];
1010,1014c1223
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
< mode != TImode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode))
< best_mode = mode;
---
> gcc_assert (mode != VOIDmode);
1016,1043d1224
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< if (best_mode == VOIDmode)
< for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
< mode != VOIDmode;
< mode = GET_MODE_WIDER_MODE (mode))
< if (HARD_REGNO_MODE_OK (regno, mode)
< && have_insn_for (SET, mode))
< best_mode = mode;
<
< mode = best_mode;
< if (mode == VOIDmode)
< abort ();
<
1138c1319
<
---
>
1187c1368
< emit_insn_before (seq, NEXT_INSN (get_insns ()));
---
> emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1219,1221d1399
< /* Perform postincrements before actually calling the function. */
< emit_queue ();
<
1284c1462
< if (GET_CODE (struct_value) == REG)
---
> if (REG_P (struct_value))
1290c1468
< function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
---
> function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1317,1318c1495,1496
< if (valreg)
< abort (); /* HAVE_untyped_call required. */
---
> gcc_assert (!valreg); /* HAVE_untyped_call required. */
>
1330c1508
< abort ();
---
> gcc_unreachable ();
1411d1588
< case CHAR_TYPE: return char_type_class;
1426,1427d1602
< case SET_TYPE: return set_type_class;
< case FILE_TYPE: return file_type_class;
1444,1469d1618
< /* Expand expression EXP, which is a call to __builtin_constant_p. */
<
< static rtx
< expand_builtin_constant_p (tree arglist, enum machine_mode target_mode)
< {
< rtx tmp;
<
< if (arglist == 0)
< return const0_rtx;
< arglist = TREE_VALUE (arglist);
<
< /* We have taken care of the easy cases during constant folding. This
< case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE
< get a chance to see if it can deduce whether ARGLIST is constant.
< If CSE isn't going to run, of course, don't bother waiting. */
<
< if (cse_not_expected)
< return const0_rtx;
<
< current_function_calls_constant_p = 1;
<
< tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);
< tmp = gen_rtx_CONSTANT_P_RTX (target_mode, tmp);
< return tmp;
< }
<
1484d1632
< const enum machine_mode type_mode = TYPE_MODE (type);
1523a1672
> CASE_MATHFN (BUILT_IN_LCEIL)
1524a1674
> CASE_MATHFN (BUILT_IN_LFLOOR)
1525a1676,1677
> CASE_MATHFN (BUILT_IN_LLCEIL)
> CASE_MATHFN (BUILT_IN_LLFLOOR)
1541a1694
> CASE_MATHFN (BUILT_IN_POWI)
1567c1720
< if (type_mode == TYPE_MODE (double_type_node))
---
> if (TYPE_MAIN_VARIANT (type) == double_type_node)
1569c1722
< else if (type_mode == TYPE_MODE (float_type_node))
---
> else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1571c1724
< else if (type_mode == TYPE_MODE (long_double_type_node))
---
> else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1616c1769
< /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
---
> /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1640,1650c1793
< case BUILT_IN_SIN:
< case BUILT_IN_SINF:
< case BUILT_IN_SINL:
< builtin_optab = sin_optab; break;
< case BUILT_IN_COS:
< case BUILT_IN_COSF:
< case BUILT_IN_COSL:
< builtin_optab = cos_optab; break;
< case BUILT_IN_SQRT:
< case BUILT_IN_SQRTF:
< case BUILT_IN_SQRTL:
---
> CASE_FLT_FN (BUILT_IN_SQRT):
1654,1656c1797
< case BUILT_IN_EXP:
< case BUILT_IN_EXPF:
< case BUILT_IN_EXPL:
---
> CASE_FLT_FN (BUILT_IN_EXP):
1658,1660c1799,1810
< case BUILT_IN_LOG:
< case BUILT_IN_LOGF:
< case BUILT_IN_LOGL:
---
> CASE_FLT_FN (BUILT_IN_EXP10):
> CASE_FLT_FN (BUILT_IN_POW10):
> errno_set = true; builtin_optab = exp10_optab; break;
> CASE_FLT_FN (BUILT_IN_EXP2):
> errno_set = true; builtin_optab = exp2_optab; break;
> CASE_FLT_FN (BUILT_IN_EXPM1):
> errno_set = true; builtin_optab = expm1_optab; break;
> CASE_FLT_FN (BUILT_IN_LOGB):
> errno_set = true; builtin_optab = logb_optab; break;
> CASE_FLT_FN (BUILT_IN_ILOGB):
> errno_set = true; builtin_optab = ilogb_optab; break;
> CASE_FLT_FN (BUILT_IN_LOG):
1662,1664c1812,1822
< case BUILT_IN_TAN:
< case BUILT_IN_TANF:
< case BUILT_IN_TANL:
---
> CASE_FLT_FN (BUILT_IN_LOG10):
> errno_set = true; builtin_optab = log10_optab; break;
> CASE_FLT_FN (BUILT_IN_LOG2):
> errno_set = true; builtin_optab = log2_optab; break;
> CASE_FLT_FN (BUILT_IN_LOG1P):
> errno_set = true; builtin_optab = log1p_optab; break;
> CASE_FLT_FN (BUILT_IN_ASIN):
> builtin_optab = asin_optab; break;
> CASE_FLT_FN (BUILT_IN_ACOS):
> builtin_optab = acos_optab; break;
> CASE_FLT_FN (BUILT_IN_TAN):
1666,1668c1824
< case BUILT_IN_ATAN:
< case BUILT_IN_ATANF:
< case BUILT_IN_ATANL:
---
> CASE_FLT_FN (BUILT_IN_ATAN):
1670,1672c1826
< case BUILT_IN_FLOOR:
< case BUILT_IN_FLOORF:
< case BUILT_IN_FLOORL:
---
> CASE_FLT_FN (BUILT_IN_FLOOR):
1674,1676c1828
< case BUILT_IN_CEIL:
< case BUILT_IN_CEILF:
< case BUILT_IN_CEILL:
---
> CASE_FLT_FN (BUILT_IN_CEIL):
1678,1680c1830
< case BUILT_IN_TRUNC:
< case BUILT_IN_TRUNCF:
< case BUILT_IN_TRUNCL:
---
> CASE_FLT_FN (BUILT_IN_TRUNC):
1682,1684c1832
< case BUILT_IN_ROUND:
< case BUILT_IN_ROUNDF:
< case BUILT_IN_ROUNDL:
---
> CASE_FLT_FN (BUILT_IN_ROUND):
1686,1688c1834
< case BUILT_IN_NEARBYINT:
< case BUILT_IN_NEARBYINTF:
< case BUILT_IN_NEARBYINTL:
---
> CASE_FLT_FN (BUILT_IN_NEARBYINT):
1689a1836,1840
> CASE_FLT_FN (BUILT_IN_RINT):
> builtin_optab = rint_optab; break;
> CASE_FLT_FN (BUILT_IN_LRINT):
> CASE_FLT_FN (BUILT_IN_LLRINT):
> builtin_optab = lrint_optab; break;
1691c1842
< abort ();
---
> gcc_unreachable ();
1708c1859
< narg = save_expr (arg);
---
> narg = builtin_save_expr (arg);
1718d1868
< emit_queue ();
1772c1922
< && GET_CODE (operand) == REG
---
> && REG_P (operand)
1800a1951
> int op1_type = REAL_TYPE;
1808c1959,1964
< if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
---
> if ((DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXP)
> || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPF)
> || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPL))
> op1_type = INTEGER_TYPE;
>
> if (!validate_arglist (arglist, REAL_TYPE, op1_type, VOID_TYPE))
1816,1818c1972
< case BUILT_IN_POW:
< case BUILT_IN_POWF:
< case BUILT_IN_POWL:
---
> CASE_FLT_FN (BUILT_IN_POW):
1820,1822c1974
< case BUILT_IN_ATAN2:
< case BUILT_IN_ATAN2F:
< case BUILT_IN_ATAN2L:
---
> CASE_FLT_FN (BUILT_IN_ATAN2):
1823a1976,1981
> CASE_FLT_FN (BUILT_IN_LDEXP):
> builtin_optab = ldexp_optab; break;
> CASE_FLT_FN (BUILT_IN_FMOD):
> builtin_optab = fmod_optab; break;
> CASE_FLT_FN (BUILT_IN_DREM):
> builtin_optab = drem_optab; break;
1825c1983
< abort ();
---
> gcc_unreachable ();
1840,1841c1998,1999
< /* Alway stabilize the argument list. */
< narg = save_expr (arg1);
---
> /* Always stabilize the argument list. */
> narg = builtin_save_expr (arg1);
1851c2009
< narg = save_expr (arg0);
---
> narg = builtin_save_expr (arg0);
1864,1865c2022,2023
< op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
< op1 = expand_expr (arg1, 0, VOIDmode, 0);
---
> op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
> op1 = expand_normal (arg1);
1867d2024
< emit_queue ();
1894a2052,2311
> /* Expand a call to the builtin sin and cos math functions.
> Return 0 if a normal call should be emitted rather than expanding the
> function in-line. EXP is the expression that is a call to the builtin
> function; if convenient, the result should be placed in TARGET.
> SUBTARGET may be used as the target for computing one of EXP's
> operands. */
>
> static rtx
> expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
> {
> optab builtin_optab;
> rtx op0, insns;
> tree fndecl = get_callee_fndecl (exp);
> tree arglist = TREE_OPERAND (exp, 1);
> enum machine_mode mode;
> tree arg, narg;
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
>
> arg = TREE_VALUE (arglist);
>
> switch (DECL_FUNCTION_CODE (fndecl))
> {
> CASE_FLT_FN (BUILT_IN_SIN):
> CASE_FLT_FN (BUILT_IN_COS):
> builtin_optab = sincos_optab; break;
> default:
> gcc_unreachable ();
> }
>
> /* Make a suitable register to place result in. */
> mode = TYPE_MODE (TREE_TYPE (exp));
>
> /* Check if sincos insn is available, otherwise fallback
> to sin or cos insn. */
> if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) {
> switch (DECL_FUNCTION_CODE (fndecl))
> {
> CASE_FLT_FN (BUILT_IN_SIN):
> builtin_optab = sin_optab; break;
> CASE_FLT_FN (BUILT_IN_COS):
> builtin_optab = cos_optab; break;
> default:
> gcc_unreachable ();
> }
> }
>
> /* Before working hard, check whether the instruction is available. */
> if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
> {
> target = gen_reg_rtx (mode);
>
> /* Wrap the computation of the argument in a SAVE_EXPR, as we may
> need to expand the argument again. This way, we will not perform
> side-effects more the once. */
> narg = save_expr (arg);
> if (narg != arg)
> {
> arg = narg;
> arglist = build_tree_list (NULL_TREE, arg);
> exp = build_function_call_expr (fndecl, arglist);
> }
>
> op0 = expand_expr (arg, subtarget, VOIDmode, 0);
>
> start_sequence ();
>
> /* Compute into TARGET.
> Set TARGET to wherever the result comes back. */
> if (builtin_optab == sincos_optab)
> {
> int result;
>
> switch (DECL_FUNCTION_CODE (fndecl))
> {
> CASE_FLT_FN (BUILT_IN_SIN):
> result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
> break;
> CASE_FLT_FN (BUILT_IN_COS):
> result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
> break;
> default:
> gcc_unreachable ();
> }
> gcc_assert (result);
> }
> else
> {
> target = expand_unop (mode, builtin_optab, op0, target, 0);
> }
>
> if (target != 0)
> {
> /* Output the entire sequence. */
> insns = get_insns ();
> end_sequence ();
> emit_insn (insns);
> return target;
> }
>
> /* If we were unable to expand via the builtin, stop the sequence
> (without outputting the insns) and call to the library function
> with the stabilized argument list. */
> end_sequence ();
> }
>
> target = expand_call (exp, target, target == const0_rtx);
>
> return target;
> }
>
> /* Expand a call to the builtin sincos math function.
> Return 0 if a normal call should be emitted rather than expanding the
> function in-line. EXP is the expression that is a call to the builtin
> function. */
>
> static rtx
> expand_builtin_sincos (tree exp)
> {
> rtx op0, op1, op2, target1, target2;
> tree arglist = TREE_OPERAND (exp, 1);
> enum machine_mode mode;
> tree arg, sinp, cosp;
> int result;
>
> if (!validate_arglist (arglist, REAL_TYPE,
> POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
>
> arg = TREE_VALUE (arglist);
> sinp = TREE_VALUE (TREE_CHAIN (arglist));
> cosp = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
>
> /* Make a suitable register to place result in. */
> mode = TYPE_MODE (TREE_TYPE (arg));
>
> /* Check if sincos insn is available, otherwise emit the call. */
> if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
> return NULL_RTX;
>
> target1 = gen_reg_rtx (mode);
> target2 = gen_reg_rtx (mode);
>
> op0 = expand_normal (arg);
> op1 = expand_normal (build_fold_indirect_ref (sinp));
> op2 = expand_normal (build_fold_indirect_ref (cosp));
>
> /* Compute into target1 and target2.
> Set TARGET to wherever the result comes back. */
> result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
> gcc_assert (result);
>
> /* Move target1 and target2 to the memory locations indicated
> by op1 and op2. */
> emit_move_insn (op1, target1);
> emit_move_insn (op2, target2);
>
> return const0_rtx;
> }
>
> /* Expand a call to one of the builtin rounding functions (lfloor).
> If expanding via optab fails, lower expression to (int)(floor(x)).
> EXP is the expression that is a call to the builtin function;
> if convenient, the result should be placed in TARGET. SUBTARGET may
> be used as the target for computing one of EXP's operands. */
>
> static rtx
> expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
> {
> optab builtin_optab;
> rtx op0, insns, tmp;
> tree fndecl = get_callee_fndecl (exp);
> tree arglist = TREE_OPERAND (exp, 1);
> enum built_in_function fallback_fn;
> tree fallback_fndecl;
> enum machine_mode mode;
> tree arg, narg;
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> gcc_unreachable ();
>
> arg = TREE_VALUE (arglist);
>
> switch (DECL_FUNCTION_CODE (fndecl))
> {
> CASE_FLT_FN (BUILT_IN_LCEIL):
> CASE_FLT_FN (BUILT_IN_LLCEIL):
> builtin_optab = lceil_optab;
> fallback_fn = BUILT_IN_CEIL;
> break;
>
> CASE_FLT_FN (BUILT_IN_LFLOOR):
> CASE_FLT_FN (BUILT_IN_LLFLOOR):
> builtin_optab = lfloor_optab;
> fallback_fn = BUILT_IN_FLOOR;
> break;
>
> default:
> gcc_unreachable ();
> }
>
> /* Make a suitable register to place result in. */
> mode = TYPE_MODE (TREE_TYPE (exp));
>
> /* Before working hard, check whether the instruction is available. */
> if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
> {
> target = gen_reg_rtx (mode);
>
> /* Wrap the computation of the argument in a SAVE_EXPR, as we may
> need to expand the argument again. This way, we will not perform
> side-effects more the once. */
> narg = builtin_save_expr (arg);
> if (narg != arg)
> {
> arg = narg;
> arglist = build_tree_list (NULL_TREE, arg);
> exp = build_function_call_expr (fndecl, arglist);
> }
>
> op0 = expand_expr (arg, subtarget, VOIDmode, 0);
>
> start_sequence ();
>
> /* Compute into TARGET.
> Set TARGET to wherever the result comes back. */
> target = expand_unop (mode, builtin_optab, op0, target, 0);
>
> if (target != 0)
> {
> /* Output the entire sequence. */
> insns = get_insns ();
> end_sequence ();
> emit_insn (insns);
> return target;
> }
>
> /* If we were unable to expand via the builtin, stop the sequence
> (without outputting the insns). */
> end_sequence ();
> }
>
> /* Fall back to floating point rounding optab. */
> fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
> /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
> ??? Perhaps convert (int)floorf(x) into (int)floor((double)x). */
> gcc_assert (fallback_fndecl != NULL_TREE);
> exp = build_function_call_expr (fallback_fndecl, arglist);
>
> tmp = expand_normal (exp);
>
> /* Truncate the result of floating point optab to integer
> via expand_fix (). */
> target = gen_reg_rtx (mode);
> expand_fix (target, tmp, 0);
>
> return target;
> }
>
1908c2325
<
---
>
2025c2442
<
---
>
2043c2460
< return cache[n];
---
> return cache[n];
2074c2491
<
---
>
2144c2561,2564
< return expand_builtin_mathfn_2 (exp, target, NULL_RTX);
---
>
> if (! flag_unsafe_math_optimizations)
> return NULL_RTX;
> return expand_builtin_mathfn_2 (exp, target, subtarget);
2146a2567,2630
> /* Expand a call to the powi built-in mathematical function. Return 0 if
> a normal call should be emitted rather than expanding the function
> in-line. EXP is the expression that is a call to the builtin
> function; if convenient, the result should be placed in TARGET. */
>
> static rtx
> expand_builtin_powi (tree exp, rtx target, rtx subtarget)
> {
> tree arglist = TREE_OPERAND (exp, 1);
> tree arg0, arg1;
> rtx op0, op1;
> enum machine_mode mode;
> enum machine_mode mode2;
>
> if (! validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> arg0 = TREE_VALUE (arglist);
> arg1 = TREE_VALUE (TREE_CHAIN (arglist));
> mode = TYPE_MODE (TREE_TYPE (exp));
>
> /* Handle constant power. */
>
> if (TREE_CODE (arg1) == INTEGER_CST
> && ! TREE_CONSTANT_OVERFLOW (arg1))
> {
> HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
>
> /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
> Otherwise, check the number of multiplications required. */
> if ((TREE_INT_CST_HIGH (arg1) == 0
> || TREE_INT_CST_HIGH (arg1) == -1)
> && ((n >= -1 && n <= 2)
> || (! optimize_size
> && powi_cost (n) <= POWI_MAX_MULTS)))
> {
> op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
> op0 = force_reg (mode, op0);
> return expand_powi (op0, mode, n);
> }
> }
>
> /* Emit a libcall to libgcc. */
>
> /* Mode of the 2nd argument must match that of an int. */
> mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
>
> if (target == NULL_RTX)
> target = gen_reg_rtx (mode);
>
> op0 = expand_expr (arg0, subtarget, mode, 0);
> if (GET_MODE (op0) != mode)
> op0 = convert_to_mode (mode, op0, 0);
> op1 = expand_expr (arg1, 0, mode2, 0);
> if (GET_MODE (op1) != mode2)
> op1 = convert_to_mode (mode2, op1, 0);
>
> target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
> target, LCT_CONST_MAKE_BLOCK, mode, 2,
> op0, mode, op1, mode2);
>
> return target;
> }
>
2204c2688
< && GET_CODE (result) == REG
---
> && REG_P (result)
2232,2233c2716
< pat = memory_address (BLKmode,
< expand_expr (src, src_reg, ptr_mode, EXPAND_SUM));
---
> pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
2261c2744
< expand_builtin_strstr (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strstr (tree arglist, tree type, rtx target, enum machine_mode mode)
2263,2265c2746
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2267,2306c2748,2750
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< tree fn;
< const char *p1, *p2;
<
< p2 = c_getstr (s2);
< if (p2 == NULL)
< return 0;
<
< p1 = c_getstr (s1);
< if (p1 != NULL)
< {
< const char *r = strstr (p1, p2);
<
< if (r == NULL)
< return const0_rtx;
<
< /* Return an offset into the constant string argument. */
< return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
< s1, convert (TREE_TYPE (s1),
< ssize_int (r - p1)))),
< target, mode, EXPAND_NORMAL);
< }
<
< if (p2[0] == '\0')
< return expand_expr (s1, target, mode, EXPAND_NORMAL);
<
< if (p2[1] != '\0')
< return 0;
<
< fn = implicit_built_in_decls[BUILT_IN_STRCHR];
< if (!fn)
< return 0;
<
< /* New argument list transforming strstr(s1, s2) to
< strchr(s1, s2[0]). */
< arglist =
< build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
< arglist = tree_cons (NULL_TREE, s1, arglist);
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> tree result = fold_builtin_strstr (arglist, type);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2307a2752
> return 0;
2315c2760
< expand_builtin_strchr (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2317,2319c2762
< if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2321,2322c2764,2766
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< const char *p1;
---
> tree result = fold_builtin_strchr (arglist, type);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2324,2350c2768
< if (TREE_CODE (s2) != INTEGER_CST)
< return 0;
<
< p1 = c_getstr (s1);
< if (p1 != NULL)
< {
< char c;
< const char *r;
<
< if (target_char_cast (s2, &c))
< return 0;
<
< r = strchr (p1, c);
<
< if (r == NULL)
< return const0_rtx;
<
< /* Return an offset into the constant string argument. */
< return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
< s1, convert (TREE_TYPE (s1),
< ssize_int (r - p1)))),
< target, mode, EXPAND_NORMAL);
< }
<
< /* FIXME: Should use here strchrM optab so that ports can optimize
< this. */
< return 0;
---
> /* FIXME: Should use strchrM optab so that ports can optimize this. */
2351a2770
> return 0;
2359c2778
< expand_builtin_strrchr (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strrchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2361,2363c2780
< if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2365,2402c2782,2784
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< tree fn;
< const char *p1;
<
< if (TREE_CODE (s2) != INTEGER_CST)
< return 0;
<
< p1 = c_getstr (s1);
< if (p1 != NULL)
< {
< char c;
< const char *r;
<
< if (target_char_cast (s2, &c))
< return 0;
<
< r = strrchr (p1, c);
<
< if (r == NULL)
< return const0_rtx;
<
< /* Return an offset into the constant string argument. */
< return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
< s1, convert (TREE_TYPE (s1),
< ssize_int (r - p1)))),
< target, mode, EXPAND_NORMAL);
< }
<
< if (! integer_zerop (s2))
< return 0;
<
< fn = implicit_built_in_decls[BUILT_IN_STRCHR];
< if (!fn)
< return 0;
<
< /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> tree result = fold_builtin_strrchr (arglist, type);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2403a2786
> return 0;
2411c2794
< expand_builtin_strpbrk (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strpbrk (tree arglist, tree type, rtx target, enum machine_mode mode)
2413,2415c2796
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2417,2462c2798,2800
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< tree fn;
< const char *p1, *p2;
<
< p2 = c_getstr (s2);
< if (p2 == NULL)
< return 0;
<
< p1 = c_getstr (s1);
< if (p1 != NULL)
< {
< const char *r = strpbrk (p1, p2);
<
< if (r == NULL)
< return const0_rtx;
<
< /* Return an offset into the constant string argument. */
< return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
< s1, convert (TREE_TYPE (s1),
< ssize_int (r - p1)))),
< target, mode, EXPAND_NORMAL);
< }
<
< if (p2[0] == '\0')
< {
< /* strpbrk(x, "") == NULL.
< Evaluate and ignore the arguments in case they had
< side-effects. */
< expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
<
< if (p2[1] != '\0')
< return 0; /* Really call strpbrk. */
<
< fn = implicit_built_in_decls[BUILT_IN_STRCHR];
< if (!fn)
< return 0;
<
< /* New argument list transforming strpbrk(s1, s2) to
< strchr(s1, s2[0]). */
< arglist =
< build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
< arglist = tree_cons (NULL_TREE, s1, arglist);
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> tree result = fold_builtin_strpbrk (arglist, type);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2463a2802
> return 0;
2476,2479c2815,2817
< if (offset < 0
< || ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
< > strlen (str) + 1))
< abort (); /* Attempt to read past the end of constant string. */
---
> gcc_assert (offset >= 0
> && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
> <= strlen (str) + 1));
2489c2827
< expand_builtin_memcpy (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
2490a2829,2830
> tree fndecl = get_callee_fndecl (exp);
> tree arglist = TREE_OPERAND (exp, 1);
2503a2844,2845
> tree result = fold_builtin_memory_op (arglist, TREE_TYPE (TREE_TYPE (fndecl)),
> false, /*endp=*/0);
2504a2847,2857
> if (result)
> {
> while (TREE_CODE (result) == COMPOUND_EXPR)
> {
> expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
> EXPAND_NORMAL);
> result = TREE_OPERAND (result, 1);
> }
> return expand_expr (result, target, mode, EXPAND_NORMAL);
> }
>
2509,2524d2861
< /* If the LEN parameter is zero, return DEST. */
< if (integer_zerop (len))
< {
< /* Evaluate and ignore SRC in case it has side-effects. */
< expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
< }
<
< /* If SRC and DEST are the same (and not volatile), return DEST. */
< if (operand_equal_p (src, dest, 0))
< {
< /* Evaluate and ignore LEN in case it has side-effects. */
< expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
< }
<
2526c2863
< operation in-line. */
---
> operation in-line. */
2530c2867
< dest_mem = get_memory_rtx (dest);
---
> dest_mem = get_memory_rtx (dest, len);
2532c2869
< len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
---
> len_rtx = expand_normal (len);
2552c2889
< src_mem = get_memory_rtx (src);
---
> src_mem = get_memory_rtx (src, len);
2557c2894,2895
< BLOCK_OP_NORMAL);
---
> CALL_EXPR_TAILCALL (exp)
> ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
2569c2907
< Return 0 if we failed the caller should emit a normal call,
---
> Return 0 if we failed; the caller should emit a normal call,
2577c2915
< expand_builtin_mempcpy (tree arglist, rtx target, enum machine_mode mode,
---
> expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode mode,
2603a2942
> tree result = fold_builtin_memory_op (arglist, type, false, endp);
2605,2610c2944
< /* If DEST is not a pointer type, call the normal function. */
< if (dest_align == 0)
< return 0;
<
< /* If SRC and DEST are the same (and not volatile), do nothing. */
< if (operand_equal_p (src, dest, 0))
---
> if (result)
2612,2614c2946
< tree expr;
<
< if (endp == 0)
---
> while (TREE_CODE (result) == COMPOUND_EXPR)
2616,2618c2948,2950
< /* Evaluate and ignore LEN in case it has side-effects. */
< expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
---
> expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
> EXPAND_NORMAL);
> result = TREE_OPERAND (result, 1);
2620,2626c2952
<
< if (endp == 2)
< len = fold (build (MINUS_EXPR, TREE_TYPE (len), dest,
< integer_one_node));
< len = convert (TREE_TYPE (dest), len);
< expr = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
< return expand_expr (expr, target, mode, EXPAND_NORMAL);
---
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2628a2955,2959
> /* If either SRC or DEST is not a pointer type, don't do this
> operation in-line. */
> if (dest_align == 0 || src_align == 0)
> return 0;
>
2632,2639d2962
<
< /* If the LEN parameter is zero, return DEST. */
< if (tree_low_cst (len, 1) == 0)
< {
< /* Evaluate and ignore SRC in case it has side-effects. */
< expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
< }
2641,2646c2964
< /* If either SRC is not a pointer type, don't do this
< operation in-line. */
< if (src_align == 0)
< return 0;
<
< len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
---
> len_rtx = expand_normal (len);
2658c2976
< dest_mem = get_memory_rtx (dest);
---
> dest_mem = get_memory_rtx (dest, len);
2672c2990
< dest_mem = get_memory_rtx (dest);
---
> dest_mem = get_memory_rtx (dest, len);
2674c2992
< src_mem = get_memory_rtx (src);
---
> src_mem = get_memory_rtx (src, len);
2688c3006
< if we failed the caller should emit a normal call. */
---
> if we failed; the caller should emit a normal call. */
2691c3009,3010
< expand_builtin_memmove (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_memmove (tree arglist, tree type, rtx target,
> enum machine_mode mode, tree orig_exp)
2704a3024
> tree result = fold_builtin_memory_op (arglist, type, false, /*endp=*/3);
2705a3026,3036
> if (result)
> {
> while (TREE_CODE (result) == COMPOUND_EXPR)
> {
> expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
> EXPAND_NORMAL);
> result = TREE_OPERAND (result, 1);
> }
> return expand_expr (result, target, mode, EXPAND_NORMAL);
> }
>
2710,2725d3040
< /* If the LEN parameter is zero, return DEST. */
< if (integer_zerop (len))
< {
< /* Evaluate and ignore SRC in case it has side-effects. */
< expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
< }
<
< /* If SRC and DEST are the same (and not volatile), return DEST. */
< if (operand_equal_p (src, dest, 0))
< {
< /* Evaluate and ignore LEN in case it has side-effects. */
< expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dest, target, mode, EXPAND_NORMAL);
< }
<
2727c3042
< operation in-line. */
---
> operation in-line. */
2734,2735c3049,3050
< {
< tree const fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
---
> {
> tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2738,2739c3053,3056
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> fn = build_function_call_expr (fn, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
> return expand_expr (fn, target, mode, EXPAND_NORMAL);
2741a3059,3068
> /* If length is 1 and we can expand memcpy call inline,
> it is ok to use memcpy as well. */
> if (integer_onep (len))
> {
> rtx ret = expand_builtin_mempcpy (arglist, type, target, mode,
> /*endp=*/0);
> if (ret)
> return ret;
> }
>
2751c3078
< expand_builtin_bcopy (tree arglist)
---
> expand_builtin_bcopy (tree exp)
2752a3080,3081
> tree arglist = TREE_OPERAND (exp, 1);
> tree type = TREE_TYPE (exp);
2768c3097
< newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
---
> newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
2772c3101
< return expand_builtin_memmove (newarglist, const0_rtx, VOIDmode);
---
> return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode, exp);
2775,2778c3104,3107
< /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
< if we failed the caller should emit a normal call, otherwise try to get
< the result in TARGET, if convenient (and in mode MODE if that's
< convenient). */
---
> #ifndef HAVE_movstr
> # define HAVE_movstr 0
> # define CODE_FOR_movstr CODE_FOR_nothing
> #endif
2779a3109,3115
> /* Expand into a movstr instruction, if one is available. Return 0 if
> we failed, the caller should emit a normal call, otherwise try to
> get the result in TARGET, if convenient. If ENDP is 0 return the
> destination pointer, if ENDP is 1 return the end pointer ala
> mempcpy, and if ENDP is 2 return the end pointer minus one ala
> stpcpy. */
>
2781c3117
< expand_builtin_strcpy (tree arglist, rtx target, enum machine_mode mode)
---
> expand_movstr (tree dest, tree src, rtx target, int endp)
2783c3119,3123
< tree fn, len, src, dst;
---
> rtx end;
> rtx dest_mem;
> rtx src_mem;
> rtx insn;
> const struct insn_data * data;
2785c3125
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
---
> if (!HAVE_movstr)
2788,2789c3128,3146
< src = TREE_VALUE (TREE_CHAIN (arglist));
< dst = TREE_VALUE (arglist);
---
> dest_mem = get_memory_rtx (dest, NULL);
> src_mem = get_memory_rtx (src, NULL);
> if (!endp)
> {
> target = force_reg (Pmode, XEXP (dest_mem, 0));
> dest_mem = replace_equiv_address (dest_mem, target);
> end = gen_reg_rtx (Pmode);
> }
> else
> {
> if (target == 0 || target == const0_rtx)
> {
> end = gen_reg_rtx (Pmode);
> if (target == 0)
> target = end;
> }
> else
> end = target;
> }
2791,2793c3148
< /* If SRC and DST are equal (and not volatile), return DST. */
< if (operand_equal_p (src, dst, 0))
< return expand_expr (dst, target, mode, EXPAND_NORMAL);
---
> data = insn_data + CODE_FOR_movstr;
2795,2797c3150,3151
< fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
< if (!fn)
< return 0;
---
> if (data->operand[0].mode != VOIDmode)
> end = gen_lowpart (data->operand[0].mode, end);
2799,2801c3153
< len = c_strlen (src, 1);
< if (len == 0 || TREE_SIDE_EFFECTS (len))
< return 0;
---
> insn = data->genfun (end, dest_mem, src_mem);
2803,2808c3155,3168
< len = size_binop (PLUS_EXPR, len, ssize_int (1));
< arglist = build_tree_list (NULL_TREE, len);
< arglist = tree_cons (NULL_TREE, src, arglist);
< arglist = tree_cons (NULL_TREE, dst, arglist);
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> gcc_assert (insn);
>
> emit_insn (insn);
>
> /* movstr is supposed to set end to the address of the NUL
> terminator. If the caller requested a mempcpy-like return value,
> adjust it. */
> if (endp == 1 && target != const0_rtx)
> {
> rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
> emit_move_insn (target, force_operand (tem, NULL_RTX));
> }
>
> return target;
2810a3171,3199
> /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
> if we failed the caller should emit a normal call, otherwise try to get
> the result in TARGET, if convenient (and in mode MODE if that's
> convenient). */
>
> static rtx
> expand_builtin_strcpy (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
> {
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> {
> tree result = fold_builtin_strcpy (fndecl, arglist, 0);
> if (result)
> {
> while (TREE_CODE (result) == COMPOUND_EXPR)
> {
> expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
> EXPAND_NORMAL);
> result = TREE_OPERAND (result, 1);
> }
> return expand_expr (result, target, mode, EXPAND_NORMAL);
> }
>
> return expand_movstr (TREE_VALUE (arglist),
> TREE_VALUE (TREE_CHAIN (arglist)),
> target, /*endp=*/0);
> }
> return 0;
> }
>
2817c3206
< expand_builtin_stpcpy (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
2818a3208,3219
> tree arglist = TREE_OPERAND (exp, 1);
> /* If return value is ignored, transform stpcpy into strcpy. */
> if (target == const0_rtx)
> {
> tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
> if (!fn)
> return 0;
>
> return expand_expr (build_function_call_expr (fn, arglist),
> target, mode, EXPAND_NORMAL);
> }
>
2823c3224,3226
< tree dst, src, len;
---
> tree dst, src, len, lenp1;
> tree narglist;
> rtx ret;
2825,2835d3227
< /* If return value is ignored, transform stpcpy into strcpy. */
< if (target == const0_rtx)
< {
< tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
< if (!fn)
< return 0;
<
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
< }
<
2837,2839c3229,3231
< compile-time, not an expression containing a string. This is
< because the latter will potentially produce pessimized code
< when used to produce the return value. */
---
> compile-time, not an expression containing a string. This is
> because the latter will potentially produce pessimized code
> when used to produce the return value. */
2842c3234,3236
< return 0;
---
> return expand_movstr (TREE_VALUE (arglist),
> TREE_VALUE (TREE_CHAIN (arglist)),
> target, /*endp=*/2);
2845,2849c3239,3281
< len = fold (size_binop (PLUS_EXPR, len, ssize_int (1)));
< arglist = build_tree_list (NULL_TREE, len);
< arglist = tree_cons (NULL_TREE, src, arglist);
< arglist = tree_cons (NULL_TREE, dst, arglist);
< return expand_builtin_mempcpy (arglist, target, mode, /*endp=*/2);
---
> lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
> narglist = build_tree_list (NULL_TREE, lenp1);
> narglist = tree_cons (NULL_TREE, src, narglist);
> narglist = tree_cons (NULL_TREE, dst, narglist);
> ret = expand_builtin_mempcpy (narglist, TREE_TYPE (exp),
> target, mode, /*endp=*/2);
>
> if (ret)
> return ret;
>
> if (TREE_CODE (len) == INTEGER_CST)
> {
> rtx len_rtx = expand_normal (len);
>
> if (GET_CODE (len_rtx) == CONST_INT)
> {
> ret = expand_builtin_strcpy (get_callee_fndecl (exp),
> arglist, target, mode);
>
> if (ret)
> {
> if (! target)
> {
> if (mode != VOIDmode)
> target = gen_reg_rtx (mode);
> else
> target = gen_reg_rtx (GET_MODE (ret));
> }
> if (GET_MODE (target) != GET_MODE (ret))
> ret = gen_lowpart (GET_MODE (target), ret);
>
> ret = plus_constant (ret, INTVAL (len_rtx));
> ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
> gcc_assert (ret);
>
> return target;
> }
> }
> }
>
> return expand_movstr (TREE_VALUE (arglist),
> TREE_VALUE (TREE_CHAIN (arglist)),
> target, /*endp=*/2);
2873c3305
< expand_builtin_strncpy (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
2875,2878c3307,3310
< if (!validate_arglist (arglist,
< POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
< return 0;
< else
---
> tree fndecl = get_callee_fndecl (exp);
> tree arglist = TREE_OPERAND (exp, 1);
> if (validate_arglist (arglist,
> POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2882c3314
< tree fn;
---
> tree result = fold_builtin_strncpy (fndecl, arglist, slen);
2884,2889c3316
< /* We must be passed a constant len parameter. */
< if (TREE_CODE (len) != INTEGER_CST)
< return 0;
<
< /* If the len parameter is zero, return the dst parameter. */
< if (integer_zerop (len))
---
> if (result)
2891,2897c3318,3324
< /* Evaluate and ignore the src argument in case it has
< side-effects. */
< expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
< VOIDmode, EXPAND_NORMAL);
< /* Return the dst parameter. */
< return expand_expr (TREE_VALUE (arglist), target, mode,
< EXPAND_NORMAL);
---
> while (TREE_CODE (result) == COMPOUND_EXPR)
> {
> expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
> EXPAND_NORMAL);
> result = TREE_OPERAND (result, 1);
> }
> return expand_expr (result, target, mode, EXPAND_NORMAL);
2900,2901c3327,3328
< /* Now, we must be passed a constant src ptr parameter. */
< if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
---
> /* We must be passed a constant len and src parameter. */
> if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
2907c3334
< len is greater than strlen(s2)+1. In that case try to
---
> len is greater than strlen(s2)+1. In that case try to
2923c3350
< dest_mem = get_memory_rtx (dest);
---
> dest_mem = get_memory_rtx (dest, len);
2931,2937d3357
<
< /* OK transform into builtin memcpy. */
< fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
< if (!fn)
< return 0;
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
2938a3359
> return 0;
2989c3410,3411
< expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode,
> tree orig_exp)
2998a3421,3422
> tree fndecl, fn;
> enum built_in_function fcode;
3000,3002c3424
<
< unsigned int dest_align
< = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
---
> unsigned int dest_align;
3004a3427,3428
> dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
>
3017a3442,3449
> /* Stabilize the arguments in case we fail. */
> dest = builtin_save_expr (dest);
> val = builtin_save_expr (val);
> len = builtin_save_expr (len);
>
> len_rtx = expand_normal (len);
> dest_mem = get_memory_rtx (dest, len);
>
3022,3023c3454,3456
< if (!host_integerp (len, 1))
< return 0;
---
> val_rtx = expand_normal (val);
> val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
> val_rtx, 0);
3025,3027d3457
< if (optimize_size && tree_low_cst (len, 1) > 1)
< return 0;
<
3032,3035c3462,3474
< if (!can_store_by_pieces (tree_low_cst (len, 1),
< builtin_memset_read_str,
< &c, dest_align))
< return 0;
---
> if (host_integerp (len, 1)
> && !(optimize_size && tree_low_cst (len, 1) > 1)
> && can_store_by_pieces (tree_low_cst (len, 1),
> builtin_memset_read_str, &c, dest_align))
> {
> val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
> val_rtx);
> store_by_pieces (dest_mem, tree_low_cst (len, 1),
> builtin_memset_gen_str, val_rtx, dest_align, 0);
> }
> else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
> dest_align))
> goto do_libcall;
3037,3044d3475
< val = fold (build1 (CONVERT_EXPR, unsigned_char_type_node, val));
< val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
< val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
< val_rtx);
< dest_mem = get_memory_rtx (dest);
< store_by_pieces (dest_mem, tree_low_cst (len, 1),
< builtin_memset_gen_str,
< val_rtx, dest_align, 0);
3051c3482
< return 0;
---
> goto do_libcall;
3055,3060c3486,3494
< if (!host_integerp (len, 1))
< return 0;
< if (!can_store_by_pieces (tree_low_cst (len, 1),
< builtin_memset_read_str, &c,
< dest_align))
< return 0;
---
> if (host_integerp (len, 1)
> && !(optimize_size && tree_low_cst (len, 1) > 1)
> && can_store_by_pieces (tree_low_cst (len, 1),
> builtin_memset_read_str, &c, dest_align))
> store_by_pieces (dest_mem, tree_low_cst (len, 1),
> builtin_memset_read_str, &c, dest_align, 0);
> else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
> dest_align))
> goto do_libcall;
3062,3065d3495
< dest_mem = get_memory_rtx (dest);
< store_by_pieces (dest_mem, tree_low_cst (len, 1),
< builtin_memset_read_str,
< &c, dest_align, 0);
3071,3073d3500
< len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
<
< dest_mem = get_memory_rtx (dest);
3075c3502,3504
< dest_addr = clear_storage (dest_mem, len_rtx);
---
> dest_addr = clear_storage (dest_mem, len_rtx,
> CALL_EXPR_TAILCALL (orig_exp)
> ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
3083a3513,3525
>
> do_libcall:
> fndecl = get_callee_fndecl (orig_exp);
> fcode = DECL_FUNCTION_CODE (fndecl);
> gcc_assert (fcode == BUILT_IN_MEMSET || fcode == BUILT_IN_BZERO);
> arglist = build_tree_list (NULL_TREE, len);
> if (fcode == BUILT_IN_MEMSET)
> arglist = tree_cons (NULL_TREE, val, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> fn = build_function_call_expr (fndecl, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
> return expand_call (fn, target, target == const0_rtx);
3091c3533
< expand_builtin_bzero (tree arglist)
---
> expand_builtin_bzero (tree exp)
3092a3535
> tree arglist = TREE_OPERAND (exp, 1);
3106c3549
< newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
---
> newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3110c3553
< return expand_builtin_memset (newarglist, const0_rtx, VOIDmode);
---
> return expand_builtin_memset (newarglist, const0_rtx, VOIDmode, exp);
3122,3124d3564
< tree arg1, arg2, len;
< const char *p1, *p2;
<
3128,3134c3568
<
< arg1 = TREE_VALUE (arglist);
< arg2 = TREE_VALUE (TREE_CHAIN (arglist));
< len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
<
< /* If the len parameter is zero, return zero. */
< if (integer_zerop (len))
---
> else
3136,3140c3570,3572
< /* Evaluate and ignore arg1 and arg2 in case they have
< side-effects. */
< expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
< expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
---
> tree result = fold_builtin_memcmp (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
3143,3183c3575
< /* If both arguments are equal (and not volatile), return zero. */
< if (operand_equal_p (arg1, arg2, 0))
< {
< /* Evaluate and ignore len in case it has side-effects. */
< expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
<
< p1 = c_getstr (arg1);
< p2 = c_getstr (arg2);
<
< /* If all arguments are constant, and the value of len is not greater
< than the lengths of arg1 and arg2, evaluate at compile-time. */
< if (host_integerp (len, 1) && p1 && p2
< && compare_tree_int (len, strlen (p1) + 1) <= 0
< && compare_tree_int (len, strlen (p2) + 1) <= 0)
< {
< const int r = memcmp (p1, p2, tree_low_cst (len, 1));
<
< return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
< }
<
< /* If len parameter is one, return an expression corresponding to
< (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
< if (integer_onep (len))
< {
< tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
< tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
< tree ind1 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
< tree ind2 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
< tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
< return expand_expr (result, target, mode, EXPAND_NORMAL);
< }
<
< #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
---
> #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3184a3577,3579
> tree arg1 = TREE_VALUE (arglist);
> tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
> tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3200,3202c3595,3597
< #ifdef HAVE_cmpstrsi
< if (HAVE_cmpstrsi)
< insn_mode = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
---
> #ifdef HAVE_cmpstrnsi
> if (HAVE_cmpstrnsi)
> insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3205c3600
< return 0;
---
> return 0;
3214c3609
< && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
---
> && REG_P (result) && GET_MODE (result) == insn_mode
3218,3220c3613,3623
< arg1_rtx = get_memory_rtx (arg1);
< arg2_rtx = get_memory_rtx (arg2);
< arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
---
> arg1_rtx = get_memory_rtx (arg1, len);
> arg2_rtx = get_memory_rtx (arg2, len);
> arg3_rtx = expand_normal (len);
>
> /* Set MEM_SIZE as appropriate. */
> if (GET_CODE (arg3_rtx) == CONST_INT)
> {
> set_mem_size (arg1_rtx, arg3_rtx);
> set_mem_size (arg2_rtx, arg3_rtx);
> }
>
3227,3230c3630,3633
< #ifdef HAVE_cmpstrsi
< if (HAVE_cmpstrsi)
< insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
< GEN_INT (MIN (arg1_align, arg2_align)));
---
> #ifdef HAVE_cmpstrnsi
> if (HAVE_cmpstrnsi)
> insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
> GEN_INT (MIN (arg1_align, arg2_align)));
3233c3636
< abort ();
---
> gcc_unreachable ();
3243c3646
< TREE_UNSIGNED (sizetype)),
---
> TYPE_UNSIGNED (sizetype)),
3271,3272d3673
< tree arg1, arg2;
< const char *p1, *p2;
3275a3677,3682
> else
> {
> tree result = fold_builtin_strcmp (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
> }
3277,3278c3684,3690
< arg1 = TREE_VALUE (arglist);
< arg2 = TREE_VALUE (TREE_CHAIN (arglist));
---
> #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
> if (cmpstr_optab[SImode] != CODE_FOR_nothing
> || cmpstrn_optab[SImode] != CODE_FOR_nothing)
> {
> rtx arg1_rtx, arg2_rtx;
> rtx result, insn = NULL_RTX;
> tree fndecl, fn;
3280,3282c3692,3697
< /* If both arguments are equal (and not volatile), return zero. */
< if (operand_equal_p (arg1, arg2, 0))
< return const0_rtx;
---
> tree arg1 = TREE_VALUE (arglist);
> tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
> int arg1_align
> = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
> int arg2_align
> = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3284,3285c3699,3701
< p1 = c_getstr (arg1);
< p2 = c_getstr (arg2);
---
> /* If we don't have POINTER_TYPE, call the function. */
> if (arg1_align == 0 || arg2_align == 0)
> return 0;
3287,3291c3703,3705
< if (p1 && p2)
< {
< const int i = strcmp (p1, p2);
< return (i < 0 ? constm1_rtx : (i > 0 ? const1_rtx : const0_rtx));
< }
---
> /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
> arg1 = builtin_save_expr (arg1);
> arg2 = builtin_save_expr (arg2);
3293,3309c3707,3708
< /* If either arg is "", return an expression corresponding to
< (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
< if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
< {
< tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
< tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
< tree ind1 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
< tree ind2 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
< tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
< return expand_expr (result, target, mode, EXPAND_NORMAL);
< }
---
> arg1_rtx = get_memory_rtx (arg1, NULL);
> arg2_rtx = get_memory_rtx (arg2, NULL);
3312,3317c3711,3715
< if (HAVE_cmpstrsi)
< {
< tree len, len1, len2;
< rtx arg1_rtx, arg2_rtx, arg3_rtx;
< rtx result, insn;
< tree fndecl;
---
> /* Try to call cmpstrsi. */
> if (HAVE_cmpstrsi)
> {
> enum machine_mode insn_mode
> = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3319,3324c3717,3722
< int arg1_align
< = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
< int arg2_align
< = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
< enum machine_mode insn_mode
< = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
---
> /* Make a place to write the result of the instruction. */
> result = target;
> if (! (result != 0
> && REG_P (result) && GET_MODE (result) == insn_mode
> && REGNO (result) >= FIRST_PSEUDO_REGISTER))
> result = gen_reg_rtx (insn_mode);
3326,3327c3724,3733
< len1 = c_strlen (arg1, 1);
< len2 = c_strlen (arg2, 1);
---
> insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
> GEN_INT (MIN (arg1_align, arg2_align)));
> }
> #endif
> #ifdef HAVE_cmpstrnsi
> /* Try to determine at least one length and call cmpstrnsi. */
> if (!insn && HAVE_cmpstrnsi)
> {
> tree len;
> rtx arg3_rtx;
3329,3332c3735,3738
< if (len1)
< len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
< if (len2)
< len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
---
> enum machine_mode insn_mode
> = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
> tree len1 = c_strlen (arg1, 1);
> tree len2 = c_strlen (arg2, 1);
3334,3339c3740,3743
< /* If we don't have a constant length for the first, use the length
< of the second, if we know it. We don't require a constant for
< this case; some cost analysis could be done if both are available
< but neither is constant. For now, assume they're equally cheap,
< unless one has side effects. If both strings have constant lengths,
< use the smaller. */
---
> if (len1)
> len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
> if (len2)
> len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3341,3356c3745,3750
< if (!len1)
< len = len2;
< else if (!len2)
< len = len1;
< else if (TREE_SIDE_EFFECTS (len1))
< len = len2;
< else if (TREE_SIDE_EFFECTS (len2))
< len = len1;
< else if (TREE_CODE (len1) != INTEGER_CST)
< len = len2;
< else if (TREE_CODE (len2) != INTEGER_CST)
< len = len1;
< else if (tree_int_cst_lt (len1, len2))
< len = len1;
< else
< len = len2;
---
> /* If we don't have a constant length for the first, use the length
> of the second, if we know it. We don't require a constant for
> this case; some cost analysis could be done if both are available
> but neither is constant. For now, assume they're equally cheap,
> unless one has side effects. If both strings have constant lengths,
> use the smaller. */
3358,3360c3752,3767
< /* If both arguments have side effects, we cannot optimize. */
< if (!len || TREE_SIDE_EFFECTS (len))
< return 0;
---
> if (!len1)
> len = len2;
> else if (!len2)
> len = len1;
> else if (TREE_SIDE_EFFECTS (len1))
> len = len2;
> else if (TREE_SIDE_EFFECTS (len2))
> len = len1;
> else if (TREE_CODE (len1) != INTEGER_CST)
> len = len2;
> else if (TREE_CODE (len2) != INTEGER_CST)
> len = len1;
> else if (tree_int_cst_lt (len1, len2))
> len = len1;
> else
> len = len2;
3362,3364c3769,3771
< /* If we don't have POINTER_TYPE, call the function. */
< if (arg1_align == 0 || arg2_align == 0)
< return 0;
---
> /* If both arguments have side effects, we cannot optimize. */
> if (!len || TREE_SIDE_EFFECTS (len))
> goto do_libcall;
3366,3371c3773
< /* Make a place to write the result of the instruction. */
< result = target;
< if (! (result != 0
< && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
< && REGNO (result) >= FIRST_PSEUDO_REGISTER))
< result = gen_reg_rtx (insn_mode);
---
> arg3_rtx = expand_normal (len);
3373,3375c3775,3780
< /* Stabilize the arguments in case gen_cmpstrsi fails. */
< arg1 = save_expr (arg1);
< arg2 = save_expr (arg2);
---
> /* Make a place to write the result of the instruction. */
> result = target;
> if (! (result != 0
> && REG_P (result) && GET_MODE (result) == insn_mode
> && REGNO (result) >= FIRST_PSEUDO_REGISTER))
> result = gen_reg_rtx (insn_mode);
3377,3384c3782,3785
< arg1_rtx = get_memory_rtx (arg1);
< arg2_rtx = get_memory_rtx (arg2);
< arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
< insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
< GEN_INT (MIN (arg1_align, arg2_align)));
< if (insn)
< {
< emit_insn (insn);
---
> insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
> GEN_INT (MIN (arg1_align, arg2_align)));
> }
> #endif
3386,3394c3787,3789
< /* Return the value in the proper mode for this function. */
< mode = TYPE_MODE (TREE_TYPE (exp));
< if (GET_MODE (result) == mode)
< return result;
< if (target == 0)
< return convert_to_mode (mode, result, 0);
< convert_move (target, result, 0);
< return target;
< }
---
> if (insn)
> {
> emit_insn (insn);
3396,3403c3791,3804
< /* Expand the library call ourselves using a stabilized argument
< list to avoid re-evaluating the function's arguments twice. */
< arglist = build_tree_list (NULL_TREE, arg2);
< arglist = tree_cons (NULL_TREE, arg1, arglist);
< fndecl = get_callee_fndecl (exp);
< exp = build_function_call_expr (fndecl, arglist);
< return expand_call (exp, target, target == const0_rtx);
< }
---
> /* Return the value in the proper mode for this function. */
> mode = TYPE_MODE (TREE_TYPE (exp));
> if (GET_MODE (result) == mode)
> return result;
> if (target == 0)
> return convert_to_mode (mode, result, 0);
> convert_move (target, result, 0);
> return target;
> }
>
> /* Expand the library call ourselves using a stabilized argument
> list to avoid re-evaluating the function's arguments twice. */
> #ifdef HAVE_cmpstrnsi
> do_libcall:
3404a3806,3814
> arglist = build_tree_list (NULL_TREE, arg2);
> arglist = tree_cons (NULL_TREE, arg1, arglist);
> fndecl = get_callee_fndecl (exp);
> fn = build_function_call_expr (fndecl, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_call (fn, target, target == const0_rtx);
> }
> #endif
3416,3417d3825
< tree arg1, arg2, arg3;
< const char *p1, *p2;
3422,3428c3830
<
< arg1 = TREE_VALUE (arglist);
< arg2 = TREE_VALUE (TREE_CHAIN (arglist));
< arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
<
< /* If the len parameter is zero, return zero. */
< if (integer_zerop (arg3))
---
> else
3430,3434c3832,3834
< /* Evaluate and ignore arg1 and arg2 in case they have
< side-effects. */
< expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
< expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
---
> tree result = fold_builtin_strncmp (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
3437,3475d3836
< /* If arg1 and arg2 are equal (and not volatile), return zero. */
< if (operand_equal_p (arg1, arg2, 0))
< {
< /* Evaluate and ignore arg3 in case it has side-effects. */
< expand_expr (arg3, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
<
< p1 = c_getstr (arg1);
< p2 = c_getstr (arg2);
<
< /* If all arguments are constant, evaluate at compile-time. */
< if (host_integerp (arg3, 1) && p1 && p2)
< {
< const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
< return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
< }
<
< /* If len == 1 or (either string parameter is "" and (len >= 1)),
< return (*(const u_char*)arg1 - *(const u_char*)arg2). */
< if (host_integerp (arg3, 1)
< && (tree_low_cst (arg3, 1) == 1
< || (tree_low_cst (arg3, 1) > 1
< && ((p1 && *p1 == '\0') || (p2 && *p2 == '\0')))))
< {
< tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
< tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
< tree ind1 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
< tree ind2 =
< fold (build1 (CONVERT_EXPR, integer_type_node,
< build1 (INDIRECT_REF, cst_uchar_node,
< build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
< tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
< return expand_expr (result, target, mode, EXPAND_NORMAL);
< }
<
3477c3838
< lengths, and it doesn't have side effects, then emit cmpstrsi
---
> lengths, and it doesn't have side effects, then emit cmpstrnsi
3479,3480c3840,3841
< #ifdef HAVE_cmpstrsi
< if (HAVE_cmpstrsi)
---
> #ifdef HAVE_cmpstrnsi
> if (HAVE_cmpstrnsi)
3481a3843,3845
> tree arg1 = TREE_VALUE (arglist);
> tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
> tree arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3485c3849
< tree fndecl;
---
> tree fndecl, fn;
3492c3856
< = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
---
> = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3531c3895,3896
< len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
---
> len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
> fold_convert (TREE_TYPE (len), arg3));
3540c3905
< && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
---
> && REG_P (result) && GET_MODE (result) == insn_mode
3544,3547c3909,3912
< /* Stabilize the arguments in case gen_cmpstrsi fails. */
< arg1 = save_expr (arg1);
< arg2 = save_expr (arg2);
< len = save_expr (len);
---
> /* Stabilize the arguments in case gen_cmpstrnsi fails. */
> arg1 = builtin_save_expr (arg1);
> arg2 = builtin_save_expr (arg2);
> len = builtin_save_expr (len);
3549,3553c3914,3918
< arg1_rtx = get_memory_rtx (arg1);
< arg2_rtx = get_memory_rtx (arg2);
< arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
< insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
< GEN_INT (MIN (arg1_align, arg2_align)));
---
> arg1_rtx = get_memory_rtx (arg1, len);
> arg2_rtx = get_memory_rtx (arg2, len);
> arg3_rtx = expand_normal (len);
> insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
> GEN_INT (MIN (arg1_align, arg2_align)));
3574,3575c3939,3942
< exp = build_function_call_expr (fndecl, arglist);
< return expand_call (exp, target, target == const0_rtx);
---
> fn = build_function_call_expr (fndecl, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_call (fn, target, target == const0_rtx);
3586c3953
< expand_builtin_strcat (tree arglist, rtx target, enum machine_mode mode)
---
> expand_builtin_strcat (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3593c3960
< src = TREE_VALUE (TREE_CHAIN (arglist));
---
> src = TREE_VALUE (TREE_CHAIN (arglist));
3596c3963,3967
< if (p)
---
> /* If the string length is zero, return the dst parameter. */
> if (p && *p == '\0')
> return expand_expr (dst, target, mode, EXPAND_NORMAL);
>
> if (!optimize_size)
3598,3617c3969,3972
< /* If the string length is zero, return the dst parameter. */
< if (*p == '\0')
< return expand_expr (dst, target, mode, EXPAND_NORMAL);
< else if (!optimize_size)
< {
< /* Otherwise if !optimize_size, see if we can store by
< pieces into (dst + strlen(dst)). */
< tree newdst, arglist,
< strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
<
< /* This is the length argument. */
< arglist = build_tree_list (NULL_TREE,
< fold (size_binop (PLUS_EXPR,
< c_strlen (src, 0),
< ssize_int (1))));
< /* Prepend src argument. */
< arglist = tree_cons (NULL_TREE, src, arglist);
<
< /* We're going to use dst more than once. */
< dst = save_expr (dst);
---
> /* See if we can store by pieces into (dst + strlen(dst)). */
> tree newsrc, newdst,
> strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
> rtx insns;
3619,3625c3974,3979
< /* Create strlen (dst). */
< newdst =
< fold (build_function_call_expr (strlen_fn,
< build_tree_list (NULL_TREE,
< dst)));
< /* Create (dst + strlen (dst)). */
< newdst = fold (build (PLUS_EXPR, TREE_TYPE (dst), dst, newdst));
---
> /* Stabilize the argument list. */
> newsrc = builtin_save_expr (src);
> if (newsrc != src)
> arglist = build_tree_list (NULL_TREE, newsrc);
> else
> arglist = TREE_CHAIN (arglist); /* Reusing arglist if safe. */
3627,3639c3981,3999
< /* Prepend the new dst argument. */
< arglist = tree_cons (NULL_TREE, newdst, arglist);
<
< /* We don't want to get turned into a memcpy if the
< target is const0_rtx, i.e. when the return value
< isn't used. That would produce pessimized code so
< pass in a target of zero, it should never actually be
< used. If this was successful return the original
< dst, not the result of mempcpy. */
< if (expand_builtin_mempcpy (arglist, /*target=*/0, mode, /*endp=*/0))
< return expand_expr (dst, target, mode, EXPAND_NORMAL);
< else
< return 0;
---
> dst = builtin_save_expr (dst);
>
> start_sequence ();
>
> /* Create strlen (dst). */
> newdst =
> build_function_call_expr (strlen_fn,
> build_tree_list (NULL_TREE, dst));
> /* Create (dst + (cast) strlen (dst)). */
> newdst = fold_convert (TREE_TYPE (dst), newdst);
> newdst = fold_build2 (PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
>
> newdst = builtin_save_expr (newdst);
> arglist = tree_cons (NULL_TREE, newdst, arglist);
>
> if (!expand_builtin_strcpy (fndecl, arglist, target, mode))
> {
> end_sequence (); /* Stop sequence. */
> return 0;
3640a4001,4007
>
> /* Output the entire sequence. */
> insns = get_insns ();
> end_sequence ();
> emit_insn (insns);
>
> return expand_expr (dst, target, mode, EXPAND_NORMAL);
3654,3657c4021,4022
< if (!validate_arglist (arglist,
< POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist,
> POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3659,3692c4024,4026
< tree dst = TREE_VALUE (arglist),
< src = TREE_VALUE (TREE_CHAIN (arglist)),
< len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
< const char *p = c_getstr (src);
<
< /* If the requested length is zero, or the src parameter string
< length is zero, return the dst parameter. */
< if (integer_zerop (len) || (p && *p == '\0'))
< {
< /* Evaluate and ignore the src and len parameters in case
< they have side-effects. */
< expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
< expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return expand_expr (dst, target, mode, EXPAND_NORMAL);
< }
<
< /* If the requested len is greater than or equal to the string
< length, call strcat. */
< if (TREE_CODE (len) == INTEGER_CST && p
< && compare_tree_int (len, strlen (p)) >= 0)
< {
< tree newarglist
< = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
< tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
<
< /* If the replacement _DECL isn't initialized, don't do the
< transformation. */
< if (!fn)
< return 0;
<
< return expand_expr (build_function_call_expr (fn, newarglist),
< target, mode, EXPAND_NORMAL);
< }
< return 0;
---
> tree result = fold_builtin_strncat (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
3693a4028
> return 0;
3703,3705c4038
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3707,3726c4040,4042
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
<
< /* If both arguments are constants, evaluate at compile-time. */
< if (p1 && p2)
< {
< const size_t r = strspn (p1, p2);
< return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
< }
<
< /* If either argument is "", return 0. */
< if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
< {
< /* Evaluate and ignore both arguments in case either one has
< side-effects. */
< expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
< expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
< return 0;
---
> tree result = fold_builtin_strspn (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
3727a4044
> return 0;
3737,3739c4054
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
< return 0;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3741,3774c4056,4058
< tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
< const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
<
< /* If both arguments are constants, evaluate at compile-time. */
< if (p1 && p2)
< {
< const size_t r = strcspn (p1, p2);
< return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
< }
<
< /* If the first argument is "", return 0. */
< if (p1 && *p1 == '\0')
< {
< /* Evaluate and ignore argument s2 in case it has
< side-effects. */
< expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
<
< /* If the second argument is "", return __builtin_strlen(s1). */
< if (p2 && *p2 == '\0')
< {
< tree newarglist = build_tree_list (NULL_TREE, s1),
< fn = implicit_built_in_decls[BUILT_IN_STRLEN];
<
< /* If the replacement _DECL isn't initialized, don't do the
< transformation. */
< if (!fn)
< return 0;
<
< return expand_expr (build_function_call_expr (fn, newarglist),
< target, mode, EXPAND_NORMAL);
< }
< return 0;
---
> tree result = fold_builtin_strcspn (arglist);
> if (result)
> return expand_expr (result, target, mode, EXPAND_NORMAL);
3775a4060
> return 0;
3809c4094
< emit_insn_after (seq, get_insns ());
---
> emit_insn_after (seq, entry_of_function ());
3825,3826c4110
< if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
< abort ();
---
> gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
3831c4115
< error ("argument of `__builtin_args_info' must be constant");
---
> error ("argument of %<__builtin_args_info%> must be constant");
3837c4121
< error ("argument of `__builtin_args_info' out of range");
---
> error ("argument of %<__builtin_args_info%> out of range");
3843c4127
< error ("missing argument in `__builtin_args_info'");
---
> error ("missing argument in %<__builtin_args_info%>");
3848c4132
< /* Expand ARGLIST, from a call to __builtin_next_arg. */
---
> /* Expand a call to __builtin_next_arg. */
3851c4135
< expand_builtin_next_arg (tree arglist)
---
> expand_builtin_next_arg (void)
3853,3884c4137,4138
< tree fntype = TREE_TYPE (current_function_decl);
<
< if (TYPE_ARG_TYPES (fntype) == 0
< || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
< == void_type_node))
< {
< error ("`va_start' used in function with fixed args");
< return const0_rtx;
< }
<
< if (arglist)
< {
< tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
< tree arg = TREE_VALUE (arglist);
<
< /* Strip off all nops for the sake of the comparison. This
< is not quite the same as STRIP_NOPS. It does more.
< We must also strip off INDIRECT_EXPR for C++ reference
< parameters. */
< while (TREE_CODE (arg) == NOP_EXPR
< || TREE_CODE (arg) == CONVERT_EXPR
< || TREE_CODE (arg) == NON_LVALUE_EXPR
< || TREE_CODE (arg) == INDIRECT_REF)
< arg = TREE_OPERAND (arg, 0);
< if (arg != last_parm)
< warning ("second parameter of `va_start' not last named argument");
< }
< else
< /* Evidently an out of date version of <stdarg.h>; can't validate
< va_start's second argument, but can still work as intended. */
< warning ("`__builtin_next_arg' called without an argument");
<
---
> /* Checking arguments is already done in fold_builtin_next_arg
> that must be called before this function. */
3909,3912c4163
< tree p2 = build_pointer_type (va_list_type_node);
<
< valist = build1 (ADDR_EXPR, p2, valist);
< valist = fold (build1 (NOP_EXPR, p1, valist));
---
> valist = build_fold_addr_expr_with_type (valist, p1);
3925c4176
< valist = fold (build1 (ADDR_EXPR, pt, valist));
---
> valist = fold_build1 (ADDR_EXPR, pt, valist);
3931,3932c4182
< valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
< valist));
---
> valist = build_fold_indirect_ref (valist);
3954,3955c4204,4205
< t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
< make_tree (ptr_type_node, nextarg));
---
> t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
> make_tree (ptr_type_node, nextarg));
3971,3972c4221,4225
< if (TREE_CHAIN (chain))
< error ("too many arguments to function `va_start'");
---
> if (!chain)
> {
> error ("too few arguments to function %<va_start%>");
> return const0_rtx;
> }
3974c4227,4230
< nextarg = expand_builtin_next_arg (chain);
---
> if (fold_builtin_next_arg (chain))
> return const0_rtx;
>
> nextarg = expand_builtin_next_arg ();
3989,3990c4245,4246
< rtx
< std_expand_builtin_va_arg (tree valist, tree type)
---
> tree
> std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
3992,3996c4248,4250
< tree addr_tree, t, type_size = NULL;
< tree align, alignm1;
< tree rounded_size;
< rtx addr;
< HOST_WIDE_INT boundary;
---
> tree addr, t, type_size, rounded_size, valist_tmp;
> unsigned HOST_WIDE_INT align, boundary;
> bool indirect;
3998,4001c4252,4257
< /* Compute the rounded size of the type. */
< align = size_int (PARM_BOUNDARY / BITS_PER_UNIT);
< alignm1 = size_int (PARM_BOUNDARY / BITS_PER_UNIT - 1);
< boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
---
> #ifdef ARGS_GROW_DOWNWARD
> /* All of the alignment and movement below is for args-grow-up machines.
> As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
> implement their own specialized gimplify_va_arg_expr routines. */
> gcc_unreachable ();
> #endif
4002a4259,4268
> indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
> if (indirect)
> type = build_pointer_type (type);
>
> align = PARM_BOUNDARY / BITS_PER_UNIT;
> boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type) / BITS_PER_UNIT;
>
> /* Hoist the valist value into a temporary for the moment. */
> valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
>
4005,4006c4271,4272
<
< if (boundary > PARM_BOUNDARY)
---
> if (boundary > align
> && !integer_zerop (TYPE_SIZE (type)))
4008,4020c4274,4282
< if (!PAD_VARARGS_DOWN)
< {
< t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
< build (PLUS_EXPR, TREE_TYPE (valist), valist,
< build_int_2 (boundary / BITS_PER_UNIT - 1, 0)));
< TREE_SIDE_EFFECTS (t) = 1;
< expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
< }
< t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
< build (BIT_AND_EXPR, TREE_TYPE (valist), valist,
< build_int_2 (~(boundary / BITS_PER_UNIT - 1), -1)));
< TREE_SIDE_EFFECTS (t) = 1;
< expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
---
> t = fold_convert (TREE_TYPE (valist), size_int (boundary - 1));
> t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
> build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t));
> gimplify_and_add (t, pre_p);
>
> t = fold_convert (TREE_TYPE (valist), size_int (-boundary));
> t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
> build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist_tmp, t));
> gimplify_and_add (t, pre_p);
4022,4025d4283
< if (type == error_mark_node
< || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
< || TREE_OVERFLOW (type_size))
< rounded_size = size_zero_node;
4027,4032c4285
< rounded_size = fold (build (MULT_EXPR, sizetype,
< fold (build (TRUNC_DIV_EXPR, sizetype,
< fold (build (PLUS_EXPR, sizetype,
< type_size, alignm1)),
< align)),
< align));
---
> boundary = align;
4034,4036c4287,4291
< /* Get AP. */
< addr_tree = valist;
< if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
---
> /* If the actual alignment is less than the alignment of the type,
> adjust the type accordingly so that we don't assume strict alignment
> when deferencing the pointer. */
> boundary *= BITS_PER_UNIT;
> if (boundary < TYPE_ALIGN (type))
4038,4047c4293,4294
< /* Small args are padded downward. */
< addr_tree = fold (build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
< fold (build (COND_EXPR, sizetype,
< fold (build (GT_EXPR, sizetype,
< rounded_size,
< align)),
< size_zero_node,
< fold (build (MINUS_EXPR, sizetype,
< rounded_size,
< type_size))))));
---
> type = build_variant_type_copy (type);
> TYPE_ALIGN (type) = boundary;
4050,4051c4297,4299
< addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
< addr = copy_to_reg (addr);
---
> /* Compute the rounded size of the type. */
> type_size = size_in_bytes (type);
> rounded_size = round_up (type_size, align);
4053,4054c4301,4306
< /* Compute new value for AP. */
< if (! integer_zerop (rounded_size))
---
> /* Reduce rounded_size so it's sharable with the postqueue. */
> gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
>
> /* Get AP. */
> addr = valist_tmp;
> if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4056,4060c4308,4313
< t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
< build (PLUS_EXPR, TREE_TYPE (valist), valist,
< rounded_size));
< TREE_SIDE_EFFECTS (t) = 1;
< expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
---
> /* Small args are padded downward. */
> t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
> t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
> size_binop (MINUS_EXPR, rounded_size, type_size));
> t = fold_convert (TREE_TYPE (addr), t);
> addr = fold_build2 (PLUS_EXPR, TREE_TYPE (addr), addr, t);
4062a4316,4339
> /* Compute new value for AP. */
> t = fold_convert (TREE_TYPE (valist), rounded_size);
> t = build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t);
> t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
> gimplify_and_add (t, pre_p);
>
> addr = fold_convert (build_pointer_type (type), addr);
>
> if (indirect)
> addr = build_va_arg_indirect_ref (addr);
>
> return build_va_arg_indirect_ref (addr);
> }
>
> /* Build an indirect-ref expression over the given TREE, which represents a
> piece of a va_arg() expansion. */
> tree
> build_va_arg_indirect_ref (tree addr)
> {
> addr = build_fold_indirect_ref (addr);
>
> if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
> mf_mark (addr);
>
4066,4067c4343,4344
< /* Expand __builtin_va_arg, which is not really a builtin function, but
< a very special sort of operator. */
---
> /* Return a dummy expression of type TYPE in order to keep going after an
> error. */
4069,4070c4346,4347
< rtx
< expand_builtin_va_arg (tree valist, tree type)
---
> static tree
> dummy_object (tree type)
4072c4349,4358
< rtx addr, result;
---
> tree t = build_int_cst (build_pointer_type (type), 0);
> return build1 (INDIRECT_REF, type, t);
> }
>
> /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
> builtin function, but a very special sort of operator. */
>
> enum gimplify_status
> gimplify_va_arg_expr (tree *expr_p, tree *pre_p, tree *post_p)
> {
4073a4360,4362
> tree valist = TREE_OPERAND (*expr_p, 0);
> tree type = TREE_TYPE (*expr_p);
> tree t;
4076d4364
<
4078a4367,4370
>
> if (have_va_type == error_mark_node)
> return GS_ERROR;
>
4083c4375
< In that case, unwrap both types so that we can compare the
---
> In that case, unwrap both types so that we can compare the
4086c4378
< || TREE_CODE (have_va_type) == POINTER_TYPE)
---
> || POINTER_TYPE_P (have_va_type))
4091a4384
>
4094,4095c4387,4388
< error ("first argument to `va_arg' not of type `va_list'");
< addr = const0_rtx;
---
> error ("first argument to %<va_arg%> not of type %<va_list%>");
> return GS_ERROR;
4100c4393
< else if ((promoted_type = (*lang_hooks.types.type_promotes_to) (type))
---
> else if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4103d4395
< const char *name = "<anonymous type>", *pname = 0;
4106,4122d4397
< if (TYPE_NAME (type))
< {
< if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
< name = IDENTIFIER_POINTER (TYPE_NAME (type));
< else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
< && DECL_NAME (TYPE_NAME (type)))
< name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
< }
< if (TYPE_NAME (promoted_type))
< {
< if (TREE_CODE (TYPE_NAME (promoted_type)) == IDENTIFIER_NODE)
< pname = IDENTIFIER_POINTER (TYPE_NAME (promoted_type));
< else if (TREE_CODE (TYPE_NAME (promoted_type)) == TYPE_DECL
< && DECL_NAME (TYPE_NAME (promoted_type)))
< pname = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type)));
< }
<
4126,4127c4401,4402
< warning ("`%s' is promoted to `%s' when passed through `...'",
< name, pname);
---
> warning (0, "%qT is promoted to %qT when passed through %<...%>",
> type, promoted_type);
4131,4132c4406,4407
< warning ("(so you should pass `%s' not `%s' to `va_arg')",
< pname, name);
---
> warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
> promoted_type, type);
4138c4413,4415
< expand_builtin_trap ();
---
> t = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
> NULL);
> append_to_statement_list (t, pre_p);
4142c4419,4420
< addr = const0_rtx;
---
> *expr_p = dummy_object (type);
> return GS_ALL_DONE;
4147,4148c4425,4440
< from multiple evaluations. */
< valist = stabilize_va_list (valist, 0);
---
> from multiple evaluations. */
> if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
> {
> /* For this case, the backends will be expecting a pointer to
> TREE_TYPE (va_list_type_node), but it's possible we've
> actually been given an array (an actual va_list_type_node).
> So fix it. */
> if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
> {
> tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
> valist = build_fold_addr_expr_with_type (valist, p1);
> }
> gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
> }
> else
> gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4150,4155c4442,4445
< #ifdef EXPAND_BUILTIN_VA_ARG
< addr = EXPAND_BUILTIN_VA_ARG (valist, type);
< #else
< addr = std_expand_builtin_va_arg (valist, type);
< #endif
< }
---
> if (!targetm.gimplify_va_arg_expr)
> /* FIXME:Once most targets are converted we should merely
> assert this is non-null. */
> return GS_ALL_DONE;
4157,4162c4447,4449
< addr = convert_memory_address (Pmode, addr);
<
< result = gen_rtx_MEM (TYPE_MODE (type), addr);
< set_mem_alias_set (result, get_varargs_alias_set ());
<
< return result;
---
> *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
> return GS_OK;
> }
4197c4484
< t = build (MODIFY_EXPR, va_list_type_node, dst, src);
---
> t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
4244c4531
< error ("invalid arg to `__builtin_frame_address'");
---
> error ("invalid argument to %<__builtin_frame_address%>");
4246c4533
< error ("invalid arg to `__builtin_return_address'");
---
> error ("invalid argument to %<__builtin_return_address%>");
4253,4254c4540
< tree_low_cst (TREE_VALUE (arglist), 1),
< hard_frame_pointer_rtx);
---
> tree_low_cst (TREE_VALUE (arglist), 1));
4260c4546
< warning ("unsupported arg to `__builtin_frame_address'");
---
> warning (0, "unsupported argument to %<__builtin_frame_address%>");
4262c4548
< warning ("unsupported arg to `__builtin_return_address'");
---
> warning (0, "unsupported argument to %<__builtin_return_address%>");
4270c4556
< if (GET_CODE (tem) != REG
---
> if (!REG_P (tem)
4286a4573,4578
> /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
> should always expand to function calls. These can be intercepted
> in libmudflap. */
> if (flag_mudflap)
> return 0;
>
4291c4583
< op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
---
> op0 = expand_normal (TREE_VALUE (arglist));
4319,4320c4611
< if (target == 0)
< abort ();
---
> gcc_assert (target);
4331,4342d4621
< tree len, fn;
< /* If we're using an unlocked function, assume the other unlocked
< functions exist explicitly. */
< tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
< : implicit_built_in_decls[BUILT_IN_FPUTC];
< tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
< : implicit_built_in_decls[BUILT_IN_FWRITE];
<
< /* If the return value is used, don't do the transformation. */
< if (target != const0_rtx)
< return 0;
<
4344,4353c4623
< if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
< return 0;
<
< /* Get the length of the string passed to fputs. If the length
< can't be determined, punt. */
< if (!(len = c_strlen (TREE_VALUE (arglist), 1))
< || TREE_CODE (len) != INTEGER_CST)
< return 0;
<
< switch (compare_tree_int (len, 1))
---
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4355,4398c4625,4628
< case -1: /* length is 0, delete the call entirely . */
< {
< /* Evaluate and ignore the argument in case it has
< side-effects. */
< expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
< VOIDmode, EXPAND_NORMAL);
< return const0_rtx;
< }
< case 0: /* length is 1, call fputc. */
< {
< const char *p = c_getstr (TREE_VALUE (arglist));
<
< if (p != NULL)
< {
< /* New argument list transforming fputs(string, stream) to
< fputc(string[0], stream). */
< arglist =
< build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
< arglist =
< tree_cons (NULL_TREE, build_int_2 (p[0], 0), arglist);
< fn = fn_fputc;
< break;
< }
< }
< /* Fall through. */
< case 1: /* length is greater than 1, call fwrite. */
< {
< tree string_arg;
<
< /* If optimizing for size keep fputs. */
< if (optimize_size)
< return 0;
< string_arg = TREE_VALUE (arglist);
< /* New argument list transforming fputs(string, stream) to
< fwrite(string, 1, len, stream). */
< arglist = build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
< arglist = tree_cons (NULL_TREE, len, arglist);
< arglist = tree_cons (NULL_TREE, size_one_node, arglist);
< arglist = tree_cons (NULL_TREE, string_arg, arglist);
< fn = fn_fwrite;
< break;
< }
< default:
< abort ();
---
> tree result = fold_builtin_fputs (arglist, (target == const0_rtx),
> unlocked, NULL_TREE);
> if (result)
> return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
4400,4407c4630
<
< /* If the replacement _DECL isn't initialized, don't do the
< transformation. */
< if (!fn)
< return 0;
<
< return expand_expr (build_function_call_expr (fn, arglist),
< const0_rtx, VOIDmode, EXPAND_NORMAL);
---
> return 0;
4428c4651
< error ("second arg to `__builtin_expect' must be a constant");
---
> error ("second argument to %<__builtin_expect%> must be a constant");
4479c4702
< if (drop_through_label && GET_CODE (drop_through_label) == NOTE)
---
> if (drop_through_label && NOTE_P (drop_through_label))
4481c4704
< if (drop_through_label && GET_CODE (drop_through_label) != CODE_LABEL)
---
> if (drop_through_label && !LABEL_P (drop_through_label))
4496c4719
< if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn))
---
> if (JUMP_P (insn) && any_condjump_p (insn))
4519c4742
< if (next && GET_CODE (next) == NOTE)
---
> if (next && NOTE_P (next))
4522c4745
< if (next && GET_CODE (next) == JUMP_INSN
---
> if (next && JUMP_P (next)
4537c4760
< if (next && GET_CODE (next) == NOTE)
---
> if (next && NOTE_P (next))
4540c4763
< if (next && GET_CODE (next) == JUMP_INSN
---
> if (next && JUMP_P (next)
4558c4781
< predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
---
> predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
4603,4606c4826,4829
< /* Expand a call to cabs, cabsf or cabsl with arguments ARGLIST.
< Return 0 if a normal call should be emitted rather than expanding
< the function inline. If convenient, the result should be placed
< in target. */
---
> /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
> Return NULL is a normal call should be emitted rather than expanding the
> function inline. If convenient, the result should be placed in TARGET.
> SUBTARGET may be used as the target for computing the operand. */
4609c4832
< expand_builtin_cabs (tree arglist, rtx target)
---
> expand_builtin_copysign (tree arglist, rtx target, rtx subtarget)
4611c4834
< enum machine_mode mode;
---
> rtx op0, op1;
4613d4835
< rtx op0;
4615c4837
< if (arglist == 0 || TREE_CHAIN (arglist))
---
> if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4616a4839
>
4618,4620c4841
< if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
< || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
< return 0;
---
> op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4622,4624c4843,4846
< mode = TYPE_MODE (TREE_TYPE (arg));
< op0 = expand_expr (arg, NULL_RTX, VOIDmode, 0);
< return expand_complex_abs (mode, op0, target, 0);
---
> arg = TREE_VALUE (TREE_CHAIN (arglist));
> op1 = expand_normal (arg);
>
> return expand_copysign (op0, op1, target);
4629c4851
< static tree
---
> tree
4636c4858
< index = build_index_type (build_int_2 (len - 1, 0));
---
> index = build_index_type (build_int_cst (NULL_TREE, len - 1));
4639a4862
> TREE_INVARIANT (t) = 1;
4651c4874
< /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
---
> /* Expand EXP, a call to printf or printf_unlocked.
4654c4877
< TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
---
> TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4657c4880
< expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode,
---
> expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
4659a4883
> tree arglist = TREE_OPERAND (exp, 1);
4677c4901
< if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4685a4910,4912
> if (!init_target_chars())
> return 0;
>
4687c4914
< if (strcmp (fmt_str, "%s\n") == 0)
---
> if (strcmp (fmt_str, target_percent_s_newline) == 0)
4690c4917
< || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
---
> || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
4696c4923
< else if (strcmp (fmt_str, "%c") == 0)
---
> else if (strcmp (fmt_str, target_percent_c) == 0)
4707,4708c4934,4935
< if (strchr (fmt_str, '%'))
< return 0;
---
> if (strchr (fmt_str, target_percent))
> return 0;
4722c4949
< arg = build_int_2 (fmt_str[0], 0);
---
> arg = build_int_cst (NULL_TREE, fmt_str[0]);
4730c4957
< if (fmt_str[len - 1] == '\n')
---
> if ((unsigned char)fmt_str[len - 1] == target_newline)
4734c4961
< char *newstr = (char *) alloca (len);
---
> char *newstr = alloca (len);
4751,4752c4978,4981
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> fn = build_function_call_expr (fn, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_expr (fn, target, mode, EXPAND_NORMAL);
4755c4984
< /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
---
> /* Expand EXP, a call to fprintf or fprintf_unlocked.
4758c4987
< TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
---
> TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4761,4762c4990,4991
< expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode,
< bool unlocked)
---
> expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
> bool unlocked)
4763a4993
> tree arglist = TREE_OPERAND (exp, 1);
4781c5011
< if (TREE_CODE (TREE_TYPE (fp)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (fp)))
4787c5017
< if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4795a5026,5028
> if (!init_target_chars())
> return 0;
>
4797c5030
< if (strcmp (fmt_str, "%s") == 0)
---
> if (strcmp (fmt_str, target_percent_s) == 0)
4800c5033
< || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
---
> || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
4809c5042
< else if (strcmp (fmt_str, "%c") == 0)
---
> else if (strcmp (fmt_str, target_percent_c) == 0)
4823,4824c5056,5057
< if (strchr (fmt_str, '%'))
< return 0;
---
> if (strchr (fmt_str, target_percent))
> return 0;
4847,4848c5080,5083
< return expand_expr (build_function_call_expr (fn, arglist),
< target, mode, EXPAND_NORMAL);
---
> fn = build_function_call_expr (fn, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_expr (fn, target, mode, EXPAND_NORMAL);
4868c5103
< if (TREE_CODE (TREE_TYPE (dest)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (dest)))
4874c5109
< if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4882a5118,5120
> if (!init_target_chars())
> return 0;
>
4884c5122
< if (strchr (fmt_str, '%') == 0)
---
> if (strchr (fmt_str, target_percent) == 0)
4895,4896c5133
< exp = build_int_2 (strlen (fmt_str), 0);
< exp = fold (build1 (NOP_EXPR, integer_type_node, exp));
---
> exp = build_int_cst (NULL_TREE, strlen (fmt_str));
4900c5137
< else if (strcmp (fmt_str, "%s") == 0)
---
> else if (strcmp (fmt_str, target_percent_s) == 0)
4911c5148
< if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
---
> if (! POINTER_TYPE_P (TREE_TYPE (arg)))
4934a5172,5441
>
> /* Expand a call to either the entry or exit function profiler. */
>
> static rtx
> expand_builtin_profile_func (bool exitp)
> {
> rtx this, which;
>
> this = DECL_RTL (current_function_decl);
> gcc_assert (MEM_P (this));
> this = XEXP (this, 0);
>
> if (exitp)
> which = profile_function_exit_libfunc;
> else
> which = profile_function_entry_libfunc;
>
> emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode,
> expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
> 0),
> Pmode);
>
> return const0_rtx;
> }
>
> /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
>
> static rtx
> round_trampoline_addr (rtx tramp)
> {
> rtx temp, addend, mask;
>
> /* If we don't need too much alignment, we'll have been guaranteed
> proper alignment by get_trampoline_type. */
> if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
> return tramp;
>
> /* Round address up to desired boundary. */
> temp = gen_reg_rtx (Pmode);
> addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
> mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
>
> temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
> temp, 0, OPTAB_LIB_WIDEN);
> tramp = expand_simple_binop (Pmode, AND, temp, mask,
> temp, 0, OPTAB_LIB_WIDEN);
>
> return tramp;
> }
>
> static rtx
> expand_builtin_init_trampoline (tree arglist)
> {
> tree t_tramp, t_func, t_chain;
> rtx r_tramp, r_func, r_chain;
> #ifdef TRAMPOLINE_TEMPLATE
> rtx blktramp;
> #endif
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE,
> POINTER_TYPE, VOID_TYPE))
> return NULL_RTX;
>
> t_tramp = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> t_func = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> t_chain = TREE_VALUE (arglist);
>
> r_tramp = expand_normal (t_tramp);
> r_func = expand_normal (t_func);
> r_chain = expand_normal (t_chain);
>
> /* Generate insns to initialize the trampoline. */
> r_tramp = round_trampoline_addr (r_tramp);
> #ifdef TRAMPOLINE_TEMPLATE
> blktramp = gen_rtx_MEM (BLKmode, r_tramp);
> set_mem_align (blktramp, TRAMPOLINE_ALIGNMENT);
> emit_block_move (blktramp, assemble_trampoline_template (),
> GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
> #endif
> trampolines_created = 1;
> INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
>
> return const0_rtx;
> }
>
> static rtx
> expand_builtin_adjust_trampoline (tree arglist)
> {
> rtx tramp;
>
> if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
> return NULL_RTX;
>
> tramp = expand_normal (TREE_VALUE (arglist));
> tramp = round_trampoline_addr (tramp);
> #ifdef TRAMPOLINE_ADJUST_ADDRESS
> TRAMPOLINE_ADJUST_ADDRESS (tramp);
> #endif
>
> return tramp;
> }
>
> /* Expand a call to the built-in signbit, signbitf or signbitl function.
> Return NULL_RTX if a normal call should be emitted rather than expanding
> the function in-line. EXP is the expression that is a call to the builtin
> function; if convenient, the result should be placed in TARGET. */
>
> static rtx
> expand_builtin_signbit (tree exp, rtx target)
> {
> const struct real_format *fmt;
> enum machine_mode fmode, imode, rmode;
> HOST_WIDE_INT hi, lo;
> tree arg, arglist;
> int word, bitpos;
> rtx temp;
>
> arglist = TREE_OPERAND (exp, 1);
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
>
> arg = TREE_VALUE (arglist);
> fmode = TYPE_MODE (TREE_TYPE (arg));
> rmode = TYPE_MODE (TREE_TYPE (exp));
> fmt = REAL_MODE_FORMAT (fmode);
>
> /* For floating point formats without a sign bit, implement signbit
> as "ARG < 0.0". */
> bitpos = fmt->signbit_ro;
> if (bitpos < 0)
> {
> /* But we can't do this if the format supports signed zero. */
> if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
> return 0;
>
> arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
> build_real (TREE_TYPE (arg), dconst0));
> return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
> }
>
> temp = expand_normal (arg);
> if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
> {
> imode = int_mode_for_mode (fmode);
> if (imode == BLKmode)
> return 0;
> temp = gen_lowpart (imode, temp);
> }
> else
> {
> imode = word_mode;
> /* Handle targets with different FP word orders. */
> if (FLOAT_WORDS_BIG_ENDIAN)
> word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
> else
> word = bitpos / BITS_PER_WORD;
> temp = operand_subword_force (temp, word, fmode);
> bitpos = bitpos % BITS_PER_WORD;
> }
>
> /* Force the intermediate word_mode (or narrower) result into a
> register. This avoids attempting to create paradoxical SUBREGs
> of floating point modes below. */
> temp = force_reg (imode, temp);
>
> /* If the bitpos is within the "result mode" lowpart, the operation
> can be implement with a single bitwise AND. Otherwise, we need
> a right shift and an AND. */
>
> if (bitpos < GET_MODE_BITSIZE (rmode))
> {
> if (bitpos < HOST_BITS_PER_WIDE_INT)
> {
> hi = 0;
> lo = (HOST_WIDE_INT) 1 << bitpos;
> }
> else
> {
> hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
> lo = 0;
> }
>
> if (imode != rmode)
> temp = gen_lowpart (rmode, temp);
> temp = expand_binop (rmode, and_optab, temp,
> immed_double_const (lo, hi, rmode),
> NULL_RTX, 1, OPTAB_LIB_WIDEN);
> }
> else
> {
> /* Perform a logical right shift to place the signbit in the least
> significant bit, then truncate the result to the desired mode
> and mask just this bit. */
> temp = expand_shift (RSHIFT_EXPR, imode, temp,
> build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
> temp = gen_lowpart (rmode, temp);
> temp = expand_binop (rmode, and_optab, temp, const1_rtx,
> NULL_RTX, 1, OPTAB_LIB_WIDEN);
> }
>
> return temp;
> }
>
> /* Expand fork or exec calls. TARGET is the desired target of the
> call. ARGLIST is the list of arguments of the call. FN is the
> identificator of the actual function. IGNORE is nonzero if the
> value is to be ignored. */
>
> static rtx
> expand_builtin_fork_or_exec (tree fn, tree arglist, rtx target, int ignore)
> {
> tree id, decl;
> tree call;
>
> /* If we are not profiling, just call the function. */
> if (!profile_arc_flag)
> return NULL_RTX;
>
> /* Otherwise call the wrapper. This should be equivalent for the rest of
> compiler, so the code does not diverge, and the wrapper may run the
> code necessary for keeping the profiling sane. */
>
> switch (DECL_FUNCTION_CODE (fn))
> {
> case BUILT_IN_FORK:
> id = get_identifier ("__gcov_fork");
> break;
>
> case BUILT_IN_EXECL:
> id = get_identifier ("__gcov_execl");
> break;
>
> case BUILT_IN_EXECV:
> id = get_identifier ("__gcov_execv");
> break;
>
> case BUILT_IN_EXECLP:
> id = get_identifier ("__gcov_execlp");
> break;
>
> case BUILT_IN_EXECLE:
> id = get_identifier ("__gcov_execle");
> break;
>
> case BUILT_IN_EXECVP:
> id = get_identifier ("__gcov_execvp");
> break;
>
> case BUILT_IN_EXECVE:
> id = get_identifier ("__gcov_execve");
> break;
>
> default:
> gcc_unreachable ();
> }
>
> decl = build_decl (FUNCTION_DECL, id, TREE_TYPE (fn));
> DECL_EXTERNAL (decl) = 1;
> TREE_PUBLIC (decl) = 1;
> DECL_ARTIFICIAL (decl) = 1;
> TREE_NOTHROW (decl) = 1;
> DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
> DECL_VISIBILITY_SPECIFIED (decl) = 1;
> call = build_function_call_expr (decl, arglist);
>
> return expand_call (call, target, ignore);
> }
>
4935a5443,5638
> /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
> the pointer in these functions is void*, the tree optimizers may remove
> casts. The mode computed in expand_builtin isn't reliable either, due
> to __sync_bool_compare_and_swap.
>
> FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
> group of builtins. This gives us log2 of the mode size. */
>
> static inline enum machine_mode
> get_builtin_sync_mode (int fcode_diff)
> {
> /* The size is not negotiable, so ask not to get BLKmode in return
> if the target indicates that a smaller size would be better. */
> return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
> }
>
> /* Expand the memory expression LOC and return the appropriate memory operand
> for the builtin_sync operations. */
>
> static rtx
> get_builtin_sync_mem (tree loc, enum machine_mode mode)
> {
> rtx addr, mem;
>
> addr = expand_expr (loc, NULL, Pmode, EXPAND_SUM);
>
> /* Note that we explicitly do not want any alias information for this
> memory, so that we kill all other live memories. Otherwise we don't
> satisfy the full barrier semantics of the intrinsic. */
> mem = validize_mem (gen_rtx_MEM (mode, addr));
>
> set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
> set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
> MEM_VOLATILE_P (mem) = 1;
>
> return mem;
> }
>
> /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
> ARGLIST is the operands list to the function. CODE is the rtx code
> that corresponds to the arithmetic or logical operation from the name;
> an exception here is that NOT actually means NAND. TARGET is an optional
> place for us to store the results; AFTER is true if this is the
> fetch_and_xxx form. IGNORE is true if we don't actually care about
> the result of the operation at all. */
>
> static rtx
> expand_builtin_sync_operation (enum machine_mode mode, tree arglist,
> enum rtx_code code, bool after,
> rtx target, bool ignore)
> {
> rtx val, mem;
> enum machine_mode old_mode;
>
> /* Expand the operands. */
> mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
>
> arglist = TREE_CHAIN (arglist);
> val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
> /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
> of CONST_INTs, where we know the old_mode only from the call argument. */
> old_mode = GET_MODE (val);
> if (old_mode == VOIDmode)
> old_mode = TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist)));
> val = convert_modes (mode, old_mode, val, 1);
>
> if (ignore)
> return expand_sync_operation (mem, val, code);
> else
> return expand_sync_fetch_operation (mem, val, code, after, target);
> }
>
> /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
> intrinsics. ARGLIST is the operands list to the function. IS_BOOL is
> true if this is the boolean form. TARGET is a place for us to store the
> results; this is NOT optional if IS_BOOL is true. */
>
> static rtx
> expand_builtin_compare_and_swap (enum machine_mode mode, tree arglist,
> bool is_bool, rtx target)
> {
> rtx old_val, new_val, mem;
> enum machine_mode old_mode;
>
> /* Expand the operands. */
> mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
>
> arglist = TREE_CHAIN (arglist);
> old_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
> /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
> of CONST_INTs, where we know the old_mode only from the call argument. */
> old_mode = GET_MODE (old_val);
> if (old_mode == VOIDmode)
> old_mode = TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist)));
> old_val = convert_modes (mode, old_mode, old_val, 1);
>
> arglist = TREE_CHAIN (arglist);
> new_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
> /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
> of CONST_INTs, where we know the old_mode only from the call argument. */
> old_mode = GET_MODE (new_val);
> if (old_mode == VOIDmode)
> old_mode = TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist)));
> new_val = convert_modes (mode, old_mode, new_val, 1);
>
> if (is_bool)
> return expand_bool_compare_and_swap (mem, old_val, new_val, target);
> else
> return expand_val_compare_and_swap (mem, old_val, new_val, target);
> }
>
> /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
> general form is actually an atomic exchange, and some targets only
> support a reduced form with the second argument being a constant 1.
> ARGLIST is the operands list to the function; TARGET is an optional
> place for us to store the results. */
>
> static rtx
> expand_builtin_lock_test_and_set (enum machine_mode mode, tree arglist,
> rtx target)
> {
> rtx val, mem;
> enum machine_mode old_mode;
>
> /* Expand the operands. */
> mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
>
> arglist = TREE_CHAIN (arglist);
> val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
> /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
> of CONST_INTs, where we know the old_mode only from the call argument. */
> old_mode = GET_MODE (val);
> if (old_mode == VOIDmode)
> old_mode = TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist)));
> val = convert_modes (mode, old_mode, val, 1);
>
> return expand_sync_lock_test_and_set (mem, val, target);
> }
>
> /* Expand the __sync_synchronize intrinsic. */
>
> static void
> expand_builtin_synchronize (void)
> {
> tree x;
>
> #ifdef HAVE_memory_barrier
> if (HAVE_memory_barrier)
> {
> emit_insn (gen_memory_barrier ());
> return;
> }
> #endif
>
> /* If no explicit memory barrier instruction is available, create an
> empty asm stmt with a memory clobber. */
> x = build4 (ASM_EXPR, void_type_node, build_string (0, ""), NULL, NULL,
> tree_cons (NULL, build_string (6, "memory"), NULL));
> ASM_VOLATILE_P (x) = 1;
> expand_asm_expr (x);
> }
>
> /* Expand the __sync_lock_release intrinsic. ARGLIST is the operands list
> to the function. */
>
> static void
> expand_builtin_lock_release (enum machine_mode mode, tree arglist)
> {
> enum insn_code icode;
> rtx mem, insn;
> rtx val = const0_rtx;
>
> /* Expand the operands. */
> mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
>
> /* If there is an explicit operation in the md file, use it. */
> icode = sync_lock_release[mode];
> if (icode != CODE_FOR_nothing)
> {
> if (!insn_data[icode].operand[1].predicate (val, mode))
> val = force_reg (mode, val);
>
> insn = GEN_FCN (icode) (mem, val);
> if (insn)
> {
> emit_insn (insn);
> return;
> }
> }
>
> /* Otherwise we can implement this operation by emitting a barrier
> followed by a store of zero. */
> expand_builtin_synchronize ();
> emit_move_insn (mem, val);
> }
> 
4951,4953d5653
< /* Perform postincrements before expanding builtin functions. */
< emit_queue ();
<
4955c5655
< return (*targetm.expand_builtin) (exp, target, subtarget, mode, ignore);
---
> return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
4960c5660
< && !CALLED_AS_BUILT_IN (fndecl)
---
> && !called_as_built_in (fndecl)
4997,5006c5697
< case BUILT_IN_ABS:
< case BUILT_IN_LABS:
< case BUILT_IN_LLABS:
< case BUILT_IN_IMAXABS:
< /* build_function_call changes these into ABS_EXPR. */
< abort ();
<
< case BUILT_IN_FABS:
< case BUILT_IN_FABSF:
< case BUILT_IN_FABSL:
---
> CASE_FLT_FN (BUILT_IN_FABS):
5009c5700
< return target;
---
> return target;
5012,5020c5703,5706
< case BUILT_IN_CABS:
< case BUILT_IN_CABSF:
< case BUILT_IN_CABSL:
< if (flag_unsafe_math_optimizations)
< {
< target = expand_builtin_cabs (arglist, target);
< if (target)
< return target;
< }
---
> CASE_FLT_FN (BUILT_IN_COPYSIGN):
> target = expand_builtin_copysign (arglist, target, subtarget);
> if (target)
> return target;
5023,5034c5709,5712
< case BUILT_IN_CONJ:
< case BUILT_IN_CONJF:
< case BUILT_IN_CONJL:
< case BUILT_IN_CREAL:
< case BUILT_IN_CREALF:
< case BUILT_IN_CREALL:
< case BUILT_IN_CIMAG:
< case BUILT_IN_CIMAGF:
< case BUILT_IN_CIMAGL:
< /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
< and IMAGPART_EXPR. */
< abort ();
---
> /* Just do a normal library call if we were unable to fold
> the values. */
> CASE_FLT_FN (BUILT_IN_CABS):
> break;
5036,5053c5714,5728
< case BUILT_IN_SIN:
< case BUILT_IN_SINF:
< case BUILT_IN_SINL:
< case BUILT_IN_COS:
< case BUILT_IN_COSF:
< case BUILT_IN_COSL:
< case BUILT_IN_EXP:
< case BUILT_IN_EXPF:
< case BUILT_IN_EXPL:
< case BUILT_IN_LOG:
< case BUILT_IN_LOGF:
< case BUILT_IN_LOGL:
< case BUILT_IN_TAN:
< case BUILT_IN_TANF:
< case BUILT_IN_TANL:
< case BUILT_IN_ATAN:
< case BUILT_IN_ATANF:
< case BUILT_IN_ATANL:
---
> CASE_FLT_FN (BUILT_IN_EXP):
> CASE_FLT_FN (BUILT_IN_EXP10):
> CASE_FLT_FN (BUILT_IN_POW10):
> CASE_FLT_FN (BUILT_IN_EXP2):
> CASE_FLT_FN (BUILT_IN_EXPM1):
> CASE_FLT_FN (BUILT_IN_LOGB):
> CASE_FLT_FN (BUILT_IN_ILOGB):
> CASE_FLT_FN (BUILT_IN_LOG):
> CASE_FLT_FN (BUILT_IN_LOG10):
> CASE_FLT_FN (BUILT_IN_LOG2):
> CASE_FLT_FN (BUILT_IN_LOG1P):
> CASE_FLT_FN (BUILT_IN_TAN):
> CASE_FLT_FN (BUILT_IN_ASIN):
> CASE_FLT_FN (BUILT_IN_ACOS):
> CASE_FLT_FN (BUILT_IN_ATAN):
5058,5075c5733,5741
< case BUILT_IN_SQRT:
< case BUILT_IN_SQRTF:
< case BUILT_IN_SQRTL:
< case BUILT_IN_FLOOR:
< case BUILT_IN_FLOORF:
< case BUILT_IN_FLOORL:
< case BUILT_IN_CEIL:
< case BUILT_IN_CEILF:
< case BUILT_IN_CEILL:
< case BUILT_IN_TRUNC:
< case BUILT_IN_TRUNCF:
< case BUILT_IN_TRUNCL:
< case BUILT_IN_ROUND:
< case BUILT_IN_ROUNDF:
< case BUILT_IN_ROUNDL:
< case BUILT_IN_NEARBYINT:
< case BUILT_IN_NEARBYINTF:
< case BUILT_IN_NEARBYINTL:
---
> CASE_FLT_FN (BUILT_IN_SQRT):
> CASE_FLT_FN (BUILT_IN_FLOOR):
> CASE_FLT_FN (BUILT_IN_CEIL):
> CASE_FLT_FN (BUILT_IN_TRUNC):
> CASE_FLT_FN (BUILT_IN_ROUND):
> CASE_FLT_FN (BUILT_IN_NEARBYINT):
> CASE_FLT_FN (BUILT_IN_RINT):
> CASE_FLT_FN (BUILT_IN_LRINT):
> CASE_FLT_FN (BUILT_IN_LLRINT):
5081,5085c5747,5756
< case BUILT_IN_POW:
< case BUILT_IN_POWF:
< case BUILT_IN_POWL:
< if (! flag_unsafe_math_optimizations)
< break;
---
> CASE_FLT_FN (BUILT_IN_LCEIL):
> CASE_FLT_FN (BUILT_IN_LLCEIL):
> CASE_FLT_FN (BUILT_IN_LFLOOR):
> CASE_FLT_FN (BUILT_IN_LLFLOOR):
> target = expand_builtin_int_roundingfn (exp, target, subtarget);
> if (target)
> return target;
> break;
>
> CASE_FLT_FN (BUILT_IN_POW):
5091,5093c5762,5771
< case BUILT_IN_ATAN2:
< case BUILT_IN_ATAN2F:
< case BUILT_IN_ATAN2L:
---
> CASE_FLT_FN (BUILT_IN_POWI):
> target = expand_builtin_powi (exp, target, subtarget);
> if (target)
> return target;
> break;
>
> CASE_FLT_FN (BUILT_IN_ATAN2):
> CASE_FLT_FN (BUILT_IN_LDEXP):
> CASE_FLT_FN (BUILT_IN_FMOD):
> CASE_FLT_FN (BUILT_IN_DREM):
5100a5779,5795
> CASE_FLT_FN (BUILT_IN_SIN):
> CASE_FLT_FN (BUILT_IN_COS):
> if (! flag_unsafe_math_optimizations)
> break;
> target = expand_builtin_mathfn_3 (exp, target, subtarget);
> if (target)
> return target;
> break;
>
> CASE_FLT_FN (BUILT_IN_SINCOS):
> if (! flag_unsafe_math_optimizations)
> break;
> target = expand_builtin_sincos (exp);
> if (target)
> return target;
> break;
>
5127c5822
< ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
---
> ops[i] = expand_normal (TREE_VALUE (t));
5137,5138c5832
< expand_builtin_return (expand_expr (TREE_VALUE (arglist),
< NULL_RTX, VOIDmode, 0));
---
> expand_builtin_return (expand_normal (TREE_VALUE (arglist)));
5149c5843,5845
< return expand_builtin_next_arg (arglist);
---
> if (fold_builtin_next_arg (arglist))
> return const0_rtx;
> return expand_builtin_next_arg ();
5155c5851
< return expand_builtin_constant_p (arglist, target_mode);
---
> return const0_rtx;
5166c5862
< || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
---
> || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5177,5179c5873,5881
< case BUILT_IN_FFS:
< case BUILT_IN_FFSL:
< case BUILT_IN_FFSLL:
---
> case BUILT_IN_STACK_SAVE:
> return expand_stack_save ();
>
> case BUILT_IN_STACK_RESTORE:
> expand_stack_restore (TREE_VALUE (arglist));
> return const0_rtx;
>
> CASE_INT_FN (BUILT_IN_FFS):
> case BUILT_IN_FFSIMAX:
5186,5188c5888,5889
< case BUILT_IN_CLZ:
< case BUILT_IN_CLZL:
< case BUILT_IN_CLZLL:
---
> CASE_INT_FN (BUILT_IN_CLZ):
> case BUILT_IN_CLZIMAX:
5195,5197c5896,5897
< case BUILT_IN_CTZ:
< case BUILT_IN_CTZL:
< case BUILT_IN_CTZLL:
---
> CASE_INT_FN (BUILT_IN_CTZ):
> case BUILT_IN_CTZIMAX:
5204,5206c5904,5905
< case BUILT_IN_POPCOUNT:
< case BUILT_IN_POPCOUNTL:
< case BUILT_IN_POPCOUNTLL:
---
> CASE_INT_FN (BUILT_IN_POPCOUNT):
> case BUILT_IN_POPCOUNTIMAX:
5213,5215c5912,5913
< case BUILT_IN_PARITY:
< case BUILT_IN_PARITYL:
< case BUILT_IN_PARITYLL:
---
> CASE_INT_FN (BUILT_IN_PARITY):
> case BUILT_IN_PARITYIMAX:
5229c5927
< target = expand_builtin_strcpy (arglist, target, mode);
---
> target = expand_builtin_strcpy (fndecl, arglist, target, mode);
5235c5933
< target = expand_builtin_strncpy (arglist, target, mode);
---
> target = expand_builtin_strncpy (exp, target, mode);
5241c5939
< target = expand_builtin_stpcpy (arglist, target, mode);
---
> target = expand_builtin_stpcpy (exp, target, mode);
5247c5945
< target = expand_builtin_strcat (arglist, target, mode);
---
> target = expand_builtin_strcat (fndecl, arglist, target, mode);
5271c5969
< target = expand_builtin_strstr (arglist, target, mode);
---
> target = expand_builtin_strstr (arglist, TREE_TYPE (exp), target, mode);
5277c5975
< target = expand_builtin_strpbrk (arglist, target, mode);
---
> target = expand_builtin_strpbrk (arglist, TREE_TYPE (exp), target, mode);
5284c5982
< target = expand_builtin_strchr (arglist, target, mode);
---
> target = expand_builtin_strchr (arglist, TREE_TYPE (exp), target, mode);
5291c5989
< target = expand_builtin_strrchr (arglist, target, mode);
---
> target = expand_builtin_strrchr (arglist, TREE_TYPE (exp), target, mode);
5297c5995
< target = expand_builtin_memcpy (arglist, target, mode);
---
> target = expand_builtin_memcpy (exp, target, mode);
5303c6001
< target = expand_builtin_mempcpy (arglist, target, mode, /*endp=*/ 1);
---
> target = expand_builtin_mempcpy (arglist, TREE_TYPE (exp), target, mode, /*endp=*/ 1);
5309c6007,6008
< target = expand_builtin_memmove (arglist, target, mode);
---
> target = expand_builtin_memmove (arglist, TREE_TYPE (exp), target,
> mode, exp);
5315c6014
< target = expand_builtin_bcopy (arglist);
---
> target = expand_builtin_bcopy (exp);
5321c6020
< target = expand_builtin_memset (arglist, target, mode);
---
> target = expand_builtin_memset (arglist, target, mode, exp);
5327c6026
< target = expand_builtin_bzero (arglist);
---
> target = expand_builtin_bzero (exp);
5352,5354c6051,6074
< target = expand_builtin_setjmp (arglist, target);
< if (target)
< return target;
---
> /* This should have been lowered to the builtins below. */
> gcc_unreachable ();
>
> case BUILT_IN_SETJMP_SETUP:
> /* __builtin_setjmp_setup is passed a pointer to an array of five words
> and the receiver label. */
> if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> {
> rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
> VOIDmode, EXPAND_NORMAL);
> tree label = TREE_OPERAND (TREE_VALUE (TREE_CHAIN (arglist)), 0);
> rtx label_r = label_rtx (label);
>
> /* This is copied from the handling of non-local gotos. */
> expand_builtin_setjmp_setup (buf_addr, label_r);
> nonlocal_goto_handler_labels
> = gen_rtx_EXPR_LIST (VOIDmode, label_r,
> nonlocal_goto_handler_labels);
> /* ??? Do not let expand_label treat us as such since we would
> not want to be both on the list of non-local labels and on
> the list of forced labels. */
> FORCED_LABEL (label) = 0;
> return const0_rtx;
> }
5356a6077,6102
> case BUILT_IN_SETJMP_DISPATCHER:
> /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
> if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
> {
> tree label = TREE_OPERAND (TREE_VALUE (arglist), 0);
> rtx label_r = label_rtx (label);
>
> /* Remove the dispatcher label from the list of non-local labels
> since the receiver labels have been added to it above. */
> remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
> return const0_rtx;
> }
> break;
>
> case BUILT_IN_SETJMP_RECEIVER:
> /* __builtin_setjmp_receiver is passed the receiver label. */
> if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
> {
> tree label = TREE_OPERAND (TREE_VALUE (arglist), 0);
> rtx label_r = label_rtx (label);
>
> expand_builtin_setjmp_receiver (label_r);
> return const0_rtx;
> }
> break;
>
5361,5363c6107
< if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
< break;
< else
---
> if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5366,5368c6110,6111
< VOIDmode, 0);
< rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
< NULL_RTX, VOIDmode, 0);
---
> VOIDmode, EXPAND_NORMAL);
> rtx value = expand_normal (TREE_VALUE (TREE_CHAIN (arglist)));
5372c6115
< error ("__builtin_longjmp second argument must be 1");
---
> error ("%<__builtin_longjmp%> second argument must be 1");
5378a6122
> break;
5379a6124,6142
> case BUILT_IN_NONLOCAL_GOTO:
> target = expand_builtin_nonlocal_goto (arglist);
> if (target)
> return target;
> break;
>
> /* This updates the setjmp buffer that is its argument with the value
> of the current stack pointer. */
> case BUILT_IN_UPDATE_SETJMP_BUF:
> if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
> {
> rtx buf_addr
> = expand_normal (TREE_VALUE (arglist));
>
> expand_builtin_update_setjmp_buf (buf_addr);
> return const0_rtx;
> }
> break;
>
5385c6148
< target = expand_builtin_printf (arglist, target, mode, false);
---
> target = expand_builtin_printf (exp, target, mode, false);
5391c6154
< target = expand_builtin_printf (arglist, target, mode, true);
---
> target = expand_builtin_printf (exp, target, mode, true);
5401d6163
<
5409c6171
< target = expand_builtin_fprintf (arglist, target, mode, false);
---
> target = expand_builtin_fprintf (exp, target, mode, false);
5415c6177
< target = expand_builtin_fprintf (arglist, target, mode, true);
---
> target = expand_builtin_fprintf (exp, target, mode, true);
5425a6188,6193
> CASE_FLT_FN (BUILT_IN_SIGNBIT):
> target = expand_builtin_signbit (exp, target);
> if (target)
> return target;
> break;
>
5466a6235,6238
> case BUILT_IN_PROFILE_FUNC_ENTER:
> return expand_builtin_profile_func (false);
> case BUILT_IN_PROFILE_FUNC_EXIT:
> return expand_builtin_profile_func (true);
5467a6240,6477
> case BUILT_IN_INIT_TRAMPOLINE:
> return expand_builtin_init_trampoline (arglist);
> case BUILT_IN_ADJUST_TRAMPOLINE:
> return expand_builtin_adjust_trampoline (arglist);
>
> case BUILT_IN_FORK:
> case BUILT_IN_EXECL:
> case BUILT_IN_EXECV:
> case BUILT_IN_EXECLP:
> case BUILT_IN_EXECLE:
> case BUILT_IN_EXECVP:
> case BUILT_IN_EXECVE:
> target = expand_builtin_fork_or_exec (fndecl, arglist, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_ADD_1:
> case BUILT_IN_FETCH_AND_ADD_2:
> case BUILT_IN_FETCH_AND_ADD_4:
> case BUILT_IN_FETCH_AND_ADD_8:
> case BUILT_IN_FETCH_AND_ADD_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
> target = expand_builtin_sync_operation (mode, arglist, PLUS,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_SUB_1:
> case BUILT_IN_FETCH_AND_SUB_2:
> case BUILT_IN_FETCH_AND_SUB_4:
> case BUILT_IN_FETCH_AND_SUB_8:
> case BUILT_IN_FETCH_AND_SUB_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
> target = expand_builtin_sync_operation (mode, arglist, MINUS,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_OR_1:
> case BUILT_IN_FETCH_AND_OR_2:
> case BUILT_IN_FETCH_AND_OR_4:
> case BUILT_IN_FETCH_AND_OR_8:
> case BUILT_IN_FETCH_AND_OR_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
> target = expand_builtin_sync_operation (mode, arglist, IOR,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_AND_1:
> case BUILT_IN_FETCH_AND_AND_2:
> case BUILT_IN_FETCH_AND_AND_4:
> case BUILT_IN_FETCH_AND_AND_8:
> case BUILT_IN_FETCH_AND_AND_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
> target = expand_builtin_sync_operation (mode, arglist, AND,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_XOR_1:
> case BUILT_IN_FETCH_AND_XOR_2:
> case BUILT_IN_FETCH_AND_XOR_4:
> case BUILT_IN_FETCH_AND_XOR_8:
> case BUILT_IN_FETCH_AND_XOR_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
> target = expand_builtin_sync_operation (mode, arglist, XOR,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_FETCH_AND_NAND_1:
> case BUILT_IN_FETCH_AND_NAND_2:
> case BUILT_IN_FETCH_AND_NAND_4:
> case BUILT_IN_FETCH_AND_NAND_8:
> case BUILT_IN_FETCH_AND_NAND_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
> target = expand_builtin_sync_operation (mode, arglist, NOT,
> false, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_ADD_AND_FETCH_1:
> case BUILT_IN_ADD_AND_FETCH_2:
> case BUILT_IN_ADD_AND_FETCH_4:
> case BUILT_IN_ADD_AND_FETCH_8:
> case BUILT_IN_ADD_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, PLUS,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_SUB_AND_FETCH_1:
> case BUILT_IN_SUB_AND_FETCH_2:
> case BUILT_IN_SUB_AND_FETCH_4:
> case BUILT_IN_SUB_AND_FETCH_8:
> case BUILT_IN_SUB_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, MINUS,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_OR_AND_FETCH_1:
> case BUILT_IN_OR_AND_FETCH_2:
> case BUILT_IN_OR_AND_FETCH_4:
> case BUILT_IN_OR_AND_FETCH_8:
> case BUILT_IN_OR_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, IOR,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_AND_AND_FETCH_1:
> case BUILT_IN_AND_AND_FETCH_2:
> case BUILT_IN_AND_AND_FETCH_4:
> case BUILT_IN_AND_AND_FETCH_8:
> case BUILT_IN_AND_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, AND,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_XOR_AND_FETCH_1:
> case BUILT_IN_XOR_AND_FETCH_2:
> case BUILT_IN_XOR_AND_FETCH_4:
> case BUILT_IN_XOR_AND_FETCH_8:
> case BUILT_IN_XOR_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, XOR,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_NAND_AND_FETCH_1:
> case BUILT_IN_NAND_AND_FETCH_2:
> case BUILT_IN_NAND_AND_FETCH_4:
> case BUILT_IN_NAND_AND_FETCH_8:
> case BUILT_IN_NAND_AND_FETCH_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
> target = expand_builtin_sync_operation (mode, arglist, NOT,
> true, target, ignore);
> if (target)
> return target;
> break;
>
> case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
> case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
> case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
> case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
> case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
> if (mode == VOIDmode)
> mode = TYPE_MODE (boolean_type_node);
> if (!target || !register_operand (target, mode))
> target = gen_reg_rtx (mode);
>
> mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
> target = expand_builtin_compare_and_swap (mode, arglist, true, target);
> if (target)
> return target;
> break;
>
> case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
> case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
> case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
> case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
> case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
> target = expand_builtin_compare_and_swap (mode, arglist, false, target);
> if (target)
> return target;
> break;
>
> case BUILT_IN_LOCK_TEST_AND_SET_1:
> case BUILT_IN_LOCK_TEST_AND_SET_2:
> case BUILT_IN_LOCK_TEST_AND_SET_4:
> case BUILT_IN_LOCK_TEST_AND_SET_8:
> case BUILT_IN_LOCK_TEST_AND_SET_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
> target = expand_builtin_lock_test_and_set (mode, arglist, target);
> if (target)
> return target;
> break;
>
> case BUILT_IN_LOCK_RELEASE_1:
> case BUILT_IN_LOCK_RELEASE_2:
> case BUILT_IN_LOCK_RELEASE_4:
> case BUILT_IN_LOCK_RELEASE_8:
> case BUILT_IN_LOCK_RELEASE_16:
> mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
> expand_builtin_lock_release (mode, arglist);
> return const0_rtx;
>
> case BUILT_IN_SYNCHRONIZE:
> expand_builtin_synchronize ();
> return const0_rtx;
>
> case BUILT_IN_OBJECT_SIZE:
> return expand_builtin_object_size (exp);
>
> case BUILT_IN_MEMCPY_CHK:
> case BUILT_IN_MEMPCPY_CHK:
> case BUILT_IN_MEMMOVE_CHK:
> case BUILT_IN_MEMSET_CHK:
> target = expand_builtin_memory_chk (exp, target, mode, fcode);
> if (target)
> return target;
> break;
>
> case BUILT_IN_STRCPY_CHK:
> case BUILT_IN_STPCPY_CHK:
> case BUILT_IN_STRNCPY_CHK:
> case BUILT_IN_STRCAT_CHK:
> case BUILT_IN_SNPRINTF_CHK:
> case BUILT_IN_VSNPRINTF_CHK:
> maybe_emit_chk_warning (exp, fcode);
> break;
>
> case BUILT_IN_SPRINTF_CHK:
> case BUILT_IN_VSPRINTF_CHK:
> maybe_emit_sprintf_chk_warning (exp, fcode);
> break;
>
5469,5471c6479
< if (!DECL_ASSEMBLER_NAME_SET_P (fndecl))
< error ("built-in function `%s' not currently supported",
< IDENTIFIER_POINTER (DECL_NAME (fndecl)));
---
> break;
5568c6576
< if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
---
> if (CONSTANT_CLASS_P (arglist)
5570,5572c6578
< && TREE_CONSTANT (arglist))
< || (TREE_CODE (arglist) == ADDR_EXPR
< && TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST))
---
> && TREE_CONSTANT (arglist)))
5573a6580,6588
> if (TREE_CODE (arglist) == ADDR_EXPR)
> {
> tree op = TREE_OPERAND (arglist, 0);
> if (TREE_CODE (op) == STRING_CST
> || (TREE_CODE (op) == ARRAY_REF
> && integer_zerop (TREE_OPERAND (op, 1))
> && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
> return integer_one_node;
> }
5585c6600,6601
< || cfun == 0)
---
> || cfun == 0
> || folding_initializer)
5590a6607,6644
> /* Fold a call to __builtin_expect, if we expect that a comparison against
> the argument will fold to a constant. In practice, this means a true
> constant or the address of a non-weak symbol. ARGLIST is the argument
> list of the call. */
>
> static tree
> fold_builtin_expect (tree arglist)
> {
> tree arg, inner;
>
> if (arglist == 0)
> return 0;
>
> arg = TREE_VALUE (arglist);
>
> /* If the argument isn't invariant, then there's nothing we can do. */
> if (!TREE_INVARIANT (arg))
> return 0;
>
> /* If we're looking at an address of a weak decl, then do not fold. */
> inner = arg;
> STRIP_NOPS (inner);
> if (TREE_CODE (inner) == ADDR_EXPR)
> {
> do
> {
> inner = TREE_OPERAND (inner, 0);
> }
> while (TREE_CODE (inner) == COMPONENT_REF
> || TREE_CODE (inner) == ARRAY_REF);
> if (DECL_P (inner) && DECL_WEAK (inner))
> return 0;
> }
>
> /* Otherwise, ARG already has the proper type for the return value. */
> return arg;
> }
>
5597c6651
< return build_int_2 (no_type_class, 0);
---
> return build_int_cst (NULL_TREE, no_type_class);
5599c6653,6654
< return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
---
> return build_int_cst (NULL_TREE,
> type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
5601a6657,6679
> /* Fold a call to __builtin_strlen. */
>
> static tree
> fold_builtin_strlen (tree arglist)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
> return NULL_TREE;
> else
> {
> tree len = c_strlen (TREE_VALUE (arglist), 0);
>
> if (len)
> {
> /* Convert from the internal "sizetype" type to "size_t". */
> if (size_type_node)
> len = fold_convert (size_type_node, len);
> return len;
> }
>
> return NULL_TREE;
> }
> }
>
5608a6687,6693
> /* __builtin_inff is intended to be usable to define INFINITY on all
> targets. If an infinity is not available, INFINITY expands "to a
> positive constant of type float that overflows at translation
> time", footnote "In this case, using INFINITY will violate the
> constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
> Thus we pedwarn to ensure this constraint violation is
> diagnosed. */
5610c6695
< warning ("target format does not support infinity");
---
> pedwarn ("target format does not support infinity");
5672c6757
< REAL_VALUE_TYPE c, cint;
---
> REAL_VALUE_TYPE c, cint;
5677a6763
> break;
5692,5706c6778,6783
< case BUILT_IN_CEIL:
< case BUILT_IN_CEILF:
< case BUILT_IN_CEILL:
< case BUILT_IN_FLOOR:
< case BUILT_IN_FLOORF:
< case BUILT_IN_FLOORL:
< case BUILT_IN_NEARBYINT:
< case BUILT_IN_NEARBYINTF:
< case BUILT_IN_NEARBYINTL:
< case BUILT_IN_ROUND:
< case BUILT_IN_ROUNDF:
< case BUILT_IN_ROUNDL:
< case BUILT_IN_TRUNC:
< case BUILT_IN_TRUNCF:
< case BUILT_IN_TRUNCL:
---
> CASE_FLT_FN (BUILT_IN_CEIL):
> CASE_FLT_FN (BUILT_IN_FLOOR):
> CASE_FLT_FN (BUILT_IN_NEARBYINT):
> CASE_FLT_FN (BUILT_IN_RINT):
> CASE_FLT_FN (BUILT_IN_ROUND):
> CASE_FLT_FN (BUILT_IN_TRUNC):
5725c6802
< fold_trunc_transparent_mathfn (tree exp)
---
> fold_trunc_transparent_mathfn (tree fndecl, tree arglist)
5727,5728d6803
< tree fndecl = get_callee_fndecl (exp);
< tree arglist = TREE_OPERAND (exp, 1);
5748c6823
< tree ftype = TREE_TYPE (exp);
---
> tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
5756,5758c6831,6833
< build_tree_list (NULL_TREE, fold (convert (newtype, arg0)));
< return convert (ftype,
< build_function_call_expr (decl, arglist));
---
> build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
> return fold_convert (ftype,
> build_function_call_expr (decl, arglist));
5764,5766c6839,6840
< /* Fold function call to builtin cabs, cabsf or cabsl. FNDECL is the
< function's DECL, ARGLIST is the argument list and TYPE is the return
< type. Return NULL_TREE if no simplification can be made. */
---
> /* EXP is assumed to be builtin call which can narrow the FP type of
> the argument, for instance lround((double)f) -> lroundf (f). */
5769c6843
< fold_builtin_cabs (tree fndecl, tree arglist, tree type)
---
> fold_fixed_mathfn (tree fndecl, tree arglist)
5770a6845
> enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5772a6848,6921
> if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
>
> arg = TREE_VALUE (arglist);
>
> /* If argument is already integer valued, and we don't need to worry
> about setting errno, there's no need to perform rounding. */
> if (! flag_errno_math && integer_valued_real_p (arg))
> return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
>
> if (optimize)
> {
> tree ftype = TREE_TYPE (arg);
> tree arg0 = strip_float_extensions (arg);
> tree newtype = TREE_TYPE (arg0);
> tree decl;
>
> if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
> && (decl = mathfn_built_in (newtype, fcode)))
> {
> arglist =
> build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
> return build_function_call_expr (decl, arglist);
> }
> }
>
> /* Canonicalize llround (x) to lround (x) on LP64 targets where
> sizeof (long long) == sizeof (long). */
> if (TYPE_PRECISION (long_long_integer_type_node)
> == TYPE_PRECISION (long_integer_type_node))
> {
> tree newfn = NULL_TREE;
> switch (fcode)
> {
> CASE_FLT_FN (BUILT_IN_LLCEIL):
> newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
> break;
>
> CASE_FLT_FN (BUILT_IN_LLFLOOR):
> newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
> break;
>
> CASE_FLT_FN (BUILT_IN_LLROUND):
> newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
> break;
>
> CASE_FLT_FN (BUILT_IN_LLRINT):
> newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
> break;
>
> default:
> break;
> }
>
> if (newfn)
> {
> tree newcall = build_function_call_expr (newfn, arglist);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), newcall);
> }
> }
>
> return 0;
> }
>
> /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
> is the argument list, TYPE is the return type and FNDECL is the
> original function DECL. Return NULL_TREE if no if no simplification
> can be made. */
>
> static tree
> fold_builtin_cabs (tree arglist, tree type, tree fndecl)
> {
> tree arg;
>
5805c6954
< return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1)));
---
> return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1));
5808c6957
< return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0)));
---
> return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0));
5810c6959,6961
< if (flag_unsafe_math_optimizations)
---
> /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
> if (TREE_CODE (arg) == NEGATE_EXPR
> || TREE_CODE (arg) == CONJ_EXPR)
5812,5813c6963,6965
< enum built_in_function fcode;
< tree sqrtfn;
---
> tree arglist = build_tree_list (NULL_TREE, TREE_OPERAND (arg, 0));
> return build_function_call_expr (fndecl, arglist);
> }
5815,5823c6967,6971
< fcode = DECL_FUNCTION_CODE (fndecl);
< if (fcode == BUILT_IN_CABS)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
< else if (fcode == BUILT_IN_CABSF)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
< else if (fcode == BUILT_IN_CABSL)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
< else
< sqrtfn = NULL_TREE;
---
> /* Don't do this when optimizing for size. */
> if (flag_unsafe_math_optimizations
> && optimize && !optimize_size)
> {
> tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
5829c6977
< arg = save_expr (arg);
---
> arg = builtin_save_expr (arg);
5831,5832c6979,6980
< rpart = fold (build1 (REALPART_EXPR, type, arg));
< ipart = fold (build1 (IMAGPART_EXPR, type, arg));
---
> rpart = fold_build1 (REALPART_EXPR, type, arg);
> ipart = fold_build1 (IMAGPART_EXPR, type, arg);
5834,5835c6982,6983
< rpart = save_expr (rpart);
< ipart = save_expr (ipart);
---
> rpart = builtin_save_expr (rpart);
> ipart = builtin_save_expr (ipart);
5837,5841c6985,6989
< result = fold (build (PLUS_EXPR, type,
< fold (build (MULT_EXPR, type,
< rpart, rpart)),
< fold (build (MULT_EXPR, type,
< ipart, ipart))));
---
> result = fold_build2 (PLUS_EXPR, type,
> fold_build2 (MULT_EXPR, type,
> rpart, rpart),
> fold_build2 (MULT_EXPR, type,
> ipart, ipart));
5850a6999,7272
> /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
> NULL_TREE if no simplification can be made. */
>
> static tree
> fold_builtin_sqrt (tree arglist, tree type)
> {
>
> enum built_in_function fcode;
> tree arg = TREE_VALUE (arglist);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize sqrt of constant value. */
> if (TREE_CODE (arg) == REAL_CST
> && ! TREE_CONSTANT_OVERFLOW (arg))
> {
> REAL_VALUE_TYPE r, x;
>
> x = TREE_REAL_CST (arg);
> if (real_sqrt (&r, TYPE_MODE (type), &x)
> || (!flag_trapping_math && !flag_errno_math))
> return build_real (type, r);
> }
>
> /* Optimize sqrt(expN(x)) = expN(x*0.5). */
> fcode = builtin_mathfn_code (arg);
> if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
> {
> tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
> arg = fold_build2 (MULT_EXPR, type,
> TREE_VALUE (TREE_OPERAND (arg, 1)),
> build_real (type, dconsthalf));
> arglist = build_tree_list (NULL_TREE, arg);
> return build_function_call_expr (expfn, arglist);
> }
>
> /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
> if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
> {
> tree powfn = mathfn_built_in (type, BUILT_IN_POW);
>
> if (powfn)
> {
> tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
> tree tree_root;
> /* The inner root was either sqrt or cbrt. */
> REAL_VALUE_TYPE dconstroot =
> BUILTIN_SQRT_P (fcode) ? dconsthalf : dconstthird;
>
> /* Adjust for the outer root. */
> SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
> dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
> tree_root = build_real (type, dconstroot);
> arglist = tree_cons (NULL_TREE, arg0,
> build_tree_list (NULL_TREE, tree_root));
> return build_function_call_expr (powfn, arglist);
> }
> }
>
> /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
> if (flag_unsafe_math_optimizations
> && (fcode == BUILT_IN_POW
> || fcode == BUILT_IN_POWF
> || fcode == BUILT_IN_POWL))
> {
> tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
> tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
> tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
> tree narg1;
> if (!tree_expr_nonnegative_p (arg0))
> arg0 = build1 (ABS_EXPR, type, arg0);
> narg1 = fold_build2 (MULT_EXPR, type, arg1,
> build_real (type, dconsthalf));
> arglist = tree_cons (NULL_TREE, arg0,
> build_tree_list (NULL_TREE, narg1));
> return build_function_call_expr (powfn, arglist);
> }
>
> return NULL_TREE;
> }
>
> /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_cbrt (tree arglist, tree type)
> {
> tree arg = TREE_VALUE (arglist);
> const enum built_in_function fcode = builtin_mathfn_code (arg);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize cbrt of constant value. */
> if (real_zerop (arg) || real_onep (arg) || real_minus_onep (arg))
> return arg;
>
> if (flag_unsafe_math_optimizations)
> {
> /* Optimize cbrt(expN(x)) -> expN(x/3). */
> if (BUILTIN_EXPONENT_P (fcode))
> {
> tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
> const REAL_VALUE_TYPE third_trunc =
> real_value_truncate (TYPE_MODE (type), dconstthird);
> arg = fold_build2 (MULT_EXPR, type,
> TREE_VALUE (TREE_OPERAND (arg, 1)),
> build_real (type, third_trunc));
> arglist = build_tree_list (NULL_TREE, arg);
> return build_function_call_expr (expfn, arglist);
> }
>
> /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
> if (BUILTIN_SQRT_P (fcode))
> {
> tree powfn = mathfn_built_in (type, BUILT_IN_POW);
>
> if (powfn)
> {
> tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
> tree tree_root;
> REAL_VALUE_TYPE dconstroot = dconstthird;
>
> SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
> dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
> tree_root = build_real (type, dconstroot);
> arglist = tree_cons (NULL_TREE, arg0,
> build_tree_list (NULL_TREE, tree_root));
> return build_function_call_expr (powfn, arglist);
> }
> }
>
> /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
> if (BUILTIN_CBRT_P (fcode))
> {
> tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
> if (tree_expr_nonnegative_p (arg0))
> {
> tree powfn = mathfn_built_in (type, BUILT_IN_POW);
>
> if (powfn)
> {
> tree tree_root;
> REAL_VALUE_TYPE dconstroot;
>
> real_arithmetic (&dconstroot, MULT_EXPR, &dconstthird, &dconstthird);
> dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
> tree_root = build_real (type, dconstroot);
> arglist = tree_cons (NULL_TREE, arg0,
> build_tree_list (NULL_TREE, tree_root));
> return build_function_call_expr (powfn, arglist);
> }
> }
> }
>
> /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
> if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
> || fcode == BUILT_IN_POWL)
> {
> tree arg00 = TREE_VALUE (TREE_OPERAND (arg, 1));
> tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
> if (tree_expr_nonnegative_p (arg00))
> {
> tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
> const REAL_VALUE_TYPE dconstroot
> = real_value_truncate (TYPE_MODE (type), dconstthird);
> tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
> build_real (type, dconstroot));
> arglist = tree_cons (NULL_TREE, arg00,
> build_tree_list (NULL_TREE, narg01));
> return build_function_call_expr (powfn, arglist);
> }
> }
> }
> return NULL_TREE;
> }
>
> /* Fold function call to builtin sin, sinf, or sinl. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_sin (tree arglist)
> {
> tree arg = TREE_VALUE (arglist);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize sin (0.0) = 0.0. */
> if (real_zerop (arg))
> return arg;
>
> return NULL_TREE;
> }
>
> /* Fold function call to builtin cos, cosf, or cosl. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_cos (tree arglist, tree type, tree fndecl)
> {
> tree arg = TREE_VALUE (arglist);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize cos (0.0) = 1.0. */
> if (real_zerop (arg))
> return build_real (type, dconst1);
>
> /* Optimize cos(-x) into cos (x). */
> if (TREE_CODE (arg) == NEGATE_EXPR)
> {
> tree args = build_tree_list (NULL_TREE,
> TREE_OPERAND (arg, 0));
> return build_function_call_expr (fndecl, args);
> }
>
> return NULL_TREE;
> }
>
> /* Fold function call to builtin tan, tanf, or tanl. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_tan (tree arglist)
> {
> enum built_in_function fcode;
> tree arg = TREE_VALUE (arglist);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize tan(0.0) = 0.0. */
> if (real_zerop (arg))
> return arg;
>
> /* Optimize tan(atan(x)) = x. */
> fcode = builtin_mathfn_code (arg);
> if (flag_unsafe_math_optimizations
> && (fcode == BUILT_IN_ATAN
> || fcode == BUILT_IN_ATANF
> || fcode == BUILT_IN_ATANL))
> return TREE_VALUE (TREE_OPERAND (arg, 1));
>
> return NULL_TREE;
> }
>
> /* Fold function call to builtin atan, atanf, or atanl. Return
> NULL_TREE if no simplification can be made. */
>
> static tree
> fold_builtin_atan (tree arglist, tree type)
> {
>
> tree arg = TREE_VALUE (arglist);
>
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize atan(0.0) = 0.0. */
> if (real_zerop (arg))
> return arg;
>
> /* Optimize atan(1.0) = pi/4. */
> if (real_onep (arg))
> {
> REAL_VALUE_TYPE cst;
>
> real_convert (&cst, TYPE_MODE (type), &dconstpi);
> SET_REAL_EXP (&cst, REAL_EXP (&cst) - 2);
> return build_real (type, cst);
> }
>
> return NULL_TREE;
> }
>
5855c7277
< fold_builtin_trunc (tree exp)
---
> fold_builtin_trunc (tree fndecl, tree arglist)
5857d7278
< tree arglist = TREE_OPERAND (exp, 1);
5868c7289
< tree type = TREE_TYPE (exp);
---
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
5875c7296
< return fold_trunc_transparent_mathfn (exp);
---
> return fold_trunc_transparent_mathfn (fndecl, arglist);
5882c7303
< fold_builtin_floor (tree exp)
---
> fold_builtin_floor (tree fndecl, tree arglist)
5884d7304
< tree arglist = TREE_OPERAND (exp, 1);
5899c7319
< tree type = TREE_TYPE (exp);
---
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
5907c7327
< return fold_trunc_transparent_mathfn (exp);
---
> return fold_trunc_transparent_mathfn (fndecl, arglist);
5914c7334
< fold_builtin_ceil (tree exp)
---
> fold_builtin_ceil (tree fndecl, tree arglist)
5916d7335
< tree arglist = TREE_OPERAND (exp, 1);
5931c7350
< tree type = TREE_TYPE (exp);
---
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
5939c7358
< return fold_trunc_transparent_mathfn (exp);
---
> return fold_trunc_transparent_mathfn (fndecl, arglist);
5941a7361,7447
> /* Fold function call to builtin round, roundf or roundl. Return
> NULL_TREE if no simplification can be made. */
>
> static tree
> fold_builtin_round (tree fndecl, tree arglist)
> {
> tree arg;
>
> if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
>
> /* Optimize round of constant value. */
> arg = TREE_VALUE (arglist);
> if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
> {
> REAL_VALUE_TYPE x;
>
> x = TREE_REAL_CST (arg);
> if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
> {
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
> REAL_VALUE_TYPE r;
>
> real_round (&r, TYPE_MODE (type), &x);
> return build_real (type, r);
> }
> }
>
> return fold_trunc_transparent_mathfn (fndecl, arglist);
> }
>
> /* Fold function call to builtin lround, lroundf or lroundl (or the
> corresponding long long versions) and other rounding functions.
> Return NULL_TREE if no simplification can be made. */
>
> static tree
> fold_builtin_int_roundingfn (tree fndecl, tree arglist)
> {
> tree arg;
>
> if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
>
> /* Optimize lround of constant value. */
> arg = TREE_VALUE (arglist);
> if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
> {
> const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
>
> if (! REAL_VALUE_ISNAN (x) && ! REAL_VALUE_ISINF (x))
> {
> tree itype = TREE_TYPE (TREE_TYPE (fndecl));
> tree ftype = TREE_TYPE (arg), result;
> HOST_WIDE_INT hi, lo;
> REAL_VALUE_TYPE r;
>
> switch (DECL_FUNCTION_CODE (fndecl))
> {
> CASE_FLT_FN (BUILT_IN_LFLOOR):
> CASE_FLT_FN (BUILT_IN_LLFLOOR):
> real_floor (&r, TYPE_MODE (ftype), &x);
> break;
>
> CASE_FLT_FN (BUILT_IN_LCEIL):
> CASE_FLT_FN (BUILT_IN_LLCEIL):
> real_ceil (&r, TYPE_MODE (ftype), &x);
> break;
>
> CASE_FLT_FN (BUILT_IN_LROUND):
> CASE_FLT_FN (BUILT_IN_LLROUND):
> real_round (&r, TYPE_MODE (ftype), &x);
> break;
>
> default:
> gcc_unreachable ();
> }
>
> REAL_VALUE_TO_INT (&lo, &hi, r);
> result = build_int_cst_wide (NULL_TREE, lo, hi);
> if (int_fits_type_p (result, itype))
> return fold_convert (itype, result);
> }
> }
>
> return fold_fixed_mathfn (fndecl, arglist);
> }
>
5947c7453
< fold_builtin_bitop (tree exp)
---
> fold_builtin_bitop (tree fndecl, tree arglist)
5949,5950d7454
< tree fndecl = get_callee_fndecl (exp);
< tree arglist = TREE_OPERAND (exp, 1);
5962c7466
< tree type, t;
---
> tree type;
5984,5986c7488
< case BUILT_IN_FFS:
< case BUILT_IN_FFSL:
< case BUILT_IN_FFSLL:
---
> CASE_INT_FN (BUILT_IN_FFS):
5995,5997c7497
< case BUILT_IN_CLZ:
< case BUILT_IN_CLZL:
< case BUILT_IN_CLZLL:
---
> CASE_INT_FN (BUILT_IN_CLZ):
6006,6008c7506
< case BUILT_IN_CTZ:
< case BUILT_IN_CTZL:
< case BUILT_IN_CTZLL:
---
> CASE_INT_FN (BUILT_IN_CTZ):
6017,6019c7515
< case BUILT_IN_POPCOUNT:
< case BUILT_IN_POPCOUNTL:
< case BUILT_IN_POPCOUNTLL:
---
> CASE_INT_FN (BUILT_IN_POPCOUNT):
6027,6029c7523
< case BUILT_IN_PARITY:
< case BUILT_IN_PARITYL:
< case BUILT_IN_PARITYLL:
---
> CASE_INT_FN (BUILT_IN_PARITY):
6039c7533
< abort();
---
> gcc_unreachable ();
6042,6044c7536
< t = build_int_2 (result, 0);
< TREE_TYPE (t) = TREE_TYPE (exp);
< return t;
---
> return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
6058,6062c7550,7554
< && ! TREE_CONSTANT_OVERFLOW (expr)
< && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
< || (TREE_CODE (expr) == COMPLEX_CST
< && real_dconstp (TREE_REALPART (expr), value)
< && real_zerop (TREE_IMAGPART (expr))));
---
> && ! TREE_CONSTANT_OVERFLOW (expr)
> && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
> || (TREE_CODE (expr) == COMPLEX_CST
> && real_dconstp (TREE_REALPART (expr), value)
> && real_zerop (TREE_IMAGPART (expr))));
6066,6067c7558,7559
< functions. EXP is the CALL_EXPR of a call to a builtin log*
< function. VALUE is the base of the log* function. */
---
> functions. EXP is the CALL_EXPR of a call to a builtin logN
> function. VALUE is the base of the logN function. */
6070c7562,7563
< fold_builtin_logarithm (tree exp, const REAL_VALUE_TYPE *value)
---
> fold_builtin_logarithm (tree fndecl, tree arglist,
> const REAL_VALUE_TYPE *value)
6072,6073d7564
< tree arglist = TREE_OPERAND (exp, 1);
<
6076d7566
< tree fndecl = get_callee_fndecl (exp);
6080,6081c7570,7571
<
< /* Optimize log*(1.0) = 0.0. */
---
>
> /* Optimize logN(1.0) = 0.0. */
6086c7576
< exactly, then only do this if flag_unsafe_math_optimizations. */
---
> exactly, then only do this if flag_unsafe_math_optimizations. */
6089c7579
< {
---
> {
6095c7585
<
---
>
6106,6110c7596,7597
< || (value == &dconst10
< && (fcode == BUILT_IN_EXP10
< || fcode == BUILT_IN_EXP10F
< || fcode == BUILT_IN_EXP10L))))
< return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
---
> || (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
> return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6112,6114c7599,7601
< /* Optimize log*(func()) for various exponential functions. We
< want to determine the value "x" and the power "exponent" in
< order to transform logN(x**exponent) into exponent*logN(x). */
---
> /* Optimize logN(func()) for various exponential functions. We
> want to determine the value "x" and the power "exponent" in
> order to transform logN(x**exponent) into exponent*logN(x). */
6116c7603
< {
---
> {
6118c7605
<
---
>
6121,6123c7608
< case BUILT_IN_EXP:
< case BUILT_IN_EXPF:
< case BUILT_IN_EXPL:
---
> CASE_FLT_FN (BUILT_IN_EXP):
6129,6131c7614
< case BUILT_IN_EXP2:
< case BUILT_IN_EXP2F:
< case BUILT_IN_EXP2L:
---
> CASE_FLT_FN (BUILT_IN_EXP2):
6136,6141c7619,7620
< case BUILT_IN_EXP10:
< case BUILT_IN_EXP10F:
< case BUILT_IN_EXP10L:
< case BUILT_IN_POW10:
< case BUILT_IN_POW10F:
< case BUILT_IN_POW10L:
---
> CASE_FLT_FN (BUILT_IN_EXP10):
> CASE_FLT_FN (BUILT_IN_POW10):
6146,6148c7625
< case BUILT_IN_SQRT:
< case BUILT_IN_SQRTF:
< case BUILT_IN_SQRTL:
---
> CASE_FLT_FN (BUILT_IN_SQRT):
6153,6155c7630
< case BUILT_IN_CBRT:
< case BUILT_IN_CBRTF:
< case BUILT_IN_CBRTL:
---
> CASE_FLT_FN (BUILT_IN_CBRT):
6161,6163c7636
< case BUILT_IN_POW:
< case BUILT_IN_POWF:
< case BUILT_IN_POWL:
---
> CASE_FLT_FN (BUILT_IN_POW):
6178c7651
< return fold (build (MULT_EXPR, type, exponent, logfn));
---
> return fold_build2 (MULT_EXPR, type, exponent, logfn);
6185c7658,7846
<
---
>
> /* Fold a builtin function call to pow, powf, or powl. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_pow (tree fndecl, tree arglist, tree type)
> {
> tree arg0 = TREE_VALUE (arglist);
> tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
>
> if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize pow(1.0,y) = 1.0. */
> if (real_onep (arg0))
> return omit_one_operand (type, build_real (type, dconst1), arg1);
>
> if (TREE_CODE (arg1) == REAL_CST
> && ! TREE_CONSTANT_OVERFLOW (arg1))
> {
> REAL_VALUE_TYPE cint;
> REAL_VALUE_TYPE c;
> HOST_WIDE_INT n;
>
> c = TREE_REAL_CST (arg1);
>
> /* Optimize pow(x,0.0) = 1.0. */
> if (REAL_VALUES_EQUAL (c, dconst0))
> return omit_one_operand (type, build_real (type, dconst1),
> arg0);
>
> /* Optimize pow(x,1.0) = x. */
> if (REAL_VALUES_EQUAL (c, dconst1))
> return arg0;
>
> /* Optimize pow(x,-1.0) = 1.0/x. */
> if (REAL_VALUES_EQUAL (c, dconstm1))
> return fold_build2 (RDIV_EXPR, type,
> build_real (type, dconst1), arg0);
>
> /* Optimize pow(x,0.5) = sqrt(x). */
> if (flag_unsafe_math_optimizations
> && REAL_VALUES_EQUAL (c, dconsthalf))
> {
> tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
>
> if (sqrtfn != NULL_TREE)
> {
> tree arglist = build_tree_list (NULL_TREE, arg0);
> return build_function_call_expr (sqrtfn, arglist);
> }
> }
>
> /* Check for an integer exponent. */
> n = real_to_integer (&c);
> real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
> if (real_identical (&c, &cint))
> {
> /* Attempt to evaluate pow at compile-time. */
> if (TREE_CODE (arg0) == REAL_CST
> && ! TREE_CONSTANT_OVERFLOW (arg0))
> {
> REAL_VALUE_TYPE x;
> bool inexact;
>
> x = TREE_REAL_CST (arg0);
> inexact = real_powi (&x, TYPE_MODE (type), &x, n);
> if (flag_unsafe_math_optimizations || !inexact)
> return build_real (type, x);
> }
>
> /* Strip sign ops from even integer powers. */
> if ((n & 1) == 0 && flag_unsafe_math_optimizations)
> {
> tree narg0 = fold_strip_sign_ops (arg0);
> if (narg0)
> {
> arglist = build_tree_list (NULL_TREE, arg1);
> arglist = tree_cons (NULL_TREE, narg0, arglist);
> return build_function_call_expr (fndecl, arglist);
> }
> }
> }
> }
>
> if (flag_unsafe_math_optimizations)
> {
> const enum built_in_function fcode = builtin_mathfn_code (arg0);
>
> /* Optimize pow(expN(x),y) = expN(x*y). */
> if (BUILTIN_EXPONENT_P (fcode))
> {
> tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
> tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
> arg = fold_build2 (MULT_EXPR, type, arg, arg1);
> arglist = build_tree_list (NULL_TREE, arg);
> return build_function_call_expr (expfn, arglist);
> }
>
> /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
> if (BUILTIN_SQRT_P (fcode))
> {
> tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
> tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
> build_real (type, dconsthalf));
>
> arglist = tree_cons (NULL_TREE, narg0,
> build_tree_list (NULL_TREE, narg1));
> return build_function_call_expr (fndecl, arglist);
> }
>
> /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
> if (BUILTIN_CBRT_P (fcode))
> {
> tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
> if (tree_expr_nonnegative_p (arg))
> {
> const REAL_VALUE_TYPE dconstroot
> = real_value_truncate (TYPE_MODE (type), dconstthird);
> tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
> build_real (type, dconstroot));
> arglist = tree_cons (NULL_TREE, arg,
> build_tree_list (NULL_TREE, narg1));
> return build_function_call_expr (fndecl, arglist);
> }
> }
>
> /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
> if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
> || fcode == BUILT_IN_POWL)
> {
> tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
> tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
> tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
> arglist = tree_cons (NULL_TREE, arg00,
> build_tree_list (NULL_TREE, narg1));
> return build_function_call_expr (fndecl, arglist);
> }
> }
>
> return NULL_TREE;
> }
>
> /* Fold a builtin function call to powi, powif, or powil. Return
> NULL_TREE if no simplification can be made. */
> static tree
> fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED, tree arglist, tree type)
> {
> tree arg0 = TREE_VALUE (arglist);
> tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
>
> if (!validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> /* Optimize pow(1.0,y) = 1.0. */
> if (real_onep (arg0))
> return omit_one_operand (type, build_real (type, dconst1), arg1);
>
> if (host_integerp (arg1, 0))
> {
> HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
>
> /* Evaluate powi at compile-time. */
> if (TREE_CODE (arg0) == REAL_CST
> && ! TREE_CONSTANT_OVERFLOW (arg0))
> {
> REAL_VALUE_TYPE x;
> x = TREE_REAL_CST (arg0);
> real_powi (&x, TYPE_MODE (type), &x, c);
> return build_real (type, x);
> }
>
> /* Optimize pow(x,0) = 1.0. */
> if (c == 0)
> return omit_one_operand (type, build_real (type, dconst1),
> arg0);
>
> /* Optimize pow(x,1) = x. */
> if (c == 1)
> return arg0;
>
> /* Optimize pow(x,-1) = 1.0/x. */
> if (c == -1)
> return fold_build2 (RDIV_EXPR, type,
> build_real (type, dconst1), arg0);
> }
>
> return NULL_TREE;
> }
>
6191c7852,7853
< fold_builtin_exponent (tree exp, const REAL_VALUE_TYPE *value)
---
> fold_builtin_exponent (tree fndecl, tree arglist,
> const REAL_VALUE_TYPE *value)
6193,6194d7854
< tree arglist = TREE_OPERAND (exp, 1);
<
6197d7856
< tree fndecl = get_callee_fndecl (exp);
6207c7866
< {
---
> {
6218c7877
< {
---
> {
6238c7897
< {
---
> {
6253c7912
< return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
---
> return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
6260c7919,7930
< /* Fold function call to builtin memcpy. Return
---
> /* Return true if VAR is a VAR_DECL or a component thereof. */
>
> static bool
> var_decl_component_p (tree var)
> {
> tree inner = var;
> while (handled_component_p (inner))
> inner = TREE_OPERAND (inner, 0);
> return SSA_VAR_P (inner);
> }
>
> /* Fold function call to builtin memset. Return
6264c7934
< fold_builtin_memcpy (tree exp)
---
> fold_builtin_memset (tree arglist, tree type, bool ignore)
6266,6267c7936,7937
< tree arglist = TREE_OPERAND (exp, 1);
< tree dest, src, len;
---
> tree dest, c, len, var, ret;
> unsigned HOST_WIDE_INT length, cval;
6270c7940
< POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
---
> POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
6274c7944
< src = TREE_VALUE (TREE_CHAIN (arglist));
---
> c = TREE_VALUE (TREE_CHAIN (arglist));
6276a7947,7949
> if (! host_integerp (len, 1))
> return 0;
>
6279c7952
< return omit_one_operand (TREE_TYPE (exp), dest, src);
---
> return omit_one_operand (type, dest, c);
6281,6283c7954,7955
< /* If SRC and DEST are the same (and not volatile), return DEST. */
< if (operand_equal_p (src, dest, 0))
< return omit_one_operand (TREE_TYPE (exp), dest, len);
---
> if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
> return 0;
6285c7957,8001
< return 0;
---
> var = dest;
> STRIP_NOPS (var);
> if (TREE_CODE (var) != ADDR_EXPR)
> return 0;
>
> var = TREE_OPERAND (var, 0);
> if (TREE_THIS_VOLATILE (var))
> return 0;
>
> if (!INTEGRAL_TYPE_P (TREE_TYPE (var))
> && !POINTER_TYPE_P (TREE_TYPE (var)))
> return 0;
>
> if (! var_decl_component_p (var))
> return 0;
>
> length = tree_low_cst (len, 1);
> if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (var))) != length
> || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
> < (int) length)
> return 0;
>
> if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
> return 0;
>
> if (integer_zerop (c))
> cval = 0;
> else
> {
> if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
> return 0;
>
> cval = tree_low_cst (c, 1);
> cval &= 0xff;
> cval |= cval << 8;
> cval |= cval << 16;
> cval |= (cval << 31) << 1;
> }
>
> ret = build_int_cst_type (TREE_TYPE (var), cval);
> ret = build2 (MODIFY_EXPR, TREE_TYPE (var), var, ret);
> if (ignore)
> return ret;
>
> return omit_one_operand (type, dest, ret);
6288c8004
< /* Fold function call to builtin mempcpy. Return
---
> /* Fold function call to builtin memset. Return
6292c8008
< fold_builtin_mempcpy (tree exp)
---
> fold_builtin_bzero (tree arglist, bool ignore)
6294,6295c8010
< tree arglist = TREE_OPERAND (exp, 1);
< tree dest, src, len;
---
> tree dest, size, newarglist;
6297,6298c8012
< if (!validate_arglist (arglist,
< POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
---
> if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6300a8015,8017
> if (!ignore)
> return 0;
>
6301a8019,8050
> size = TREE_VALUE (TREE_CHAIN (arglist));
>
> /* New argument list transforming bzero(ptr x, int y) to
> memset(ptr x, int 0, size_t y). This is done this way
> so that if it isn't expanded inline, we fallback to
> calling bzero instead of memset. */
>
> newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
> newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
> newarglist = tree_cons (NULL_TREE, dest, newarglist);
> return fold_builtin_memset (newarglist, void_type_node, ignore);
> }
>
> /* Fold function call to builtin mem{{,p}cpy,move}. Return
> NULL_TREE if no simplification can be made.
> If ENDP is 0, return DEST (like memcpy).
> If ENDP is 1, return DEST+LEN (like mempcpy).
> If ENDP is 2, return DEST+LEN-1 (like stpcpy).
> If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
> (memmove). */
>
> static tree
> fold_builtin_memory_op (tree arglist, tree type, bool ignore, int endp)
> {
> tree dest, src, len, destvar, srcvar, expr;
> unsigned HOST_WIDE_INT length;
>
> if (! validate_arglist (arglist,
> POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
6307c8056
< return omit_one_operand (TREE_TYPE (exp), dest, src);
---
> return omit_one_operand (type, dest, src);
6309c8058,8059
< /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
---
> /* If SRC and DEST are the same (and not volatile), return
> DEST{,+LEN,+LEN-1}. */
6310a8061,8062
> expr = len;
> else
6312,6314c8064,8120
< tree temp = convert (TREE_TYPE (dest), len);
< temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
< return convert (TREE_TYPE (exp), temp);
---
> if (! host_integerp (len, 1))
> return 0;
>
> if (TREE_SIDE_EFFECTS (dest) || TREE_SIDE_EFFECTS (src))
> return 0;
>
> destvar = dest;
> STRIP_NOPS (destvar);
> if (TREE_CODE (destvar) != ADDR_EXPR)
> return 0;
>
> destvar = TREE_OPERAND (destvar, 0);
> if (TREE_THIS_VOLATILE (destvar))
> return 0;
>
> if (!INTEGRAL_TYPE_P (TREE_TYPE (destvar))
> && !POINTER_TYPE_P (TREE_TYPE (destvar))
> && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (destvar)))
> return 0;
>
> if (! var_decl_component_p (destvar))
> return 0;
>
> srcvar = src;
> STRIP_NOPS (srcvar);
> if (TREE_CODE (srcvar) != ADDR_EXPR)
> return 0;
>
> srcvar = TREE_OPERAND (srcvar, 0);
> if (TREE_THIS_VOLATILE (srcvar))
> return 0;
>
> if (!INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
> && !POINTER_TYPE_P (TREE_TYPE (srcvar))
> && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (srcvar)))
> return 0;
>
> if (! var_decl_component_p (srcvar))
> return 0;
>
> length = tree_low_cst (len, 1);
> if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (destvar))) != length
> || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
> < (int) length
> || GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (srcvar))) != length
> || get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
> < (int) length)
> return 0;
>
> if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
> || POINTER_TYPE_P (TREE_TYPE (srcvar)))
> && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
> || POINTER_TYPE_P (TREE_TYPE (destvar))))
> expr = fold_convert (TREE_TYPE (destvar), srcvar);
> else
> expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
> expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
6317c8123,8141
< return 0;
---
> if (ignore)
> return expr;
>
> if (endp == 0 || endp == 3)
> return omit_one_operand (type, dest, expr);
>
> if (expr == len)
> expr = 0;
>
> if (endp == 2)
> len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
> ssize_int (1));
>
> len = fold_convert (TREE_TYPE (dest), len);
> dest = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
> dest = fold_convert (type, dest);
> if (expr)
> dest = omit_one_operand (type, dest, expr);
> return dest;
6320,6321c8144,8145
< /* Fold function call to builtin memmove. Return
< NULL_TREE if no simplification can be made. */
---
> /* Fold function call to builtin bcopy. Return NULL_TREE if no
> simplification can be made. */
6324c8148
< fold_builtin_memmove (tree exp)
---
> fold_builtin_bcopy (tree arglist, bool ignore)
6326,6327c8150
< tree arglist = TREE_OPERAND (exp, 1);
< tree dest, src, len;
---
> tree src, dest, size, newarglist;
6333,6335c8156,8157
< dest = TREE_VALUE (arglist);
< src = TREE_VALUE (TREE_CHAIN (arglist));
< len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
---
> if (! ignore)
> return 0;
6337,6339c8159,8161
< /* If the LEN parameter is zero, return DEST. */
< if (integer_zerop (len))
< return omit_one_operand (TREE_TYPE (exp), dest, src);
---
> src = TREE_VALUE (arglist);
> dest = TREE_VALUE (TREE_CHAIN (arglist));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
6341,6343c8163,8166
< /* If SRC and DEST are the same (and not volatile), return DEST. */
< if (operand_equal_p (src, dest, 0))
< return omit_one_operand (TREE_TYPE (exp), dest, len);
---
> /* New argument list transforming bcopy(ptr x, ptr y, int z) to
> memmove(ptr y, ptr x, size_t z). This is done this way
> so that if it isn't expanded inline, we fallback to
> calling bcopy instead of memmove. */
6345c8168,8172
< return 0;
---
> newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
> newarglist = tree_cons (NULL_TREE, src, newarglist);
> newarglist = tree_cons (NULL_TREE, dest, newarglist);
>
> return fold_builtin_memory_op (newarglist, void_type_node, true, /*endp=*/3);
6348,6349c8175,8177
< /* Fold function call to builtin strcpy. Return
< NULL_TREE if no simplification can be made. */
---
> /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
> the length of the string to be copied. Return NULL_TREE if no
> simplification can be made. */
6351,6352c8179,8180
< static tree
< fold_builtin_strcpy (tree exp)
---
> tree
> fold_builtin_strcpy (tree fndecl, tree arglist, tree len)
6354,6355c8182
< tree arglist = TREE_OPERAND (exp, 1);
< tree dest, src;
---
> tree dest, src, fn;
6366c8193
< return convert (TREE_TYPE (exp), dest);
---
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
6368c8195,8214
< return 0;
---
> if (optimize_size)
> return 0;
>
> fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
> if (!fn)
> return 0;
>
> if (!len)
> {
> len = c_strlen (src, 1);
> if (! len || TREE_SIDE_EFFECTS (len))
> return 0;
> }
>
> len = size_binop (PLUS_EXPR, len, ssize_int (1));
> arglist = build_tree_list (NULL_TREE, len);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
> build_function_call_expr (fn, arglist));
6371,6372c8217,8219
< /* Fold function call to builtin strncpy. Return
< NULL_TREE if no simplification can be made. */
---
> /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
> the length of the source string. Return NULL_TREE if no simplification
> can be made. */
6374,6375c8221,8222
< static tree
< fold_builtin_strncpy (tree exp)
---
> tree
> fold_builtin_strncpy (tree fndecl, tree arglist, tree slen)
6377,6378c8224
< tree arglist = TREE_OPERAND (exp, 1);
< tree dest, src, len;
---
> tree dest, src, len, fn;
6390c8236
< return omit_one_operand (TREE_TYPE (exp), dest, src);
---
> return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
6392c8238,8263
< return 0;
---
> /* We can't compare slen with len as constants below if len is not a
> constant. */
> if (len == 0 || TREE_CODE (len) != INTEGER_CST)
> return 0;
>
> if (!slen)
> slen = c_strlen (src, 1);
>
> /* Now, we must be passed a constant src ptr parameter. */
> if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
> return 0;
>
> slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
>
> /* We do not support simplification of this case, though we do
> support it when expanding trees into RTL. */
> /* FIXME: generate a call to __builtin_memset. */
> if (tree_int_cst_lt (slen, len))
> return 0;
>
> /* OK transform into builtin memcpy. */
> fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
> if (!fn)
> return 0;
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
> build_function_call_expr (fn, arglist));
6399c8270
< fold_builtin_memcmp (tree exp)
---
> fold_builtin_memcmp (tree arglist)
6401d8271
< tree arglist = TREE_OPERAND (exp, 1);
6402a8273
> const char *p1, *p2;
6414,6417c8285,8286
< {
< tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
< return omit_one_operand (TREE_TYPE (exp), temp, arg1);
< }
---
> return omit_two_operands (integer_type_node, integer_zero_node,
> arg1, arg2);
6421c8290
< return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
---
> return omit_one_operand (integer_type_node, integer_zero_node, len);
6422a8292,8329
> p1 = c_getstr (arg1);
> p2 = c_getstr (arg2);
>
> /* If all arguments are constant, and the value of len is not greater
> than the lengths of arg1 and arg2, evaluate at compile-time. */
> if (host_integerp (len, 1) && p1 && p2
> && compare_tree_int (len, strlen (p1) + 1) <= 0
> && compare_tree_int (len, strlen (p2) + 1) <= 0)
> {
> const int r = memcmp (p1, p2, tree_low_cst (len, 1));
>
> if (r > 0)
> return integer_one_node;
> else if (r < 0)
> return integer_minus_one_node;
> else
> return integer_zero_node;
> }
>
> /* If len parameter is one, return an expression corresponding to
> (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
> if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> tree ind1 = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg1)));
> tree ind2 = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg2)));
> return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
> }
>
6430c8337
< fold_builtin_strcmp (tree exp)
---
> fold_builtin_strcmp (tree arglist)
6432d8338
< tree arglist = TREE_OPERAND (exp, 1);
6436,6437c8342
< if (!validate_arglist (arglist,
< POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
---
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6445c8350
< return convert (TREE_TYPE (exp), integer_zero_node);
---
> return integer_zero_node;
6452d8356
< tree temp;
6455c8359
< temp = integer_minus_one_node;
---
> return integer_minus_one_node;
6457c8361
< temp = integer_one_node;
---
> return integer_one_node;
6459,6460c8363
< temp = integer_zero_node;
< return convert (TREE_TYPE (exp), temp);
---
> return integer_zero_node;
6462a8366,8392
> /* If the second arg is "", return *(const unsigned char*)arg1. */
> if (p2 && *p2 == '\0')
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> return fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg1)));
> }
>
> /* If the first arg is "", return -*(const unsigned char*)arg2. */
> if (p1 && *p1 == '\0')
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> tree temp = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg2)));
> return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
> }
>
6470c8400
< fold_builtin_strncmp (tree exp)
---
> fold_builtin_strncmp (tree arglist)
6472d8401
< tree arglist = TREE_OPERAND (exp, 1);
6486,6489c8415,8416
< {
< tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
< return omit_one_operand (TREE_TYPE (exp), temp, arg1);
< }
---
> return omit_two_operands (integer_type_node, integer_zero_node,
> arg1, arg2);
6493c8420
< return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
---
> return omit_one_operand (integer_type_node, integer_zero_node, len);
6500d8426
< tree temp;
6502,6505c8428,8431
< if (i < 0)
< temp = integer_minus_one_node;
< else if (i > 0)
< temp = integer_one_node;
---
> if (i > 0)
> return integer_one_node;
> else if (i < 0)
> return integer_minus_one_node;
6507,6508c8433
< temp = integer_zero_node;
< return convert (TREE_TYPE (exp), temp);
---
> return integer_zero_node;
6510a8436,8487
> /* If the second arg is "", and the length is greater than zero,
> return *(const unsigned char*)arg1. */
> if (p2 && *p2 == '\0'
> && TREE_CODE (len) == INTEGER_CST
> && tree_int_cst_sgn (len) == 1)
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> return fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg1)));
> }
>
> /* If the first arg is "", and the length is greater than zero,
> return -*(const unsigned char*)arg2. */
> if (p1 && *p1 == '\0'
> && TREE_CODE (len) == INTEGER_CST
> && tree_int_cst_sgn (len) == 1)
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> tree temp = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg2)));
> return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
> }
>
> /* If len parameter is one, return an expression corresponding to
> (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
> if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
> {
> tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
> tree cst_uchar_ptr_node
> = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
>
> tree ind1 = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg1)));
> tree ind2 = fold_convert (integer_type_node,
> build1 (INDIRECT_REF, cst_uchar_node,
> fold_convert (cst_uchar_ptr_node,
> arg2)));
> return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
> }
>
6514,6515c8491,8492
< /* Used by constant folding to eliminate some builtin calls early. EXP is
< the CALL_EXPR of a call to a builtin function. */
---
> /* Fold function call to builtin signbit, signbitf or signbitl. Return
> NULL_TREE if no simplification can be made. */
6517,6518c8494,8495
< tree
< fold_builtin (tree exp)
---
> static tree
> fold_builtin_signbit (tree fndecl, tree arglist)
6520,6521d8496
< tree fndecl = get_callee_fndecl (exp);
< tree arglist = TREE_OPERAND (exp, 1);
6522a8498
> tree arg, temp;
6524c8500,8584
< if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
---
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> arg = TREE_VALUE (arglist);
>
> /* If ARG is a compile-time constant, determine the result. */
> if (TREE_CODE (arg) == REAL_CST
> && !TREE_CONSTANT_OVERFLOW (arg))
> {
> REAL_VALUE_TYPE c;
>
> c = TREE_REAL_CST (arg);
> temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
> return fold_convert (type, temp);
> }
>
> /* If ARG is non-negative, the result is always zero. */
> if (tree_expr_nonnegative_p (arg))
> return omit_one_operand (type, integer_zero_node, arg);
>
> /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
> if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
> return fold_build2 (LT_EXPR, type, arg,
> build_real (TREE_TYPE (arg), dconst0));
>
> return NULL_TREE;
> }
>
> /* Fold function call to builtin copysign, copysignf or copysignl.
> Return NULL_TREE if no simplification can be made. */
>
> static tree
> fold_builtin_copysign (tree fndecl, tree arglist, tree type)
> {
> tree arg1, arg2, tem;
>
> if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
> return NULL_TREE;
>
> arg1 = TREE_VALUE (arglist);
> arg2 = TREE_VALUE (TREE_CHAIN (arglist));
>
> /* copysign(X,X) is X. */
> if (operand_equal_p (arg1, arg2, 0))
> return fold_convert (type, arg1);
>
> /* If ARG1 and ARG2 are compile-time constants, determine the result. */
> if (TREE_CODE (arg1) == REAL_CST
> && TREE_CODE (arg2) == REAL_CST
> && !TREE_CONSTANT_OVERFLOW (arg1)
> && !TREE_CONSTANT_OVERFLOW (arg2))
> {
> REAL_VALUE_TYPE c1, c2;
>
> c1 = TREE_REAL_CST (arg1);
> c2 = TREE_REAL_CST (arg2);
> /* c1.sign := c2.sign. */
> real_copysign (&c1, &c2);
> return build_real (type, c1);
> }
>
> /* copysign(X, Y) is fabs(X) when Y is always non-negative.
> Remember to evaluate Y for side-effects. */
> if (tree_expr_nonnegative_p (arg2))
> return omit_one_operand (type,
> fold_build1 (ABS_EXPR, type, arg1),
> arg2);
>
> /* Strip sign changing operations for the first argument. */
> tem = fold_strip_sign_ops (arg1);
> if (tem)
> {
> arglist = tree_cons (NULL_TREE, tem, TREE_CHAIN (arglist));
> return build_function_call_expr (fndecl, arglist);
> }
>
> return NULL_TREE;
> }
>
> /* Fold a call to builtin isascii. */
>
> static tree
> fold_builtin_isascii (tree arglist)
> {
> if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
6525a8586,8589
> else
> {
> /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
> tree arg = TREE_VALUE (arglist);
6527c8591,8611
< switch (DECL_FUNCTION_CODE (fndecl))
---
> arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
> build_int_cst (NULL_TREE,
> ~ (unsigned HOST_WIDE_INT) 0x7f));
> arg = fold_build2 (EQ_EXPR, integer_type_node,
> arg, integer_zero_node);
>
> if (in_gimple_form && !TREE_CONSTANT (arg))
> return NULL_TREE;
> else
> return arg;
> }
> }
>
> /* Fold a call to builtin toascii. */
>
> static tree
> fold_builtin_toascii (tree arglist)
> {
> if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
> return 0;
> else
6529,6530c8613,8614
< case BUILT_IN_CONSTANT_P:
< return fold_builtin_constant_p (arglist);
---
> /* Transform toascii(c) -> (c & 0x7f). */
> tree arg = TREE_VALUE (arglist);
6532,6533c8616,8619
< case BUILT_IN_CLASSIFY_TYPE:
< return fold_builtin_classify_type (arglist);
---
> return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
> build_int_cst (NULL_TREE, 0x7f));
> }
> }
6535,6547c8621
< case BUILT_IN_STRLEN:
< if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
< {
< tree len = c_strlen (TREE_VALUE (arglist), 0);
< if (len)
< {
< /* Convert from the internal "sizetype" type to "size_t". */
< if (size_type_node)
< len = convert (size_type_node, len);
< return len;
< }
< }
< break;
---
> /* Fold a call to builtin isdigit. */
6549,6554c8623,8635
< case BUILT_IN_FABS:
< case BUILT_IN_FABSF:
< case BUILT_IN_FABSL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
< return fold (build1 (ABS_EXPR, type, TREE_VALUE (arglist)));
< break;
---
> static tree
> fold_builtin_isdigit (tree arglist)
> {
> if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
> /* According to the C standard, isdigit is unaffected by locale.
> However, it definitely is affected by the target character set. */
> tree arg;
> unsigned HOST_WIDE_INT target_digit0
> = lang_hooks.to_target_charset ('0');
6556,6559c8637,8638
< case BUILT_IN_CABS:
< case BUILT_IN_CABSF:
< case BUILT_IN_CABSL:
< return fold_builtin_cabs (fndecl, arglist, type);
---
> if (target_digit0 == 0)
> return NULL_TREE;
6561,6567c8640,8650
< case BUILT_IN_SQRT:
< case BUILT_IN_SQRTF:
< case BUILT_IN_SQRTL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
< {
< enum built_in_function fcode;
< tree arg = TREE_VALUE (arglist);
---
> arg = fold_convert (unsigned_type_node, TREE_VALUE (arglist));
> arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
> build_int_cst (unsigned_type_node, target_digit0));
> arg = fold_build2 (LE_EXPR, integer_type_node, arg,
> build_int_cst (unsigned_type_node, 9));
> if (in_gimple_form && !TREE_CONSTANT (arg))
> return NULL_TREE;
> else
> return arg;
> }
> }
6569,6573c8652
< /* Optimize sqrt of constant value. */
< if (TREE_CODE (arg) == REAL_CST
< && ! TREE_CONSTANT_OVERFLOW (arg))
< {
< REAL_VALUE_TYPE r, x;
---
> /* Fold a call to fabs, fabsf or fabsl. */
6575,6579c8654,8657
< x = TREE_REAL_CST (arg);
< if (real_sqrt (&r, TYPE_MODE (type), &x)
< || (!flag_trapping_math && !flag_errno_math))
< return build_real (type, r);
< }
---
> static tree
> fold_builtin_fabs (tree arglist, tree type)
> {
> tree arg;
6581,6594c8659,8660
< /* Optimize sqrt(exp(x)) = exp(x*0.5). */
< fcode = builtin_mathfn_code (arg);
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_EXP
< || fcode == BUILT_IN_EXPF
< || fcode == BUILT_IN_EXPL))
< {
< tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
< arg = fold (build (MULT_EXPR, type,
< TREE_VALUE (TREE_OPERAND (arg, 1)),
< build_real (type, dconsthalf)));
< arglist = build_tree_list (NULL_TREE, arg);
< return build_function_call_expr (expfn, arglist);
< }
---
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> return 0;
6596,6615c8662,8667
< /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_POW
< || fcode == BUILT_IN_POWF
< || fcode == BUILT_IN_POWL))
< {
< tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
< tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
< tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
< tree narg1;
< if (!tree_expr_nonnegative_p (arg0))
< arg0 = build1 (ABS_EXPR, type, arg0);
< narg1 = fold (build (MULT_EXPR, type, arg1,
< build_real (type, dconsthalf)));
< arglist = tree_cons (NULL_TREE, arg0,
< build_tree_list (NULL_TREE, narg1));
< return build_function_call_expr (powfn, arglist);
< }
< }
< break;
---
> arg = TREE_VALUE (arglist);
> arg = fold_convert (type, arg);
> if (TREE_CODE (arg) == REAL_CST)
> return fold_abs_const (arg, type);
> return fold_build1 (ABS_EXPR, type, arg);
> }
6617,6622c8669
< case BUILT_IN_SIN:
< case BUILT_IN_SINF:
< case BUILT_IN_SINL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
< {
< tree arg = TREE_VALUE (arglist);
---
> /* Fold a call to abs, labs, llabs or imaxabs. */
6624,6628c8671,8674
< /* Optimize sin(0.0) = 0.0. */
< if (real_zerop (arg))
< return arg;
< }
< break;
---
> static tree
> fold_builtin_abs (tree arglist, tree type)
> {
> tree arg;
6630,6635c8676,8677
< case BUILT_IN_COS:
< case BUILT_IN_COSF:
< case BUILT_IN_COSL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
< {
< tree arg = TREE_VALUE (arglist);
---
> if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
> return 0;
6637,6639c8679,8684
< /* Optimize cos(0.0) = 1.0. */
< if (real_zerop (arg))
< return build_real (type, dconst1);
---
> arg = TREE_VALUE (arglist);
> arg = fold_convert (type, arg);
> if (TREE_CODE (arg) == INTEGER_CST)
> return fold_abs_const (arg, type);
> return fold_build1 (ABS_EXPR, type, arg);
> }
6641,6649c8686,8687
< /* Optimize cos(-x) into cos(x). */
< if (TREE_CODE (arg) == NEGATE_EXPR)
< {
< tree arglist = build_tree_list (NULL_TREE,
< TREE_OPERAND (arg, 0));
< return build_function_call_expr (fndecl, arglist);
< }
< }
< break;
---
> /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
> EXP is the CALL_EXPR for the call. */
6651,6680c8689,8694
< case BUILT_IN_EXP:
< case BUILT_IN_EXPF:
< case BUILT_IN_EXPL:
< return fold_builtin_exponent (exp, &dconste);
< case BUILT_IN_EXP2:
< case BUILT_IN_EXP2F:
< case BUILT_IN_EXP2L:
< return fold_builtin_exponent (exp, &dconst2);
< case BUILT_IN_EXP10:
< case BUILT_IN_EXP10F:
< case BUILT_IN_EXP10L:
< case BUILT_IN_POW10:
< case BUILT_IN_POW10F:
< case BUILT_IN_POW10L:
< return fold_builtin_exponent (exp, &dconst10);
< case BUILT_IN_LOG:
< case BUILT_IN_LOGF:
< case BUILT_IN_LOGL:
< return fold_builtin_logarithm (exp, &dconste);
< break;
< case BUILT_IN_LOG2:
< case BUILT_IN_LOG2F:
< case BUILT_IN_LOG2L:
< return fold_builtin_logarithm (exp, &dconst2);
< break;
< case BUILT_IN_LOG10:
< case BUILT_IN_LOG10F:
< case BUILT_IN_LOG10L:
< return fold_builtin_logarithm (exp, &dconst10);
< break;
---
> static tree
> fold_builtin_classify (tree fndecl, tree arglist, int builtin_index)
> {
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
> tree arg;
> REAL_VALUE_TYPE r;
6682,6685c8696,8699
< case BUILT_IN_TAN:
< case BUILT_IN_TANF:
< case BUILT_IN_TANL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
---
> if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
> {
> /* Check that we have exactly one argument. */
> if (arglist == 0)
6687,6688c8701,8717
< enum built_in_function fcode;
< tree arg = TREE_VALUE (arglist);
---
> error ("too few arguments to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
> else if (TREE_CHAIN (arglist) != 0)
> {
> error ("too many arguments to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
> else
> {
> error ("non-floating-point argument to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
> }
6690,6692c8719,8724
< /* Optimize tan(0.0) = 0.0. */
< if (real_zerop (arg))
< return arg;
---
> arg = TREE_VALUE (arglist);
> switch (builtin_index)
> {
> case BUILT_IN_ISINF:
> if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
> return omit_one_operand (type, integer_zero_node, arg);
6694,6700c8726,8733
< /* Optimize tan(atan(x)) = x. */
< fcode = builtin_mathfn_code (arg);
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_ATAN
< || fcode == BUILT_IN_ATANF
< || fcode == BUILT_IN_ATANL))
< return TREE_VALUE (TREE_OPERAND (arg, 1));
---
> if (TREE_CODE (arg) == REAL_CST)
> {
> r = TREE_REAL_CST (arg);
> if (real_isinf (&r))
> return real_compare (GT_EXPR, &r, &dconst0)
> ? integer_one_node : integer_minus_one_node;
> else
> return integer_zero_node;
6702d8734
< break;
6704,6707c8736,8743
< case BUILT_IN_ATAN:
< case BUILT_IN_ATANF:
< case BUILT_IN_ATANL:
< if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
---
> return NULL_TREE;
>
> case BUILT_IN_FINITE:
> if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg)))
> && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
> return omit_one_operand (type, integer_zero_node, arg);
>
> if (TREE_CODE (arg) == REAL_CST)
6709c8745,8748
< tree arg = TREE_VALUE (arglist);
---
> r = TREE_REAL_CST (arg);
> return real_isinf (&r) || real_isnan (&r)
> ? integer_zero_node : integer_one_node;
> }
6711,6713c8750
< /* Optimize atan(0.0) = 0.0. */
< if (real_zerop (arg))
< return arg;
---
> return NULL_TREE;
6715,6718c8752,8754
< /* Optimize atan(1.0) = pi/4. */
< if (real_onep (arg))
< {
< REAL_VALUE_TYPE cst;
---
> case BUILT_IN_ISNAN:
> if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg))))
> return omit_one_operand (type, integer_zero_node, arg);
6720,6723c8756,8759
< real_convert (&cst, TYPE_MODE (type), &dconstpi);
< cst.exp -= 2;
< return build_real (type, cst);
< }
---
> if (TREE_CODE (arg) == REAL_CST)
> {
> r = TREE_REAL_CST (arg);
> return real_isnan (&r) ? integer_one_node : integer_zero_node;
6725d8760
< break;
6727,6730c8762,8793
< case BUILT_IN_POW:
< case BUILT_IN_POWF:
< case BUILT_IN_POWL:
< if (validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
---
> arg = builtin_save_expr (arg);
> return fold_build2 (UNORDERED_EXPR, type, arg, arg);
>
> default:
> gcc_unreachable ();
> }
> }
>
> /* Fold a call to an unordered comparison function such as
> __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
> being called and ARGLIST is the argument list for the call.
> UNORDERED_CODE and ORDERED_CODE are comparison codes that give
> the opposite of the desired result. UNORDERED_CODE is used
> for modes that can hold NaNs and ORDERED_CODE is used for
> the rest. */
>
> static tree
> fold_builtin_unordered_cmp (tree fndecl, tree arglist,
> enum tree_code unordered_code,
> enum tree_code ordered_code)
> {
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
> enum tree_code code;
> tree arg0, arg1;
> tree type0, type1;
> enum tree_code code0, code1;
> tree cmp_type = NULL_TREE;
>
> if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
> {
> /* Check that we have exactly two arguments. */
> if (arglist == 0 || TREE_CHAIN (arglist) == 0)
6732,6734c8795,8805
< enum built_in_function fcode;
< tree arg0 = TREE_VALUE (arglist);
< tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
---
> error ("too few arguments to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
> else if (TREE_CHAIN (TREE_CHAIN (arglist)) != 0)
> {
> error ("too many arguments to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
> }
6736,6738c8807,8808
< /* Optimize pow(1.0,y) = 1.0. */
< if (real_onep (arg0))
< return omit_one_operand (type, build_real (type, dconst1), arg1);
---
> arg0 = TREE_VALUE (arglist);
> arg1 = TREE_VALUE (TREE_CHAIN (arglist));
6740,6744c8810,8811
< if (TREE_CODE (arg1) == REAL_CST
< && ! TREE_CONSTANT_OVERFLOW (arg1))
< {
< REAL_VALUE_TYPE c;
< c = TREE_REAL_CST (arg1);
---
> type0 = TREE_TYPE (arg0);
> type1 = TREE_TYPE (arg1);
6746,6749c8813,8814
< /* Optimize pow(x,0.0) = 1.0. */
< if (REAL_VALUES_EQUAL (c, dconst0))
< return omit_one_operand (type, build_real (type, dconst1),
< arg0);
---
> code0 = TREE_CODE (type0);
> code1 = TREE_CODE (type1);
6751,6753c8816,8829
< /* Optimize pow(x,1.0) = x. */
< if (REAL_VALUES_EQUAL (c, dconst1))
< return arg0;
---
> if (code0 == REAL_TYPE && code1 == REAL_TYPE)
> /* Choose the wider of two real types. */
> cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
> ? type0 : type1;
> else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
> cmp_type = type0;
> else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
> cmp_type = type1;
> else
> {
> error ("non-floating-point argument to function %qs",
> IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> return error_mark_node;
> }
6755,6759c8831,8832
< /* Optimize pow(x,-1.0) = 1.0/x. */
< if (REAL_VALUES_EQUAL (c, dconstm1))
< return fold (build (RDIV_EXPR, type,
< build_real (type, dconst1),
< arg0));
---
> arg0 = fold_convert (cmp_type, arg0);
> arg1 = fold_convert (cmp_type, arg1);
6761,6765c8834,8839
< /* Optimize pow(x,0.5) = sqrt(x). */
< if (flag_unsafe_math_optimizations
< && REAL_VALUES_EQUAL (c, dconsthalf))
< {
< tree sqrtfn;
---
> if (unordered_code == UNORDERED_EXPR)
> {
> if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))))
> return omit_two_operands (type, integer_zero_node, arg0, arg1);
> return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
> }
6767,6775c8841,8845
< fcode = DECL_FUNCTION_CODE (fndecl);
< if (fcode == BUILT_IN_POW)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRT];
< else if (fcode == BUILT_IN_POWF)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTF];
< else if (fcode == BUILT_IN_POWL)
< sqrtfn = implicit_built_in_decls[BUILT_IN_SQRTL];
< else
< sqrtfn = NULL_TREE;
---
> code = MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
> : ordered_code;
> return fold_build1 (TRUTH_NOT_EXPR, type,
> fold_build2 (code, type, arg0, arg1));
> }
6777,6782c8847,8850
< if (sqrtfn != NULL_TREE)
< {
< tree arglist = build_tree_list (NULL_TREE, arg0);
< return build_function_call_expr (sqrtfn, arglist);
< }
< }
---
> /* Used by constant folding to simplify calls to builtin functions. EXP is
> the CALL_EXPR of a call to a builtin function. IGNORE is true if the
> result of the function call is ignored. This function returns NULL_TREE
> if no simplification was possible. */
6784,6789c8852,8856
< /* Attempt to evaluate pow at compile-time. */
< if (TREE_CODE (arg0) == REAL_CST
< && ! TREE_CONSTANT_OVERFLOW (arg0))
< {
< REAL_VALUE_TYPE cint;
< HOST_WIDE_INT n;
---
> static tree
> fold_builtin_1 (tree fndecl, tree arglist, bool ignore)
> {
> tree type = TREE_TYPE (TREE_TYPE (fndecl));
> enum built_in_function fcode;
6791,6797c8858,8859
< n = real_to_integer (&c);
< real_from_integer (&cint, VOIDmode, n,
< n < 0 ? -1 : 0, 0);
< if (real_identical (&c, &cint))
< {
< REAL_VALUE_TYPE x;
< bool inexact;
---
> if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
> return targetm.fold_builtin (fndecl, arglist, ignore);
6799,6805c8861,8865
< x = TREE_REAL_CST (arg0);
< inexact = real_powi (&x, TYPE_MODE (type), &x, n);
< if (flag_unsafe_math_optimizations || !inexact)
< return build_real (type, x);
< }
< }
< }
---
> fcode = DECL_FUNCTION_CODE (fndecl);
> switch (fcode)
> {
> case BUILT_IN_FPUTS:
> return fold_builtin_fputs (arglist, ignore, false, NULL_TREE);
6807,6819c8867,8868
< /* Optimize pow(exp(x),y) = exp(x*y). */
< fcode = builtin_mathfn_code (arg0);
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_EXP
< || fcode == BUILT_IN_EXPF
< || fcode == BUILT_IN_EXPL))
< {
< tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
< tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
< arg = fold (build (MULT_EXPR, type, arg, arg1));
< arglist = build_tree_list (NULL_TREE, arg);
< return build_function_call_expr (expfn, arglist);
< }
---
> case BUILT_IN_FPUTS_UNLOCKED:
> return fold_builtin_fputs (arglist, ignore, true, NULL_TREE);
6821,6829c8870,8871
< /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_SQRT
< || fcode == BUILT_IN_SQRTF
< || fcode == BUILT_IN_SQRTL))
< {
< tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
< tree narg1 = fold (build (MULT_EXPR, type, arg1,
< build_real (type, dconsthalf)));
---
> case BUILT_IN_STRSTR:
> return fold_builtin_strstr (arglist, type);
6831,6834c8873,8874
< arglist = tree_cons (NULL_TREE, narg0,
< build_tree_list (NULL_TREE, narg1));
< return build_function_call_expr (fndecl, arglist);
< }
---
> case BUILT_IN_STRCAT:
> return fold_builtin_strcat (arglist);
6836,6849c8876,8949
< /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
< if (flag_unsafe_math_optimizations
< && (fcode == BUILT_IN_POW
< || fcode == BUILT_IN_POWF
< || fcode == BUILT_IN_POWL))
< {
< tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
< tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
< tree narg1 = fold (build (MULT_EXPR, type, arg01, arg1));
< arglist = tree_cons (NULL_TREE, arg00,
< build_tree_list (NULL_TREE, narg1));
< return build_function_call_expr (fndecl, arglist);
< }
< }
---
> case BUILT_IN_STRNCAT:
> return fold_builtin_strncat (arglist);
>
> case BUILT_IN_STRSPN:
> return fold_builtin_strspn (arglist);
>
> case BUILT_IN_STRCSPN:
> return fold_builtin_strcspn (arglist);
>
> case BUILT_IN_STRCHR:
> case BUILT_IN_INDEX:
> return fold_builtin_strchr (arglist, type);
>
> case BUILT_IN_STRRCHR:
> case BUILT_IN_RINDEX:
> return fold_builtin_strrchr (arglist, type);
>
> case BUILT_IN_STRCPY:
> return fold_builtin_strcpy (fndecl, arglist, NULL_TREE);
>
> case BUILT_IN_STRNCPY:
> return fold_builtin_strncpy (fndecl, arglist, NULL_TREE);
>
> case BUILT_IN_STRCMP:
> return fold_builtin_strcmp (arglist);
>
> case BUILT_IN_STRNCMP:
> return fold_builtin_strncmp (arglist);
>
> case BUILT_IN_STRPBRK:
> return fold_builtin_strpbrk (arglist, type);
>
> case BUILT_IN_BCMP:
> case BUILT_IN_MEMCMP:
> return fold_builtin_memcmp (arglist);
>
> case BUILT_IN_SPRINTF:
> return fold_builtin_sprintf (arglist, ignore);
>
> case BUILT_IN_CONSTANT_P:
> {
> tree val;
>
> val = fold_builtin_constant_p (arglist);
> /* Gimplification will pull the CALL_EXPR for the builtin out of
> an if condition. When not optimizing, we'll not CSE it back.
> To avoid link error types of regressions, return false now. */
> if (!val && !optimize)
> val = integer_zero_node;
>
> return val;
> }
>
> case BUILT_IN_EXPECT:
> return fold_builtin_expect (arglist);
>
> case BUILT_IN_CLASSIFY_TYPE:
> return fold_builtin_classify_type (arglist);
>
> case BUILT_IN_STRLEN:
> return fold_builtin_strlen (arglist);
>
> CASE_FLT_FN (BUILT_IN_FABS):
> return fold_builtin_fabs (arglist, type);
>
> case BUILT_IN_ABS:
> case BUILT_IN_LABS:
> case BUILT_IN_LLABS:
> case BUILT_IN_IMAXABS:
> return fold_builtin_abs (arglist, type);
>
> CASE_FLT_FN (BUILT_IN_CONJ):
> if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
> return fold_build1 (CONJ_EXPR, type, TREE_VALUE (arglist));
6852,6854c8952,9013
< case BUILT_IN_INF:
< case BUILT_IN_INFF:
< case BUILT_IN_INFL:
---
> CASE_FLT_FN (BUILT_IN_CREAL):
> if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
> return non_lvalue (fold_build1 (REALPART_EXPR, type,
> TREE_VALUE (arglist)));
> break;
>
> CASE_FLT_FN (BUILT_IN_CIMAG):
> if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
> return non_lvalue (fold_build1 (IMAGPART_EXPR, type,
> TREE_VALUE (arglist)));
> break;
>
> CASE_FLT_FN (BUILT_IN_CABS):
> return fold_builtin_cabs (arglist, type, fndecl);
>
> CASE_FLT_FN (BUILT_IN_SQRT):
> return fold_builtin_sqrt (arglist, type);
>
> CASE_FLT_FN (BUILT_IN_CBRT):
> return fold_builtin_cbrt (arglist, type);
>
> CASE_FLT_FN (BUILT_IN_SIN):
> return fold_builtin_sin (arglist);
>
> CASE_FLT_FN (BUILT_IN_COS):
> return fold_builtin_cos (arglist, type, fndecl);
>
> CASE_FLT_FN (BUILT_IN_EXP):
> return fold_builtin_exponent (fndecl, arglist, &dconste);
>
> CASE_FLT_FN (BUILT_IN_EXP2):
> return fold_builtin_exponent (fndecl, arglist, &dconst2);
>
> CASE_FLT_FN (BUILT_IN_EXP10):
> CASE_FLT_FN (BUILT_IN_POW10):
> return fold_builtin_exponent (fndecl, arglist, &dconst10);
>
> CASE_FLT_FN (BUILT_IN_LOG):
> return fold_builtin_logarithm (fndecl, arglist, &dconste);
>
> CASE_FLT_FN (BUILT_IN_LOG2):
> return fold_builtin_logarithm (fndecl, arglist, &dconst2);
>
> CASE_FLT_FN (BUILT_IN_LOG10):
> return fold_builtin_logarithm (fndecl, arglist, &dconst10);
>
> CASE_FLT_FN (BUILT_IN_TAN):
> return fold_builtin_tan (arglist);
>
> CASE_FLT_FN (BUILT_IN_ATAN):
> return fold_builtin_atan (arglist, type);
>
> CASE_FLT_FN (BUILT_IN_POW):
> return fold_builtin_pow (fndecl, arglist, type);
>
> CASE_FLT_FN (BUILT_IN_POWI):
> return fold_builtin_powi (fndecl, arglist, type);
>
> CASE_FLT_FN (BUILT_IN_INF):
> case BUILT_IN_INFD32:
> case BUILT_IN_INFD64:
> case BUILT_IN_INFD128:
6857,6859c9016
< case BUILT_IN_HUGE_VAL:
< case BUILT_IN_HUGE_VALF:
< case BUILT_IN_HUGE_VALL:
---
> CASE_FLT_FN (BUILT_IN_HUGE_VAL):
6862,6864c9019,9022
< case BUILT_IN_NAN:
< case BUILT_IN_NANF:
< case BUILT_IN_NANL:
---
> CASE_FLT_FN (BUILT_IN_NAN):
> case BUILT_IN_NAND32:
> case BUILT_IN_NAND64:
> case BUILT_IN_NAND128:
6867,6869c9025
< case BUILT_IN_NANS:
< case BUILT_IN_NANSF:
< case BUILT_IN_NANSL:
---
> CASE_FLT_FN (BUILT_IN_NANS):
6872,6875c9028,9029
< case BUILT_IN_FLOOR:
< case BUILT_IN_FLOORF:
< case BUILT_IN_FLOORL:
< return fold_builtin_floor (exp);
---
> CASE_FLT_FN (BUILT_IN_FLOOR):
> return fold_builtin_floor (fndecl, arglist);
6877,6880c9031,9032
< case BUILT_IN_CEIL:
< case BUILT_IN_CEILF:
< case BUILT_IN_CEILL:
< return fold_builtin_ceil (exp);
---
> CASE_FLT_FN (BUILT_IN_CEIL):
> return fold_builtin_ceil (fndecl, arglist);
6882,6885c9034,9035
< case BUILT_IN_TRUNC:
< case BUILT_IN_TRUNCF:
< case BUILT_IN_TRUNCL:
< return fold_builtin_trunc (exp);
---
> CASE_FLT_FN (BUILT_IN_TRUNC):
> return fold_builtin_trunc (fndecl, arglist);
6887,6893c9037,9038
< case BUILT_IN_ROUND:
< case BUILT_IN_ROUNDF:
< case BUILT_IN_ROUNDL:
< case BUILT_IN_NEARBYINT:
< case BUILT_IN_NEARBYINTF:
< case BUILT_IN_NEARBYINTL:
< return fold_trunc_transparent_mathfn (exp);
---
> CASE_FLT_FN (BUILT_IN_ROUND):
> return fold_builtin_round (fndecl, arglist);
6895,6910c9040,9042
< case BUILT_IN_FFS:
< case BUILT_IN_FFSL:
< case BUILT_IN_FFSLL:
< case BUILT_IN_CLZ:
< case BUILT_IN_CLZL:
< case BUILT_IN_CLZLL:
< case BUILT_IN_CTZ:
< case BUILT_IN_CTZL:
< case BUILT_IN_CTZLL:
< case BUILT_IN_POPCOUNT:
< case BUILT_IN_POPCOUNTL:
< case BUILT_IN_POPCOUNTLL:
< case BUILT_IN_PARITY:
< case BUILT_IN_PARITYL:
< case BUILT_IN_PARITYLL:
< return fold_builtin_bitop (exp);
---
> CASE_FLT_FN (BUILT_IN_NEARBYINT):
> CASE_FLT_FN (BUILT_IN_RINT):
> return fold_trunc_transparent_mathfn (fndecl, arglist);
6911a9044,9065
> CASE_FLT_FN (BUILT_IN_LCEIL):
> CASE_FLT_FN (BUILT_IN_LLCEIL):
> CASE_FLT_FN (BUILT_IN_LFLOOR):
> CASE_FLT_FN (BUILT_IN_LLFLOOR):
> CASE_FLT_FN (BUILT_IN_LROUND):
> CASE_FLT_FN (BUILT_IN_LLROUND):
> return fold_builtin_int_roundingfn (fndecl, arglist);
>
> CASE_FLT_FN (BUILT_IN_LRINT):
> CASE_FLT_FN (BUILT_IN_LLRINT):
> return fold_fixed_mathfn (fndecl, arglist);
>
> CASE_INT_FN (BUILT_IN_FFS):
> CASE_INT_FN (BUILT_IN_CLZ):
> CASE_INT_FN (BUILT_IN_CTZ):
> CASE_INT_FN (BUILT_IN_POPCOUNT):
> CASE_INT_FN (BUILT_IN_PARITY):
> return fold_builtin_bitop (fndecl, arglist);
>
> case BUILT_IN_MEMSET:
> return fold_builtin_memset (arglist, type, ignore);
>
6913c9067
< return fold_builtin_memcpy (exp);
---
> return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/0);
6916c9070
< return fold_builtin_mempcpy (exp);
---
> return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/1);
6919c9073
< return fold_builtin_memmove (exp);
---
> return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/3);
6921,6922c9075,9076
< case BUILT_IN_STRCPY:
< return fold_builtin_strcpy (exp);
---
> case BUILT_IN_BZERO:
> return fold_builtin_bzero (arglist, ignore);
6924,6925c9078,9079
< case BUILT_IN_STRNCPY:
< return fold_builtin_strncpy (exp);
---
> case BUILT_IN_BCOPY:
> return fold_builtin_bcopy (arglist, ignore);
6927,6928c9081,9082
< case BUILT_IN_MEMCMP:
< return fold_builtin_memcmp (exp);
---
> CASE_FLT_FN (BUILT_IN_SIGNBIT):
> return fold_builtin_signbit (fndecl, arglist);
6930,6931c9084,9085
< case BUILT_IN_STRCMP:
< return fold_builtin_strcmp (exp);
---
> case BUILT_IN_ISASCII:
> return fold_builtin_isascii (arglist);
6933,6934c9087,9088
< case BUILT_IN_STRNCMP:
< return fold_builtin_strncmp (exp);
---
> case BUILT_IN_TOASCII:
> return fold_builtin_toascii (arglist);
6935a9090,9173
> case BUILT_IN_ISDIGIT:
> return fold_builtin_isdigit (arglist);
>
> CASE_FLT_FN (BUILT_IN_COPYSIGN):
> return fold_builtin_copysign (fndecl, arglist, type);
>
> CASE_FLT_FN (BUILT_IN_FINITE):
> case BUILT_IN_FINITED32:
> case BUILT_IN_FINITED64:
> case BUILT_IN_FINITED128:
> return fold_builtin_classify (fndecl, arglist, BUILT_IN_FINITE);
>
> CASE_FLT_FN (BUILT_IN_ISINF):
> case BUILT_IN_ISINFD32:
> case BUILT_IN_ISINFD64:
> case BUILT_IN_ISINFD128:
> return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISINF);
>
> CASE_FLT_FN (BUILT_IN_ISNAN):
> case BUILT_IN_ISNAND32:
> case BUILT_IN_ISNAND64:
> case BUILT_IN_ISNAND128:
> return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISNAN);
>
> case BUILT_IN_ISGREATER:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNLE_EXPR, LE_EXPR);
> case BUILT_IN_ISGREATEREQUAL:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNLT_EXPR, LT_EXPR);
> case BUILT_IN_ISLESS:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNGE_EXPR, GE_EXPR);
> case BUILT_IN_ISLESSEQUAL:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNGT_EXPR, GT_EXPR);
> case BUILT_IN_ISLESSGREATER:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNEQ_EXPR, EQ_EXPR);
> case BUILT_IN_ISUNORDERED:
> return fold_builtin_unordered_cmp (fndecl, arglist, UNORDERED_EXPR,
> NOP_EXPR);
>
> /* We do the folding for va_start in the expander. */
> case BUILT_IN_VA_START:
> break;
>
> case BUILT_IN_OBJECT_SIZE:
> return fold_builtin_object_size (arglist);
> case BUILT_IN_MEMCPY_CHK:
> case BUILT_IN_MEMPCPY_CHK:
> case BUILT_IN_MEMMOVE_CHK:
> case BUILT_IN_MEMSET_CHK:
> return fold_builtin_memory_chk (fndecl, arglist, NULL_TREE, ignore,
> DECL_FUNCTION_CODE (fndecl));
> case BUILT_IN_STRCPY_CHK:
> case BUILT_IN_STPCPY_CHK:
> return fold_builtin_stxcpy_chk (fndecl, arglist, NULL_TREE, ignore,
> DECL_FUNCTION_CODE (fndecl));
> case BUILT_IN_STRNCPY_CHK:
> return fold_builtin_strncpy_chk (arglist, NULL_TREE);
> case BUILT_IN_STRCAT_CHK:
> return fold_builtin_strcat_chk (fndecl, arglist);
> case BUILT_IN_STRNCAT_CHK:
> return fold_builtin_strncat_chk (fndecl, arglist);
> case BUILT_IN_SPRINTF_CHK:
> case BUILT_IN_VSPRINTF_CHK:
> return fold_builtin_sprintf_chk (arglist, DECL_FUNCTION_CODE (fndecl));
> case BUILT_IN_SNPRINTF_CHK:
> case BUILT_IN_VSNPRINTF_CHK:
> return fold_builtin_snprintf_chk (arglist, NULL_TREE,
> DECL_FUNCTION_CODE (fndecl));
>
> case BUILT_IN_PRINTF:
> case BUILT_IN_PRINTF_UNLOCKED:
> case BUILT_IN_VPRINTF:
> case BUILT_IN_PRINTF_CHK:
> case BUILT_IN_VPRINTF_CHK:
> return fold_builtin_printf (fndecl, arglist, ignore,
> DECL_FUNCTION_CODE (fndecl));
>
> case BUILT_IN_FPRINTF:
> case BUILT_IN_FPRINTF_UNLOCKED:
> case BUILT_IN_VFPRINTF:
> case BUILT_IN_FPRINTF_CHK:
> case BUILT_IN_VFPRINTF_CHK:
> return fold_builtin_fprintf (fndecl, arglist, ignore,
> DECL_FUNCTION_CODE (fndecl));
>
6942a9181,9197
> /* A wrapper function for builtin folding that prevents warnings for
> "statement without effect" and the like, caused by removing the
> call node earlier than the warning is generated. */
>
> tree
> fold_builtin (tree fndecl, tree arglist, bool ignore)
> {
> tree exp = fold_builtin_1 (fndecl, arglist, ignore);
> if (exp)
> {
> exp = build1 (NOP_EXPR, TREE_TYPE (exp), exp);
> TREE_NO_WARNING (exp) = 1;
> }
>
> return exp;
> }
>
6951,6953c9206,9207
< call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
< call_expr, arglist);
< return fold (call_expr);
---
> return fold_build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
> call_expr, arglist, NULL_TREE);
6988,6989c9242
< if (arglist == 0
< || code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
---
> if (arglist == 0)
6990a9244,9250
> if (code == POINTER_TYPE)
> {
> if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist))))
> goto end;
> }
> else if (code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
> goto end;
7017c9277,9278
< /* Instantiate all remaining CONSTANT_P_RTX nodes. */
---
> /* Returns true is EXP represents data that would potentially reside
> in a readonly section. */
7019,7020c9280,9281
< void
< purge_builtin_constant_p (void)
---
> static bool
> readonly_data_expr (tree exp)
7022c9283
< rtx insn, set, arg, new, note;
---
> STRIP_NOPS (exp);
7024,7030c9285,9792
< for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
< if (INSN_P (insn)
< && (set = single_set (insn)) != NULL_RTX
< && (GET_CODE (arg = SET_SRC (set)) == CONSTANT_P_RTX
< || (GET_CODE (arg) == SUBREG
< && (GET_CODE (arg = SUBREG_REG (arg))
< == CONSTANT_P_RTX))))
---
> if (TREE_CODE (exp) != ADDR_EXPR)
> return false;
>
> exp = get_base_address (TREE_OPERAND (exp, 0));
> if (!exp)
> return false;
>
> /* Make sure we call decl_readonly_section only for trees it
> can handle (since it returns true for everything it doesn't
> understand). */
> if (TREE_CODE (exp) == STRING_CST
> || TREE_CODE (exp) == CONSTRUCTOR
> || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
> return decl_readonly_section (exp, 0);
> else
> return false;
> }
>
> /* Simplify a call to the strstr builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strstr (tree arglist, tree type)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> tree fn;
> const char *p1, *p2;
>
> p2 = c_getstr (s2);
> if (p2 == NULL)
> return 0;
>
> p1 = c_getstr (s1);
> if (p1 != NULL)
> {
> const char *r = strstr (p1, p2);
> tree tem;
>
> if (r == NULL)
> return build_int_cst (TREE_TYPE (s1), 0);
>
> /* Return an offset into the constant string argument. */
> tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
> s1, build_int_cst (TREE_TYPE (s1), r - p1));
> return fold_convert (type, tem);
> }
>
> /* The argument is const char *, and the result is char *, so we need
> a type conversion here to avoid a warning. */
> if (p2[0] == '\0')
> return fold_convert (type, s1);
>
> if (p2[1] != '\0')
> return 0;
>
> fn = implicit_built_in_decls[BUILT_IN_STRCHR];
> if (!fn)
> return 0;
>
> /* New argument list transforming strstr(s1, s2) to
> strchr(s1, s2[0]). */
> arglist = build_tree_list (NULL_TREE,
> build_int_cst (NULL_TREE, p2[0]));
> arglist = tree_cons (NULL_TREE, s1, arglist);
> return build_function_call_expr (fn, arglist);
> }
> }
>
> /* Simplify a call to the strchr builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strchr (tree arglist, tree type)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> const char *p1;
>
> if (TREE_CODE (s2) != INTEGER_CST)
> return 0;
>
> p1 = c_getstr (s1);
> if (p1 != NULL)
> {
> char c;
> const char *r;
> tree tem;
>
> if (target_char_cast (s2, &c))
> return 0;
>
> r = strchr (p1, c);
>
> if (r == NULL)
> return build_int_cst (TREE_TYPE (s1), 0);
>
> /* Return an offset into the constant string argument. */
> tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
> s1, build_int_cst (TREE_TYPE (s1), r - p1));
> return fold_convert (type, tem);
> }
> return 0;
> }
> }
>
> /* Simplify a call to the strrchr builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strrchr (tree arglist, tree type)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> tree fn;
> const char *p1;
>
> if (TREE_CODE (s2) != INTEGER_CST)
> return 0;
>
> p1 = c_getstr (s1);
> if (p1 != NULL)
> {
> char c;
> const char *r;
> tree tem;
>
> if (target_char_cast (s2, &c))
> return 0;
>
> r = strrchr (p1, c);
>
> if (r == NULL)
> return build_int_cst (TREE_TYPE (s1), 0);
>
> /* Return an offset into the constant string argument. */
> tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
> s1, build_int_cst (TREE_TYPE (s1), r - p1));
> return fold_convert (type, tem);
> }
>
> if (! integer_zerop (s2))
> return 0;
>
> fn = implicit_built_in_decls[BUILT_IN_STRCHR];
> if (!fn)
> return 0;
>
> /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
> return build_function_call_expr (fn, arglist);
> }
> }
>
> /* Simplify a call to the strpbrk builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strpbrk (tree arglist, tree type)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> tree fn;
> const char *p1, *p2;
>
> p2 = c_getstr (s2);
> if (p2 == NULL)
> return 0;
>
> p1 = c_getstr (s1);
> if (p1 != NULL)
> {
> const char *r = strpbrk (p1, p2);
> tree tem;
>
> if (r == NULL)
> return build_int_cst (TREE_TYPE (s1), 0);
>
> /* Return an offset into the constant string argument. */
> tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
> s1, build_int_cst (TREE_TYPE (s1), r - p1));
> return fold_convert (type, tem);
> }
>
> if (p2[0] == '\0')
> /* strpbrk(x, "") == NULL.
> Evaluate and ignore s1 in case it had side-effects. */
> return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
>
> if (p2[1] != '\0')
> return 0; /* Really call strpbrk. */
>
> fn = implicit_built_in_decls[BUILT_IN_STRCHR];
> if (!fn)
> return 0;
>
> /* New argument list transforming strpbrk(s1, s2) to
> strchr(s1, s2[0]). */
> arglist = build_tree_list (NULL_TREE,
> build_int_cst (NULL_TREE, p2[0]));
> arglist = tree_cons (NULL_TREE, s1, arglist);
> return build_function_call_expr (fn, arglist);
> }
> }
>
> /* Simplify a call to the strcat builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strcat (tree arglist)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree dst = TREE_VALUE (arglist),
> src = TREE_VALUE (TREE_CHAIN (arglist));
> const char *p = c_getstr (src);
>
> /* If the string length is zero, return the dst parameter. */
> if (p && *p == '\0')
> return dst;
>
> return 0;
> }
> }
>
> /* Simplify a call to the strncat builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strncat (tree arglist)
> {
> if (!validate_arglist (arglist,
> POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree dst = TREE_VALUE (arglist);
> tree src = TREE_VALUE (TREE_CHAIN (arglist));
> tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
> const char *p = c_getstr (src);
>
> /* If the requested length is zero, or the src parameter string
> length is zero, return the dst parameter. */
> if (integer_zerop (len) || (p && *p == '\0'))
> return omit_two_operands (TREE_TYPE (dst), dst, src, len);
>
> /* If the requested len is greater than or equal to the string
> length, call strcat. */
> if (TREE_CODE (len) == INTEGER_CST && p
> && compare_tree_int (len, strlen (p)) >= 0)
> {
> tree newarglist
> = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
> tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
>
> /* If the replacement _DECL isn't initialized, don't do the
> transformation. */
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, newarglist);
> }
> return 0;
> }
> }
>
> /* Simplify a call to the strspn builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strspn (tree arglist)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
>
> /* If both arguments are constants, evaluate at compile-time. */
> if (p1 && p2)
> {
> const size_t r = strspn (p1, p2);
> return size_int (r);
> }
>
> /* If either argument is "", return 0. */
> if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
> /* Evaluate and ignore both arguments in case either one has
> side-effects. */
> return omit_two_operands (integer_type_node, integer_zero_node,
> s1, s2);
> return 0;
> }
> }
>
> /* Simplify a call to the strcspn builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree.
>
> The simplified form may be a constant or other expression which
> computes the same value, but in a more efficient manner (including
> calls to other builtin functions).
>
> The call may contain arguments which need to be evaluated, but
> which are not useful to determine the result of the call. In
> this case we return a chain of COMPOUND_EXPRs. The LHS of each
> COMPOUND_EXPR will be an argument which must be evaluated.
> COMPOUND_EXPRs are chained through their RHS. The RHS of the last
> COMPOUND_EXPR in the chain will contain the tree for the simplified
> form of the builtin function call. */
>
> static tree
> fold_builtin_strcspn (tree arglist)
> {
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
> else
> {
> tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
> const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
>
> /* If both arguments are constants, evaluate at compile-time. */
> if (p1 && p2)
> {
> const size_t r = strcspn (p1, p2);
> return size_int (r);
> }
>
> /* If the first argument is "", return 0. */
> if (p1 && *p1 == '\0')
> {
> /* Evaluate and ignore argument s2 in case it has
> side-effects. */
> return omit_one_operand (integer_type_node,
> integer_zero_node, s2);
> }
>
> /* If the second argument is "", return __builtin_strlen(s1). */
> if (p2 && *p2 == '\0')
> {
> tree newarglist = build_tree_list (NULL_TREE, s1),
> fn = implicit_built_in_decls[BUILT_IN_STRLEN];
>
> /* If the replacement _DECL isn't initialized, don't do the
> transformation. */
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, newarglist);
> }
> return 0;
> }
> }
>
> /* Fold a call to the fputs builtin. IGNORE is true if the value returned
> by the builtin will be ignored. UNLOCKED is true is true if this
> actually a call to fputs_unlocked. If LEN in non-NULL, it represents
> the known length of the string. Return NULL_TREE if no simplification
> was possible. */
>
> tree
> fold_builtin_fputs (tree arglist, bool ignore, bool unlocked, tree len)
> {
> tree fn;
> /* If we're using an unlocked function, assume the other unlocked
> functions exist explicitly. */
> tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
> : implicit_built_in_decls[BUILT_IN_FPUTC];
> tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
> : implicit_built_in_decls[BUILT_IN_FWRITE];
>
> /* If the return value is used, don't do the transformation. */
> if (!ignore)
> return 0;
>
> /* Verify the arguments in the original call. */
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
> return 0;
>
> if (! len)
> len = c_strlen (TREE_VALUE (arglist), 0);
>
> /* Get the length of the string passed to fputs. If the length
> can't be determined, punt. */
> if (!len
> || TREE_CODE (len) != INTEGER_CST)
> return 0;
>
> switch (compare_tree_int (len, 1))
> {
> case -1: /* length is 0, delete the call entirely . */
> return omit_one_operand (integer_type_node, integer_zero_node,
> TREE_VALUE (TREE_CHAIN (arglist)));
>
> case 0: /* length is 1, call fputc. */
7032,7034c9794
< arg = XEXP (arg, 0);
< new = CONSTANT_P (arg) ? const1_rtx : const0_rtx;
< validate_change (insn, &SET_SRC (set), new, 0);
---
> const char *p = c_getstr (TREE_VALUE (arglist));
7036,7038c9796,9807
< /* Remove the REG_EQUAL note from the insn. */
< if ((note = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
< remove_note (insn, note);
---
> if (p != NULL)
> {
> /* New argument list transforming fputs(string, stream) to
> fputc(string[0], stream). */
> arglist = build_tree_list (NULL_TREE,
> TREE_VALUE (TREE_CHAIN (arglist)));
> arglist = tree_cons (NULL_TREE,
> build_int_cst (NULL_TREE, p[0]),
> arglist);
> fn = fn_fputc;
> break;
> }
7039a9809,9839
> /* FALLTHROUGH */
> case 1: /* length is greater than 1, call fwrite. */
> {
> tree string_arg;
>
> /* If optimizing for size keep fputs. */
> if (optimize_size)
> return 0;
> string_arg = TREE_VALUE (arglist);
> /* New argument list transforming fputs(string, stream) to
> fwrite(string, 1, len, stream). */
> arglist = build_tree_list (NULL_TREE,
> TREE_VALUE (TREE_CHAIN (arglist)));
> arglist = tree_cons (NULL_TREE, len, arglist);
> arglist = tree_cons (NULL_TREE, size_one_node, arglist);
> arglist = tree_cons (NULL_TREE, string_arg, arglist);
> fn = fn_fwrite;
> break;
> }
> default:
> gcc_unreachable ();
> }
>
> /* If the replacement _DECL isn't initialized, don't do the
> transformation. */
> if (!fn)
> return 0;
>
> /* These optimizations are only performed when the result is ignored,
> hence there's no need to cast the result to integer_type_node. */
> return build_function_call_expr (fn, arglist);
7042,7043c9842,9848
< /* Returns true is EXP represents data that would potentially reside
< in a readonly section. */
---
> /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
> produced. False otherwise. This is done so that we don't output the error
> or warning twice or three times. */
> bool
> fold_builtin_next_arg (tree arglist)
> {
> tree fntype = TREE_TYPE (current_function_decl);
7045,7046c9850,9917
< static bool
< readonly_data_expr (tree exp)
---
> if (TYPE_ARG_TYPES (fntype) == 0
> || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
> == void_type_node))
> {
> error ("%<va_start%> used in function with fixed args");
> return true;
> }
> else if (!arglist)
> {
> /* Evidently an out of date version of <stdarg.h>; can't validate
> va_start's second argument, but can still work as intended. */
> warning (0, "%<__builtin_next_arg%> called without an argument");
> return true;
> }
> /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
> when we checked the arguments and if needed issued a warning. */
> else if (!TREE_CHAIN (arglist)
> || !integer_zerop (TREE_VALUE (arglist))
> || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist)))
> || TREE_CHAIN (TREE_CHAIN (arglist)))
> {
> tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
> tree arg = TREE_VALUE (arglist);
>
> if (TREE_CHAIN (arglist))
> {
> error ("%<va_start%> used with too many arguments");
> return true;
> }
>
> /* Strip off all nops for the sake of the comparison. This
> is not quite the same as STRIP_NOPS. It does more.
> We must also strip off INDIRECT_EXPR for C++ reference
> parameters. */
> while (TREE_CODE (arg) == NOP_EXPR
> || TREE_CODE (arg) == CONVERT_EXPR
> || TREE_CODE (arg) == NON_LVALUE_EXPR
> || TREE_CODE (arg) == INDIRECT_REF)
> arg = TREE_OPERAND (arg, 0);
> if (arg != last_parm)
> {
> /* FIXME: Sometimes with the tree optimizers we can get the
> not the last argument even though the user used the last
> argument. We just warn and set the arg to be the last
> argument so that we will get wrong-code because of
> it. */
> warning (0, "second parameter of %<va_start%> not last named argument");
> }
> /* We want to verify the second parameter just once before the tree
> optimizers are run and then avoid keeping it in the tree,
> as otherwise we could warn even for correct code like:
> void foo (int i, ...)
> { va_list ap; i++; va_start (ap, i); va_end (ap); } */
> TREE_VALUE (arglist) = integer_zero_node;
> TREE_CHAIN (arglist) = build_tree_list (NULL, integer_zero_node);
> }
> return false;
> }
>
>
> /* Simplify a call to the sprintf builtin.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree. If IGNORED is true, it means that
> the caller does not use the returned value of the function. */
>
> static tree
> fold_builtin_sprintf (tree arglist, int ignored)
7048c9919,9920
< STRIP_NOPS (exp);
---
> tree call, retval, dest, fmt;
> const char *fmt_str = NULL;
7050,7051c9922,9999
< if (TREE_CODE (exp) == ADDR_EXPR)
< return decl_readonly_section (TREE_OPERAND (exp, 0), 0);
---
> /* Verify the required arguments in the original call. We deal with two
> types of sprintf() calls: 'sprintf (str, fmt)' and
> 'sprintf (dest, "%s", orig)'. */
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)
> && !validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, POINTER_TYPE,
> VOID_TYPE))
> return NULL_TREE;
>
> /* Get the destination string and the format specifier. */
> dest = TREE_VALUE (arglist);
> fmt = TREE_VALUE (TREE_CHAIN (arglist));
> arglist = TREE_CHAIN (TREE_CHAIN (arglist));
>
> /* Check whether the format is a literal string constant. */
> fmt_str = c_getstr (fmt);
> if (fmt_str == NULL)
> return NULL_TREE;
>
> call = NULL_TREE;
> retval = NULL_TREE;
>
> if (!init_target_chars())
> return 0;
>
> /* If the format doesn't contain % args or %%, use strcpy. */
> if (strchr (fmt_str, target_percent) == NULL)
> {
> tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
>
> if (!fn)
> return NULL_TREE;
>
> /* Don't optimize sprintf (buf, "abc", ptr++). */
> if (arglist)
> return NULL_TREE;
>
> /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
> 'format' is known to contain no % formats. */
> arglist = build_tree_list (NULL_TREE, fmt);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> call = build_function_call_expr (fn, arglist);
> if (!ignored)
> retval = build_int_cst (NULL_TREE, strlen (fmt_str));
> }
>
> /* If the format is "%s", use strcpy if the result isn't used. */
> else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
> {
> tree fn, orig;
> fn = implicit_built_in_decls[BUILT_IN_STRCPY];
>
> if (!fn)
> return NULL_TREE;
>
> /* Don't crash on sprintf (str1, "%s"). */
> if (!arglist)
> return NULL_TREE;
>
> /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
> orig = TREE_VALUE (arglist);
> arglist = build_tree_list (NULL_TREE, orig);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> if (!ignored)
> {
> retval = c_strlen (orig, 1);
> if (!retval || TREE_CODE (retval) != INTEGER_CST)
> return NULL_TREE;
> }
> call = build_function_call_expr (fn, arglist);
> }
>
> if (call && retval)
> {
> retval = fold_convert
> (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
> retval);
> return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
> }
7053c10001
< return false;
---
> return call;
7054a10003,11200
>
> /* Expand a call to __builtin_object_size. */
>
> rtx
> expand_builtin_object_size (tree exp)
> {
> tree ost;
> int object_size_type;
> tree fndecl = get_callee_fndecl (exp);
> tree arglist = TREE_OPERAND (exp, 1);
> location_t locus = EXPR_LOCATION (exp);
>
> if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> {
> error ("%Hfirst argument of %D must be a pointer, second integer constant",
> &locus, fndecl);
> expand_builtin_trap ();
> return const0_rtx;
> }
>
> ost = TREE_VALUE (TREE_CHAIN (arglist));
> STRIP_NOPS (ost);
>
> if (TREE_CODE (ost) != INTEGER_CST
> || tree_int_cst_sgn (ost) < 0
> || compare_tree_int (ost, 3) > 0)
> {
> error ("%Hlast argument of %D is not integer constant between 0 and 3",
> &locus, fndecl);
> expand_builtin_trap ();
> return const0_rtx;
> }
>
> object_size_type = tree_low_cst (ost, 0);
>
> return object_size_type < 2 ? constm1_rtx : const0_rtx;
> }
>
> /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
> FCODE is the BUILT_IN_* to use.
> Return 0 if we failed; the caller should emit a normal call,
> otherwise try to get the result in TARGET, if convenient (and in
> mode MODE if that's convenient). */
>
> static rtx
> expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
> enum built_in_function fcode)
> {
> tree arglist = TREE_OPERAND (exp, 1);
> tree dest, src, len, size;
>
> if (!validate_arglist (arglist,
> POINTER_TYPE,
> fcode == BUILT_IN_MEMSET_CHK
> ? INTEGER_TYPE : POINTER_TYPE,
> INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> src = TREE_VALUE (TREE_CHAIN (arglist));
> len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (host_integerp (len, 1) || integer_all_onesp (size))
> {
> tree fn;
>
> if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
> {
> location_t locus = EXPR_LOCATION (exp);
> warning (0, "%Hcall to %D will always overflow destination buffer",
> &locus, get_callee_fndecl (exp));
> return 0;
> }
>
> arglist = build_tree_list (NULL_TREE, len);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> fn = NULL_TREE;
> /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
> mem{cpy,pcpy,move,set} is available. */
> switch (fcode)
> {
> case BUILT_IN_MEMCPY_CHK:
> fn = built_in_decls[BUILT_IN_MEMCPY];
> break;
> case BUILT_IN_MEMPCPY_CHK:
> fn = built_in_decls[BUILT_IN_MEMPCPY];
> break;
> case BUILT_IN_MEMMOVE_CHK:
> fn = built_in_decls[BUILT_IN_MEMMOVE];
> break;
> case BUILT_IN_MEMSET_CHK:
> fn = built_in_decls[BUILT_IN_MEMSET];
> break;
> default:
> break;
> }
>
> if (! fn)
> return 0;
>
> fn = build_function_call_expr (fn, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_expr (fn, target, mode, EXPAND_NORMAL);
> }
> else if (fcode == BUILT_IN_MEMSET_CHK)
> return 0;
> else
> {
> unsigned int dest_align
> = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
>
> /* If DEST is not a pointer type, call the normal function. */
> if (dest_align == 0)
> return 0;
>
> /* If SRC and DEST are the same (and not volatile), do nothing. */
> if (operand_equal_p (src, dest, 0))
> {
> tree expr;
>
> if (fcode != BUILT_IN_MEMPCPY_CHK)
> {
> /* Evaluate and ignore LEN in case it has side-effects. */
> expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
> return expand_expr (dest, target, mode, EXPAND_NORMAL);
> }
>
> len = fold_convert (TREE_TYPE (dest), len);
> expr = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
> return expand_expr (expr, target, mode, EXPAND_NORMAL);
> }
>
> /* __memmove_chk special case. */
> if (fcode == BUILT_IN_MEMMOVE_CHK)
> {
> unsigned int src_align
> = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
>
> if (src_align == 0)
> return 0;
>
> /* If src is categorized for a readonly section we can use
> normal __memcpy_chk. */
> if (readonly_data_expr (src))
> {
> tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
> if (!fn)
> return 0;
> fn = build_function_call_expr (fn, arglist);
> if (TREE_CODE (fn) == CALL_EXPR)
> CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> return expand_expr (fn, target, mode, EXPAND_NORMAL);
> }
> }
> return 0;
> }
> }
>
> /* Emit warning if a buffer overflow is detected at compile time. */
>
> static void
> maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
> {
> int arg_mask, is_strlen = 0;
> tree arglist = TREE_OPERAND (exp, 1), a;
> tree len, size;
> location_t locus;
>
> switch (fcode)
> {
> case BUILT_IN_STRCPY_CHK:
> case BUILT_IN_STPCPY_CHK:
> /* For __strcat_chk the warning will be emitted only if overflowing
> by at least strlen (dest) + 1 bytes. */
> case BUILT_IN_STRCAT_CHK:
> arg_mask = 6;
> is_strlen = 1;
> break;
> case BUILT_IN_STRNCPY_CHK:
> arg_mask = 12;
> break;
> case BUILT_IN_SNPRINTF_CHK:
> case BUILT_IN_VSNPRINTF_CHK:
> arg_mask = 10;
> break;
> default:
> gcc_unreachable ();
> }
>
> len = NULL_TREE;
> size = NULL_TREE;
> for (a = arglist; a && arg_mask; a = TREE_CHAIN (a), arg_mask >>= 1)
> if (arg_mask & 1)
> {
> if (len)
> size = a;
> else
> len = a;
> }
>
> if (!len || !size)
> return;
>
> len = TREE_VALUE (len);
> size = TREE_VALUE (size);
>
> if (! host_integerp (size, 1) || integer_all_onesp (size))
> return;
>
> if (is_strlen)
> {
> len = c_strlen (len, 1);
> if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
> return;
> }
> else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
> return;
>
> locus = EXPR_LOCATION (exp);
> warning (0, "%Hcall to %D will always overflow destination buffer",
> &locus, get_callee_fndecl (exp));
> }
>
> /* Emit warning if a buffer overflow is detected at compile time
> in __sprintf_chk/__vsprintf_chk calls. */
>
> static void
> maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
> {
> tree arglist = TREE_OPERAND (exp, 1);
> tree dest, size, len, fmt, flag;
> const char *fmt_str;
>
> /* Verify the required arguments in the original call. */
> if (! arglist)
> return;
> dest = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return;
> flag = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return;
> size = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return;
> fmt = TREE_VALUE (arglist);
> arglist = TREE_CHAIN (arglist);
>
> if (! host_integerp (size, 1) || integer_all_onesp (size))
> return;
>
> /* Check whether the format is a literal string constant. */
> fmt_str = c_getstr (fmt);
> if (fmt_str == NULL)
> return;
>
> if (!init_target_chars())
> return;
>
> /* If the format doesn't contain % args or %%, we know its size. */
> if (strchr (fmt_str, target_percent) == 0)
> len = build_int_cstu (size_type_node, strlen (fmt_str));
> /* If the format is "%s" and first ... argument is a string literal,
> we know it too. */
> else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
> {
> tree arg;
>
> if (! arglist)
> return;
> arg = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (arg)))
> return;
>
> len = c_strlen (arg, 1);
> if (!len || ! host_integerp (len, 1))
> return;
> }
> else
> return;
>
> if (! tree_int_cst_lt (len, size))
> {
> location_t locus = EXPR_LOCATION (exp);
> warning (0, "%Hcall to %D will always overflow destination buffer",
> &locus, get_callee_fndecl (exp));
> }
> }
>
> /* Fold a call to __builtin_object_size, if possible. */
>
> tree
> fold_builtin_object_size (tree arglist)
> {
> tree ptr, ost, ret = 0;
> int object_size_type;
>
> if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> ptr = TREE_VALUE (arglist);
> ost = TREE_VALUE (TREE_CHAIN (arglist));
> STRIP_NOPS (ost);
>
> if (TREE_CODE (ost) != INTEGER_CST
> || tree_int_cst_sgn (ost) < 0
> || compare_tree_int (ost, 3) > 0)
> return 0;
>
> object_size_type = tree_low_cst (ost, 0);
>
> /* __builtin_object_size doesn't evaluate side-effects in its arguments;
> if there are any side-effects, it returns (size_t) -1 for types 0 and 1
> and (size_t) 0 for types 2 and 3. */
> if (TREE_SIDE_EFFECTS (ptr))
> return fold_convert (size_type_node,
> object_size_type < 2
> ? integer_minus_one_node : integer_zero_node);
>
> if (TREE_CODE (ptr) == ADDR_EXPR)
> ret = build_int_cstu (size_type_node,
> compute_builtin_object_size (ptr, object_size_type));
>
> else if (TREE_CODE (ptr) == SSA_NAME)
> {
> unsigned HOST_WIDE_INT bytes;
>
> /* If object size is not known yet, delay folding until
> later. Maybe subsequent passes will help determining
> it. */
> bytes = compute_builtin_object_size (ptr, object_size_type);
> if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
> ? -1 : 0))
> ret = build_int_cstu (size_type_node, bytes);
> }
>
> if (ret)
> {
> ret = force_fit_type (ret, -1, false, false);
> if (TREE_CONSTANT_OVERFLOW (ret))
> ret = 0;
> }
>
> return ret;
> }
>
> /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
> IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
> code of the builtin. If MAXLEN is not NULL, it is maximum length
> passed as third argument. */
>
> tree
> fold_builtin_memory_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
> enum built_in_function fcode)
> {
> tree dest, src, len, size, fn;
>
> if (!validate_arglist (arglist,
> POINTER_TYPE,
> fcode == BUILT_IN_MEMSET_CHK
> ? INTEGER_TYPE : POINTER_TYPE,
> INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> /* Actually val for __memset_chk, but it doesn't matter. */
> src = TREE_VALUE (TREE_CHAIN (arglist));
> len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
>
> /* If SRC and DEST are the same (and not volatile), return DEST
> (resp. DEST+LEN for __mempcpy_chk). */
> if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
> {
> if (fcode != BUILT_IN_MEMPCPY_CHK)
> return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
> else
> {
> tree temp = fold_convert (TREE_TYPE (dest), len);
> temp = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, temp);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
> }
> }
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (! integer_all_onesp (size))
> {
> if (! host_integerp (len, 1))
> {
> /* If LEN is not constant, try MAXLEN too.
> For MAXLEN only allow optimizing into non-_ocs function
> if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
> if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
> {
> if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
> {
> /* (void) __mempcpy_chk () can be optimized into
> (void) __memcpy_chk (). */
> fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
> return 0;
> }
> }
> else
> maxlen = len;
>
> if (tree_int_cst_lt (size, maxlen))
> return 0;
> }
>
> arglist = build_tree_list (NULL_TREE, len);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> fn = NULL_TREE;
> /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
> mem{cpy,pcpy,move,set} is available. */
> switch (fcode)
> {
> case BUILT_IN_MEMCPY_CHK:
> fn = built_in_decls[BUILT_IN_MEMCPY];
> break;
> case BUILT_IN_MEMPCPY_CHK:
> fn = built_in_decls[BUILT_IN_MEMPCPY];
> break;
> case BUILT_IN_MEMMOVE_CHK:
> fn = built_in_decls[BUILT_IN_MEMMOVE];
> break;
> case BUILT_IN_MEMSET_CHK:
> fn = built_in_decls[BUILT_IN_MEMSET];
> break;
> default:
> break;
> }
>
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to the __st[rp]cpy_chk builtin.
> IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
> code of the builtin. If MAXLEN is not NULL, it is maximum length of
> strings passed as second argument. */
>
> tree
> fold_builtin_stxcpy_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
> enum built_in_function fcode)
> {
> tree dest, src, size, len, fn;
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
> VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> src = TREE_VALUE (TREE_CHAIN (arglist));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
>
> /* If SRC and DEST are the same (and not volatile), return DEST. */
> if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (! integer_all_onesp (size))
> {
> len = c_strlen (src, 1);
> if (! len || ! host_integerp (len, 1))
> {
> /* If LEN is not constant, try MAXLEN too.
> For MAXLEN only allow optimizing into non-_ocs function
> if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
> if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
> {
> if (fcode == BUILT_IN_STPCPY_CHK)
> {
> if (! ignore)
> return 0;
>
> /* If return value of __stpcpy_chk is ignored,
> optimize into __strcpy_chk. */
> fn = built_in_decls[BUILT_IN_STRCPY_CHK];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> if (! len || TREE_SIDE_EFFECTS (len))
> return 0;
>
> /* If c_strlen returned something, but not a constant,
> transform __strcpy_chk into __memcpy_chk. */
> fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
> if (!fn)
> return 0;
>
> len = size_binop (PLUS_EXPR, len, ssize_int (1));
> arglist = build_tree_list (NULL_TREE, size);
> arglist = tree_cons (NULL_TREE, len, arglist);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
> build_function_call_expr (fn, arglist));
> }
> }
> else
> maxlen = len;
>
> if (! tree_int_cst_lt (maxlen, size))
> return 0;
> }
>
> arglist = build_tree_list (NULL_TREE, src);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
> fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
> ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to the __strncpy_chk builtin.
> If MAXLEN is not NULL, it is maximum length passed as third argument. */
>
> tree
> fold_builtin_strncpy_chk (tree arglist, tree maxlen)
> {
> tree dest, src, size, len, fn;
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
> INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> src = TREE_VALUE (TREE_CHAIN (arglist));
> len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (! integer_all_onesp (size))
> {
> if (! host_integerp (len, 1))
> {
> /* If LEN is not constant, try MAXLEN too.
> For MAXLEN only allow optimizing into non-_ocs function
> if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
> if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
> return 0;
> }
> else
> maxlen = len;
>
> if (tree_int_cst_lt (size, maxlen))
> return 0;
> }
>
> arglist = build_tree_list (NULL_TREE, len);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_strncpy_chk is used, assume strncpy is available. */
> fn = built_in_decls[BUILT_IN_STRNCPY];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to the __strcat_chk builtin FNDECL with ARGLIST. */
>
> static tree
> fold_builtin_strcat_chk (tree fndecl, tree arglist)
> {
> tree dest, src, size, fn;
> const char *p;
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
> VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> src = TREE_VALUE (TREE_CHAIN (arglist));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
>
> p = c_getstr (src);
> /* If the SRC parameter is "", return DEST. */
> if (p && *p == '\0')
> return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
>
> if (! host_integerp (size, 1) || ! integer_all_onesp (size))
> return 0;
>
> arglist = build_tree_list (NULL_TREE, src);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_strcat_chk is used, assume strcat is available. */
> fn = built_in_decls[BUILT_IN_STRCAT];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to the __strncat_chk builtin EXP. */
>
> static tree
> fold_builtin_strncat_chk (tree fndecl, tree arglist)
> {
> tree dest, src, size, len, fn;
> const char *p;
>
> if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
> INTEGER_TYPE, VOID_TYPE))
> return 0;
>
> dest = TREE_VALUE (arglist);
> src = TREE_VALUE (TREE_CHAIN (arglist));
> len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
> size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
>
> p = c_getstr (src);
> /* If the SRC parameter is "" or if LEN is 0, return DEST. */
> if (p && *p == '\0')
> return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
> else if (integer_zerop (len))
> return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (! integer_all_onesp (size))
> {
> tree src_len = c_strlen (src, 1);
> if (src_len
> && host_integerp (src_len, 1)
> && host_integerp (len, 1)
> && ! tree_int_cst_lt (len, src_len))
> {
> /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
> fn = built_in_decls[BUILT_IN_STRCAT_CHK];
> if (!fn)
> return 0;
>
> arglist = build_tree_list (NULL_TREE, size);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
> return build_function_call_expr (fn, arglist);
> }
> return 0;
> }
>
> arglist = build_tree_list (NULL_TREE, len);
> arglist = tree_cons (NULL_TREE, src, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_strncat_chk is used, assume strncat is available. */
> fn = built_in_decls[BUILT_IN_STRNCAT];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to __{,v}sprintf_chk with argument list ARGLIST. Return 0 if
> a normal call should be emitted rather than expanding the function
> inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
>
> static tree
> fold_builtin_sprintf_chk (tree arglist, enum built_in_function fcode)
> {
> tree dest, size, len, fn, fmt, flag;
> const char *fmt_str;
>
> /* Verify the required arguments in the original call. */
> if (! arglist)
> return 0;
> dest = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (dest)))
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> flag = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE)
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> size = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> fmt = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> return 0;
> arglist = TREE_CHAIN (arglist);
>
> if (! host_integerp (size, 1))
> return 0;
>
> len = NULL_TREE;
>
> if (!init_target_chars())
> return 0;
>
> /* Check whether the format is a literal string constant. */
> fmt_str = c_getstr (fmt);
> if (fmt_str != NULL)
> {
> /* If the format doesn't contain % args or %%, we know the size. */
> if (strchr (fmt_str, target_percent) == 0)
> {
> if (fcode != BUILT_IN_SPRINTF_CHK || arglist == NULL_TREE)
> len = build_int_cstu (size_type_node, strlen (fmt_str));
> }
> /* If the format is "%s" and first ... argument is a string literal,
> we know the size too. */
> else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
> {
> tree arg;
>
> if (arglist && !TREE_CHAIN (arglist))
> {
> arg = TREE_VALUE (arglist);
> if (POINTER_TYPE_P (TREE_TYPE (arg)))
> {
> len = c_strlen (arg, 1);
> if (! len || ! host_integerp (len, 1))
> len = NULL_TREE;
> }
> }
> }
> }
>
> if (! integer_all_onesp (size))
> {
> if (! len || ! tree_int_cst_lt (len, size))
> return 0;
> }
>
> /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
> or if format doesn't contain % chars or is "%s". */
> if (! integer_zerop (flag))
> {
> if (fmt_str == NULL)
> return 0;
> if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
> return 0;
> }
>
> arglist = tree_cons (NULL_TREE, fmt, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
> fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
> ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to {,v}snprintf with argument list ARGLIST. Return 0 if
> a normal call should be emitted rather than expanding the function
> inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
> BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
> passed as second argument. */
>
> tree
> fold_builtin_snprintf_chk (tree arglist, tree maxlen,
> enum built_in_function fcode)
> {
> tree dest, size, len, fn, fmt, flag;
> const char *fmt_str;
>
> /* Verify the required arguments in the original call. */
> if (! arglist)
> return 0;
> dest = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (dest)))
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> len = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> flag = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> size = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
> return 0;
> arglist = TREE_CHAIN (arglist);
> if (! arglist)
> return 0;
> fmt = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> return 0;
> arglist = TREE_CHAIN (arglist);
>
> if (! host_integerp (size, 1))
> return 0;
>
> if (! integer_all_onesp (size))
> {
> if (! host_integerp (len, 1))
> {
> /* If LEN is not constant, try MAXLEN too.
> For MAXLEN only allow optimizing into non-_ocs function
> if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
> if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
> return 0;
> }
> else
> maxlen = len;
>
> if (tree_int_cst_lt (size, maxlen))
> return 0;
> }
>
> if (!init_target_chars())
> return 0;
>
> /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
> or if format doesn't contain % chars or is "%s". */
> if (! integer_zerop (flag))
> {
> fmt_str = c_getstr (fmt);
> if (fmt_str == NULL)
> return 0;
> if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
> return 0;
> }
>
> arglist = tree_cons (NULL_TREE, fmt, arglist);
> arglist = tree_cons (NULL_TREE, len, arglist);
> arglist = tree_cons (NULL_TREE, dest, arglist);
>
> /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
> available. */
> fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
> ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
> if (!fn)
> return 0;
>
> return build_function_call_expr (fn, arglist);
> }
>
> /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree. FCODE is the BUILT_IN_*
> code of the function to be simplified. */
>
> static tree
> fold_builtin_printf (tree fndecl, tree arglist, bool ignore,
> enum built_in_function fcode)
> {
> tree fmt, fn = NULL_TREE, fn_putchar, fn_puts, arg, call;
> const char *fmt_str = NULL;
>
> /* If the return value is used, don't do the transformation. */
> if (! ignore)
> return 0;
>
> /* Verify the required arguments in the original call. */
> if (fcode == BUILT_IN_PRINTF_CHK || fcode == BUILT_IN_VPRINTF_CHK)
> {
> tree flag;
>
> if (! arglist)
> return 0;
> flag = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
> || TREE_SIDE_EFFECTS (flag))
> return 0;
> arglist = TREE_CHAIN (arglist);
> }
>
> if (! arglist)
> return 0;
> fmt = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> return 0;
> arglist = TREE_CHAIN (arglist);
>
> /* Check whether the format is a literal string constant. */
> fmt_str = c_getstr (fmt);
> if (fmt_str == NULL)
> return NULL_TREE;
>
> if (fcode == BUILT_IN_PRINTF_UNLOCKED)
> {
> /* If we're using an unlocked function, assume the other
> unlocked functions exist explicitly. */
> fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
> fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
> }
> else
> {
> fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
> fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
> }
>
> if (!init_target_chars())
> return 0;
>
> if (strcmp (fmt_str, target_percent_s) == 0 || strchr (fmt_str, target_percent) == NULL)
> {
> const char *str;
>
> if (strcmp (fmt_str, target_percent_s) == 0)
> {
> if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
> return 0;
>
> if (! arglist
> || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
> || TREE_CHAIN (arglist))
> return 0;
>
> str = c_getstr (TREE_VALUE (arglist));
> if (str == NULL)
> return 0;
> }
> else
> {
> /* The format specifier doesn't contain any '%' characters. */
> if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
> && arglist)
> return 0;
> str = fmt_str;
> }
>
> /* If the string was "", printf does nothing. */
> if (str[0] == '\0')
> return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
>
> /* If the string has length of 1, call putchar. */
> if (str[1] == '\0')
> {
> /* Given printf("c"), (where c is any one character,)
> convert "c"[0] to an int and pass that to the replacement
> function. */
> arg = build_int_cst (NULL_TREE, str[0]);
> arglist = build_tree_list (NULL_TREE, arg);
> fn = fn_putchar;
> }
> else
> {
> /* If the string was "string\n", call puts("string"). */
> size_t len = strlen (str);
> if ((unsigned char)str[len - 1] == target_newline)
> {
> /* Create a NUL-terminated string that's one char shorter
> than the original, stripping off the trailing '\n'. */
> char *newstr = alloca (len);
> memcpy (newstr, str, len - 1);
> newstr[len - 1] = 0;
>
> arg = build_string_literal (len, newstr);
> arglist = build_tree_list (NULL_TREE, arg);
> fn = fn_puts;
> }
> else
> /* We'd like to arrange to call fputs(string,stdout) here,
> but we need stdout and don't have a way to get it yet. */
> return 0;
> }
> }
>
> /* The other optimizations can be done only on the non-va_list variants. */
> else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
> return 0;
>
> /* If the format specifier was "%s\n", call __builtin_puts(arg). */
> else if (strcmp (fmt_str, target_percent_s_newline) == 0)
> {
> if (! arglist
> || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
> || TREE_CHAIN (arglist))
> return 0;
> fn = fn_puts;
> }
>
> /* If the format specifier was "%c", call __builtin_putchar(arg). */
> else if (strcmp (fmt_str, target_percent_c) == 0)
> {
> if (! arglist
> || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
> || TREE_CHAIN (arglist))
> return 0;
> fn = fn_putchar;
> }
>
> if (!fn)
> return 0;
>
> call = build_function_call_expr (fn, arglist);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
> }
>
> /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
>
> Return 0 if no simplification was possible, otherwise return the
> simplified form of the call as a tree. FCODE is the BUILT_IN_*
> code of the function to be simplified. */
>
> static tree
> fold_builtin_fprintf (tree fndecl, tree arglist, bool ignore,
> enum built_in_function fcode)
> {
> tree fp, fmt, fn = NULL_TREE, fn_fputc, fn_fputs, arg, call;
> const char *fmt_str = NULL;
>
> /* If the return value is used, don't do the transformation. */
> if (! ignore)
> return 0;
>
> /* Verify the required arguments in the original call. */
> if (! arglist)
> return 0;
> fp = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (fp)))
> return 0;
> arglist = TREE_CHAIN (arglist);
>
> if (fcode == BUILT_IN_FPRINTF_CHK || fcode == BUILT_IN_VFPRINTF_CHK)
> {
> tree flag;
>
> if (! arglist)
> return 0;
> flag = TREE_VALUE (arglist);
> if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
> || TREE_SIDE_EFFECTS (flag))
> return 0;
> arglist = TREE_CHAIN (arglist);
> }
>
> if (! arglist)
> return 0;
> fmt = TREE_VALUE (arglist);
> if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> return 0;
> arglist = TREE_CHAIN (arglist);
>
> /* Check whether the format is a literal string constant. */
> fmt_str = c_getstr (fmt);
> if (fmt_str == NULL)
> return NULL_TREE;
>
> if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
> {
> /* If we're using an unlocked function, assume the other
> unlocked functions exist explicitly. */
> fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
> fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
> }
> else
> {
> fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
> fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
> }
>
> if (!init_target_chars())
> return 0;
>
> /* If the format doesn't contain % args or %%, use strcpy. */
> if (strchr (fmt_str, target_percent) == NULL)
> {
> if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
> && arglist)
> return 0;
>
> /* If the format specifier was "", fprintf does nothing. */
> if (fmt_str[0] == '\0')
> {
> /* If FP has side-effects, just wait until gimplification is
> done. */
> if (TREE_SIDE_EFFECTS (fp))
> return 0;
>
> return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
> }
>
> /* When "string" doesn't contain %, replace all cases of
> fprintf (fp, string) with fputs (string, fp). The fputs
> builtin will take care of special cases like length == 1. */
> arglist = build_tree_list (NULL_TREE, fp);
> arglist = tree_cons (NULL_TREE, fmt, arglist);
> fn = fn_fputs;
> }
>
> /* The other optimizations can be done only on the non-va_list variants. */
> else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
> return 0;
>
> /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
> else if (strcmp (fmt_str, target_percent_s) == 0)
> {
> if (! arglist
> || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
> || TREE_CHAIN (arglist))
> return 0;
> arg = TREE_VALUE (arglist);
> arglist = build_tree_list (NULL_TREE, fp);
> arglist = tree_cons (NULL_TREE, arg, arglist);
> fn = fn_fputs;
> }
>
> /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
> else if (strcmp (fmt_str, target_percent_c) == 0)
> {
> if (! arglist
> || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
> || TREE_CHAIN (arglist))
> return 0;
> arg = TREE_VALUE (arglist);
> arglist = build_tree_list (NULL_TREE, fp);
> arglist = tree_cons (NULL_TREE, arg, arglist);
> fn = fn_fputc;
> }
>
> if (!fn)
> return 0;
>
> call = build_function_call_expr (fn, arglist);
> return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
> }
>
> /* Initialize format string characters in the target charset. */
>
> static bool
> init_target_chars (void)
> {
> static bool init;
> if (!init)
> {
> target_newline = lang_hooks.to_target_charset ('\n');
> target_percent = lang_hooks.to_target_charset ('%');
> target_c = lang_hooks.to_target_charset ('c');
> target_s = lang_hooks.to_target_charset ('s');
> if (target_newline == 0 || target_percent == 0 || target_c == 0
> || target_s == 0)
> return false;
>
> target_percent_c[0] = target_percent;
> target_percent_c[1] = target_c;
> target_percent_c[2] = '\0';
>
> target_percent_s[0] = target_percent;
> target_percent_s[1] = target_s;
> target_percent_s[2] = '\0';
>
> target_percent_s_newline[0] = target_percent;
> target_percent_s_newline[1] = target_s;
> target_percent_s_newline[2] = target_newline;
> target_percent_s_newline[3] = '\0';
>
> init = true;
> }
> return true;
> }