7055 lines
208 KiB
C
7055 lines
208 KiB
C
/* Expand builtin functions.
|
||
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
||
2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
||
|
||
This file is part of GCC.
|
||
|
||
GCC is free software; you can redistribute it and/or modify it under
|
||
the terms of the GNU General Public License as published by the Free
|
||
Software Foundation; either version 2, or (at your option) any later
|
||
version.
|
||
|
||
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
||
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GCC; see the file COPYING. If not, write to the Free
|
||
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
||
02111-1307, USA. */
|
||
|
||
#include "config.h"
|
||
#include "system.h"
|
||
#include "coretypes.h"
|
||
#include "tm.h"
|
||
#include "machmode.h"
|
||
#include "real.h"
|
||
#include "rtl.h"
|
||
#include "tree.h"
|
||
#include "flags.h"
|
||
#include "regs.h"
|
||
#include "hard-reg-set.h"
|
||
#include "except.h"
|
||
#include "function.h"
|
||
#include "insn-config.h"
|
||
#include "expr.h"
|
||
#include "optabs.h"
|
||
#include "libfuncs.h"
|
||
#include "recog.h"
|
||
#include "output.h"
|
||
#include "typeclass.h"
|
||
#include "toplev.h"
|
||
#include "predict.h"
|
||
#include "tm_p.h"
|
||
#include "target.h"
|
||
#include "langhooks.h"
|
||
|
||
#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
|
||
|
||
#ifndef PAD_VARARGS_DOWN
|
||
#define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
|
||
#endif
|
||
|
||
/* Define the names of the builtin function types and codes. */
|
||
const char *const built_in_class_names[4]
|
||
= {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
|
||
|
||
#define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM) #X,
|
||
const char *const built_in_names[(int) END_BUILTINS] =
|
||
{
|
||
#include "builtins.def"
|
||
};
|
||
#undef DEF_BUILTIN
|
||
|
||
/* Setup an array of _DECL trees, make sure each element is
|
||
initialized to NULL_TREE. */
|
||
tree built_in_decls[(int) END_BUILTINS];
|
||
/* Declarations used when constructing the builtin implicitly in the compiler.
|
||
It may be NULL_TREE when this is invalid (for instance runtime is not
|
||
required to implement the function call in all cases. */
|
||
tree implicit_built_in_decls[(int) END_BUILTINS];
|
||
|
||
static int get_pointer_alignment (tree, unsigned int);
|
||
static tree c_strlen (tree, int);
|
||
static const char *c_getstr (tree);
|
||
static rtx c_readstr (const char *, enum machine_mode);
|
||
static int target_char_cast (tree, char *);
|
||
static rtx get_memory_rtx (tree);
|
||
static tree build_string_literal (int, const char *);
|
||
static int apply_args_size (void);
|
||
static int apply_result_size (void);
|
||
#if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
|
||
static rtx result_vector (int, rtx);
|
||
#endif
|
||
static rtx expand_builtin_setjmp (tree, rtx);
|
||
static void expand_builtin_prefetch (tree);
|
||
static rtx expand_builtin_apply_args (void);
|
||
static rtx expand_builtin_apply_args_1 (void);
|
||
static rtx expand_builtin_apply (rtx, rtx, rtx);
|
||
static void expand_builtin_return (rtx);
|
||
static enum type_class type_to_class (tree);
|
||
static rtx expand_builtin_classify_type (tree);
|
||
static void expand_errno_check (tree, rtx);
|
||
static rtx expand_builtin_mathfn (tree, rtx, rtx);
|
||
static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
|
||
static rtx expand_builtin_constant_p (tree, enum machine_mode);
|
||
static rtx expand_builtin_args_info (tree);
|
||
static rtx expand_builtin_next_arg (tree);
|
||
static rtx expand_builtin_va_start (tree);
|
||
static rtx expand_builtin_va_end (tree);
|
||
static rtx expand_builtin_va_copy (tree);
|
||
static rtx expand_builtin_memcmp (tree, tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
|
||
static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
|
||
static rtx expand_builtin_strcat (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
|
||
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_bcopy (tree);
|
||
static rtx expand_builtin_strcpy (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
|
||
static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
|
||
static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
|
||
static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
|
||
static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
|
||
static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
|
||
static rtx expand_builtin_bzero (tree);
|
||
static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
|
||
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_alloca (tree, rtx);
|
||
static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
|
||
static rtx expand_builtin_frame_address (tree, tree);
|
||
static rtx expand_builtin_fputs (tree, rtx, bool);
|
||
static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
|
||
static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
|
||
static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
|
||
static tree stabilize_va_list (tree, int);
|
||
static rtx expand_builtin_expect (tree, rtx);
|
||
static tree fold_builtin_constant_p (tree);
|
||
static tree fold_builtin_classify_type (tree);
|
||
static tree fold_builtin_inf (tree, int);
|
||
static tree fold_builtin_nan (tree, tree, int);
|
||
static int validate_arglist (tree, ...);
|
||
static bool integer_valued_real_p (tree);
|
||
static tree fold_trunc_transparent_mathfn (tree);
|
||
static bool readonly_data_expr (tree);
|
||
static rtx expand_builtin_fabs (tree, rtx, rtx);
|
||
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 tree fold_builtin_memcmp (tree);
|
||
static tree fold_builtin_strcmp (tree);
|
||
static tree fold_builtin_strncmp (tree);
|
||
|
||
/* Return the alignment in bits of EXP, a pointer valued expression.
|
||
But don't return more than MAX_ALIGN no matter what.
|
||
The alignment returned is, by default, the alignment of the thing that
|
||
EXP points to. If it is not a POINTER_TYPE, 0 is returned.
|
||
|
||
Otherwise, look at the expression to see if we can do better, i.e., if the
|
||
expression is actually pointing at an object whose alignment is tighter. */
|
||
|
||
static int
|
||
get_pointer_alignment (tree exp, unsigned int max_align)
|
||
{
|
||
unsigned int align, inner;
|
||
|
||
if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
|
||
return 0;
|
||
|
||
align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
|
||
align = MIN (align, max_align);
|
||
|
||
while (1)
|
||
{
|
||
switch (TREE_CODE (exp))
|
||
{
|
||
case NOP_EXPR:
|
||
case CONVERT_EXPR:
|
||
case NON_LVALUE_EXPR:
|
||
exp = TREE_OPERAND (exp, 0);
|
||
if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
|
||
return align;
|
||
|
||
inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
|
||
align = MIN (inner, max_align);
|
||
break;
|
||
|
||
case PLUS_EXPR:
|
||
/* If sum of pointer + int, restrict our maximum alignment to that
|
||
imposed by the integer. If not, we can't do any better than
|
||
ALIGN. */
|
||
if (! host_integerp (TREE_OPERAND (exp, 1), 1))
|
||
return align;
|
||
|
||
while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
|
||
& (max_align / BITS_PER_UNIT - 1))
|
||
!= 0)
|
||
max_align >>= 1;
|
||
|
||
exp = TREE_OPERAND (exp, 0);
|
||
break;
|
||
|
||
case ADDR_EXPR:
|
||
/* See what we are pointing at and look at its alignment. */
|
||
exp = TREE_OPERAND (exp, 0);
|
||
if (TREE_CODE (exp) == FUNCTION_DECL)
|
||
align = FUNCTION_BOUNDARY;
|
||
else if (DECL_P (exp))
|
||
align = DECL_ALIGN (exp);
|
||
#ifdef CONSTANT_ALIGNMENT
|
||
else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
|
||
align = CONSTANT_ALIGNMENT (exp, align);
|
||
#endif
|
||
return MIN (align, max_align);
|
||
|
||
default:
|
||
return align;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Compute the length of a C string. TREE_STRING_LENGTH is not the right
|
||
way, because it could contain a zero byte in the middle.
|
||
TREE_STRING_LENGTH is the size of the character array, not the string.
|
||
|
||
ONLY_VALUE should be nonzero if the result is not going to be emitted
|
||
into the instruction stream and zero if it is going to be expanded.
|
||
E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
|
||
is returned, otherwise NULL, since
|
||
len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
|
||
evaluate the side-effects.
|
||
|
||
The value returned is of type `ssizetype'.
|
||
|
||
Unfortunately, string_constant can't access the values of const char
|
||
arrays with initializers, so neither can we do so here. */
|
||
|
||
static tree
|
||
c_strlen (tree src, int only_value)
|
||
{
|
||
tree offset_node;
|
||
HOST_WIDE_INT offset;
|
||
int max;
|
||
const char *ptr;
|
||
|
||
STRIP_NOPS (src);
|
||
if (TREE_CODE (src) == COND_EXPR
|
||
&& (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
|
||
{
|
||
tree len1, len2;
|
||
|
||
len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
|
||
len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
|
||
if (tree_int_cst_equal (len1, len2))
|
||
return len1;
|
||
}
|
||
|
||
if (TREE_CODE (src) == COMPOUND_EXPR
|
||
&& (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
|
||
return c_strlen (TREE_OPERAND (src, 1), only_value);
|
||
|
||
src = string_constant (src, &offset_node);
|
||
if (src == 0)
|
||
return 0;
|
||
|
||
max = TREE_STRING_LENGTH (src) - 1;
|
||
ptr = TREE_STRING_POINTER (src);
|
||
|
||
if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
|
||
{
|
||
/* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
|
||
compute the offset to the following null if we don't know where to
|
||
start searching for it. */
|
||
int i;
|
||
|
||
for (i = 0; i < max; i++)
|
||
if (ptr[i] == 0)
|
||
return 0;
|
||
|
||
/* We don't know the starting offset, but we do know that the string
|
||
has no internal zero bytes. We can assume that the offset falls
|
||
within the bounds of the string; otherwise, the programmer deserves
|
||
what he gets. Subtract the offset from the length of the string,
|
||
and return that. This would perhaps not be valid if we were dealing
|
||
with named arrays in addition to literal string constants. */
|
||
|
||
return size_diffop (size_int (max), offset_node);
|
||
}
|
||
|
||
/* We have a known offset into the string. Start searching there for
|
||
a null character if we can represent it as a single HOST_WIDE_INT. */
|
||
if (offset_node == 0)
|
||
offset = 0;
|
||
else if (! host_integerp (offset_node, 0))
|
||
offset = -1;
|
||
else
|
||
offset = tree_low_cst (offset_node, 0);
|
||
|
||
/* If the offset is known to be out of bounds, warn, and call strlen at
|
||
runtime. */
|
||
if (offset < 0 || offset > max)
|
||
{
|
||
warning ("offset outside bounds of constant string");
|
||
return 0;
|
||
}
|
||
|
||
/* Use strlen to search for the first zero byte. Since any strings
|
||
constructed with build_string will have nulls appended, we win even
|
||
if we get handed something like (char[4])"abcd".
|
||
|
||
Since OFFSET is our starting index into the string, no further
|
||
calculation is needed. */
|
||
return ssize_int (strlen (ptr + offset));
|
||
}
|
||
|
||
/* Return a char pointer for a C string if it is a string constant
|
||
or sum of string constant and integer constant. */
|
||
|
||
static const char *
|
||
c_getstr (tree src)
|
||
{
|
||
tree offset_node;
|
||
|
||
src = string_constant (src, &offset_node);
|
||
if (src == 0)
|
||
return 0;
|
||
|
||
if (offset_node == 0)
|
||
return TREE_STRING_POINTER (src);
|
||
else if (!host_integerp (offset_node, 1)
|
||
|| compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
|
||
return 0;
|
||
|
||
return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
|
||
}
|
||
|
||
/* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
|
||
GET_MODE_BITSIZE (MODE) bits from string constant STR. */
|
||
|
||
static rtx
|
||
c_readstr (const char *str, enum machine_mode mode)
|
||
{
|
||
HOST_WIDE_INT c[2];
|
||
HOST_WIDE_INT ch;
|
||
unsigned int i, j;
|
||
|
||
if (GET_MODE_CLASS (mode) != MODE_INT)
|
||
abort ();
|
||
c[0] = 0;
|
||
c[1] = 0;
|
||
ch = 1;
|
||
for (i = 0; i < GET_MODE_SIZE (mode); i++)
|
||
{
|
||
j = i;
|
||
if (WORDS_BIG_ENDIAN)
|
||
j = GET_MODE_SIZE (mode) - i - 1;
|
||
if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
|
||
&& GET_MODE_SIZE (mode) > UNITS_PER_WORD)
|
||
j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
|
||
j *= BITS_PER_UNIT;
|
||
if (j > 2 * HOST_BITS_PER_WIDE_INT)
|
||
abort ();
|
||
if (ch)
|
||
ch = (unsigned char) str[i];
|
||
c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
|
||
}
|
||
return immed_double_const (c[0], c[1], mode);
|
||
}
|
||
|
||
/* Cast a target constant CST to target CHAR and if that value fits into
|
||
host char type, return zero and put that value into variable pointed by
|
||
P. */
|
||
|
||
static int
|
||
target_char_cast (tree cst, char *p)
|
||
{
|
||
unsigned HOST_WIDE_INT val, hostval;
|
||
|
||
if (!host_integerp (cst, 1)
|
||
|| CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
|
||
return 1;
|
||
|
||
val = tree_low_cst (cst, 1);
|
||
if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
|
||
val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
|
||
|
||
hostval = val;
|
||
if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
|
||
hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
|
||
|
||
if (val != hostval)
|
||
return 1;
|
||
|
||
*p = hostval;
|
||
return 0;
|
||
}
|
||
|
||
/* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
|
||
times to get the address of either a higher stack frame, or a return
|
||
address located within it (depending on FNDECL_CODE). */
|
||
|
||
rtx
|
||
expand_builtin_return_addr (enum built_in_function fndecl_code, int count,
|
||
rtx tem)
|
||
{
|
||
int i;
|
||
|
||
/* Some machines need special handling before we can access
|
||
arbitrary frames. For example, on the sparc, we must first flush
|
||
all register windows to the stack. */
|
||
#ifdef SETUP_FRAME_ADDRESSES
|
||
if (count > 0)
|
||
SETUP_FRAME_ADDRESSES ();
|
||
#endif
|
||
|
||
/* On the sparc, the return address is not in the frame, it is in a
|
||
register. There is no way to access it off of the current frame
|
||
pointer, but it can be accessed off the previous frame pointer by
|
||
reading the value from the register window save area. */
|
||
#ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
|
||
if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
|
||
count--;
|
||
#endif
|
||
|
||
/* Scan back COUNT frames to the specified frame. */
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
/* Assume the dynamic chain pointer is in the word that the
|
||
frame address points to, unless otherwise specified. */
|
||
#ifdef DYNAMIC_CHAIN_ADDRESS
|
||
tem = DYNAMIC_CHAIN_ADDRESS (tem);
|
||
#endif
|
||
tem = memory_address (Pmode, tem);
|
||
tem = gen_rtx_MEM (Pmode, tem);
|
||
set_mem_alias_set (tem, get_frame_alias_set ());
|
||
tem = copy_to_reg (tem);
|
||
}
|
||
|
||
/* For __builtin_frame_address, return what we've got. */
|
||
if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
|
||
return tem;
|
||
|
||
/* For __builtin_return_address, Get the return address from that
|
||
frame. */
|
||
#ifdef RETURN_ADDR_RTX
|
||
tem = RETURN_ADDR_RTX (count, tem);
|
||
#else
|
||
tem = memory_address (Pmode,
|
||
plus_constant (tem, GET_MODE_SIZE (Pmode)));
|
||
tem = gen_rtx_MEM (Pmode, tem);
|
||
set_mem_alias_set (tem, get_frame_alias_set ());
|
||
#endif
|
||
return tem;
|
||
}
|
||
|
||
/* Alias set used for setjmp buffer. */
|
||
static HOST_WIDE_INT setjmp_alias_set = -1;
|
||
|
||
/* Construct the leading half of a __builtin_setjmp call. Control will
|
||
return to RECEIVER_LABEL. This is used directly by sjlj exception
|
||
handling code. */
|
||
|
||
void
|
||
expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
|
||
{
|
||
enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
|
||
rtx stack_save;
|
||
rtx mem;
|
||
|
||
if (setjmp_alias_set == -1)
|
||
setjmp_alias_set = new_alias_set ();
|
||
|
||
buf_addr = convert_memory_address (Pmode, buf_addr);
|
||
|
||
buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
|
||
|
||
emit_queue ();
|
||
|
||
/* We store the frame pointer and the address of receiver_label in
|
||
the buffer and use the rest of it for the stack save area, which
|
||
is machine-dependent. */
|
||
|
||
#ifndef BUILTIN_SETJMP_FRAME_VALUE
|
||
#define BUILTIN_SETJMP_FRAME_VALUE virtual_stack_vars_rtx
|
||
#endif
|
||
|
||
mem = gen_rtx_MEM (Pmode, buf_addr);
|
||
set_mem_alias_set (mem, setjmp_alias_set);
|
||
emit_move_insn (mem, BUILTIN_SETJMP_FRAME_VALUE);
|
||
|
||
mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
|
||
set_mem_alias_set (mem, setjmp_alias_set);
|
||
|
||
emit_move_insn (validize_mem (mem),
|
||
force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
|
||
|
||
stack_save = gen_rtx_MEM (sa_mode,
|
||
plus_constant (buf_addr,
|
||
2 * GET_MODE_SIZE (Pmode)));
|
||
set_mem_alias_set (stack_save, setjmp_alias_set);
|
||
emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
|
||
|
||
/* If there is further processing to do, do it. */
|
||
#ifdef HAVE_builtin_setjmp_setup
|
||
if (HAVE_builtin_setjmp_setup)
|
||
emit_insn (gen_builtin_setjmp_setup (buf_addr));
|
||
#endif
|
||
|
||
/* Tell optimize_save_area_alloca that extra work is going to
|
||
need to go on during alloca. */
|
||
current_function_calls_setjmp = 1;
|
||
|
||
/* Set this so all the registers get saved in our frame; we need to be
|
||
able to copy the saved values for any registers from frames we unwind. */
|
||
current_function_has_nonlocal_label = 1;
|
||
}
|
||
|
||
/* Construct the trailing part of a __builtin_setjmp call.
|
||
This is used directly by sjlj exception handling code. */
|
||
|
||
void
|
||
expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
|
||
{
|
||
/* Clobber the FP when we get here, so we have to make sure it's
|
||
marked as used by this function. */
|
||
emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
|
||
|
||
/* Mark the static chain as clobbered here so life information
|
||
doesn't get messed up for it. */
|
||
emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
|
||
|
||
/* Now put in the code to restore the frame pointer, and argument
|
||
pointer, if needed. The code below is from expand_end_bindings
|
||
in stmt.c; see detailed documentation there. */
|
||
#ifdef HAVE_nonlocal_goto
|
||
if (! HAVE_nonlocal_goto)
|
||
#endif
|
||
emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
|
||
|
||
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
||
if (fixed_regs[ARG_POINTER_REGNUM])
|
||
{
|
||
#ifdef ELIMINABLE_REGS
|
||
size_t i;
|
||
static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
|
||
|
||
for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
|
||
if (elim_regs[i].from == ARG_POINTER_REGNUM
|
||
&& elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
|
||
break;
|
||
|
||
if (i == ARRAY_SIZE (elim_regs))
|
||
#endif
|
||
{
|
||
/* Now restore our arg pointer from the address at which it
|
||
was saved in our stack frame. */
|
||
emit_move_insn (virtual_incoming_args_rtx,
|
||
copy_to_reg (get_arg_pointer_save_area (cfun)));
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifdef HAVE_builtin_setjmp_receiver
|
||
if (HAVE_builtin_setjmp_receiver)
|
||
emit_insn (gen_builtin_setjmp_receiver (receiver_label));
|
||
else
|
||
#endif
|
||
#ifdef HAVE_nonlocal_goto_receiver
|
||
if (HAVE_nonlocal_goto_receiver)
|
||
emit_insn (gen_nonlocal_goto_receiver ());
|
||
else
|
||
#endif
|
||
{ /* Nothing */ }
|
||
|
||
/* @@@ This is a kludge. Not all machine descriptions define a blockage
|
||
insn, but we must not allow the code we just generated to be reordered
|
||
by scheduling. Specifically, the update of the frame pointer must
|
||
happen immediately, not later. So emit an ASM_INPUT to act as blockage
|
||
insn. */
|
||
emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
|
||
}
|
||
|
||
/* __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;
|
||
}
|
||
|
||
/* __builtin_longjmp 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 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. */
|
||
|
||
void
|
||
expand_builtin_longjmp (rtx buf_addr, rtx value)
|
||
{
|
||
rtx fp, lab, stack, insn, last;
|
||
enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
|
||
|
||
if (setjmp_alias_set == -1)
|
||
setjmp_alias_set = new_alias_set ();
|
||
|
||
buf_addr = convert_memory_address (Pmode, buf_addr);
|
||
|
||
buf_addr = force_reg (Pmode, buf_addr);
|
||
|
||
/* We used to store value in static_chain_rtx, but that fails if pointers
|
||
are smaller than integers. We instead require that the user must pass
|
||
a second argument of 1, because that is what builtin_setjmp will
|
||
return. This also makes EH slightly more efficient, since we are no
|
||
longer copying around a value that we don't care about. */
|
||
if (value != const1_rtx)
|
||
abort ();
|
||
|
||
current_function_calls_longjmp = 1;
|
||
|
||
last = get_last_insn ();
|
||
#ifdef HAVE_builtin_longjmp
|
||
if (HAVE_builtin_longjmp)
|
||
emit_insn (gen_builtin_longjmp (buf_addr));
|
||
else
|
||
#endif
|
||
{
|
||
fp = gen_rtx_MEM (Pmode, buf_addr);
|
||
lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
|
||
GET_MODE_SIZE (Pmode)));
|
||
|
||
stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
|
||
2 * GET_MODE_SIZE (Pmode)));
|
||
set_mem_alias_set (fp, setjmp_alias_set);
|
||
set_mem_alias_set (lab, setjmp_alias_set);
|
||
set_mem_alias_set (stack, setjmp_alias_set);
|
||
|
||
/* Pick up FP, label, and SP from the block and jump. This code is
|
||
from expand_goto in stmt.c; see there for detailed comments. */
|
||
#if HAVE_nonlocal_goto
|
||
if (HAVE_nonlocal_goto)
|
||
/* We have to pass a value to the nonlocal_goto pattern that will
|
||
get copied into the static_chain pointer, but it does not matter
|
||
what that value is, because builtin_setjmp does not use it. */
|
||
emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
|
||
else
|
||
#endif
|
||
{
|
||
lab = copy_to_reg (lab);
|
||
|
||
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)));
|
||
|
||
emit_move_insn (hard_frame_pointer_rtx, fp);
|
||
emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
|
||
|
||
emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
|
||
emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
|
||
emit_indirect_jump (lab);
|
||
}
|
||
}
|
||
|
||
/* Search backwards and mark the jump insn as a non-local goto.
|
||
Note that this precludes the use of __builtin_longjmp to a
|
||
__builtin_setjmp target in the same function. However, we've
|
||
already cautioned the user that these functions are for
|
||
internal exception handling use only. */
|
||
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
|
||
{
|
||
if (insn == last)
|
||
abort ();
|
||
if (GET_CODE (insn) == JUMP_INSN)
|
||
{
|
||
REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
|
||
REG_NOTES (insn));
|
||
break;
|
||
}
|
||
else if (GET_CODE (insn) == CALL_INSN)
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to __builtin_prefetch. For a target that does not support
|
||
data prefetch, evaluate the memory address argument in case it has side
|
||
effects. */
|
||
|
||
static void
|
||
expand_builtin_prefetch (tree arglist)
|
||
{
|
||
tree arg0, arg1, arg2;
|
||
rtx op0, op1, op2;
|
||
|
||
if (!validate_arglist (arglist, POINTER_TYPE, 0))
|
||
return;
|
||
|
||
arg0 = TREE_VALUE (arglist);
|
||
/* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
|
||
zero (read) and argument 2 (locality) defaults to 3 (high degree of
|
||
locality). */
|
||
if (TREE_CHAIN (arglist))
|
||
{
|
||
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
if (TREE_CHAIN (TREE_CHAIN (arglist)))
|
||
arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
else
|
||
arg2 = build_int_2 (3, 0);
|
||
}
|
||
else
|
||
{
|
||
arg1 = integer_zero_node;
|
||
arg2 = build_int_2 (3, 0);
|
||
}
|
||
|
||
/* Argument 0 is an address. */
|
||
op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
|
||
|
||
/* Argument 1 (read/write flag) must be a compile-time constant int. */
|
||
if (TREE_CODE (arg1) != INTEGER_CST)
|
||
{
|
||
error ("second arg to `__builtin_prefetch' must be a constant");
|
||
arg1 = integer_zero_node;
|
||
}
|
||
op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
|
||
/* Argument 1 must be either zero or one. */
|
||
if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
|
||
{
|
||
warning ("invalid second arg to __builtin_prefetch; using zero");
|
||
op1 = const0_rtx;
|
||
}
|
||
|
||
/* Argument 2 (locality) must be a compile-time constant int. */
|
||
if (TREE_CODE (arg2) != INTEGER_CST)
|
||
{
|
||
error ("third arg to `__builtin_prefetch' must be a constant");
|
||
arg2 = integer_zero_node;
|
||
}
|
||
op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
|
||
/* Argument 2 must be 0, 1, 2, or 3. */
|
||
if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
|
||
{
|
||
warning ("invalid third arg to __builtin_prefetch; using zero");
|
||
op2 = const0_rtx;
|
||
}
|
||
|
||
#ifdef HAVE_prefetch
|
||
if (HAVE_prefetch)
|
||
{
|
||
if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
|
||
(op0,
|
||
insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
|
||
|| (GET_MODE (op0) != Pmode))
|
||
{
|
||
op0 = convert_memory_address (Pmode, op0);
|
||
op0 = force_reg (Pmode, op0);
|
||
}
|
||
emit_insn (gen_prefetch (op0, op1, op2));
|
||
}
|
||
else
|
||
#endif
|
||
op0 = protect_from_queue (op0, 0);
|
||
/* Don't do anything with direct references to volatile memory, but
|
||
generate code to handle other side effects. */
|
||
if (GET_CODE (op0) != MEM && side_effects_p (op0))
|
||
emit_insn (op0);
|
||
}
|
||
|
||
/* Get a MEM rtx for expression EXP which is the address of an operand
|
||
to be used to be used in a string instruction (cmpstrsi, movstrsi, ..). */
|
||
|
||
static rtx
|
||
get_memory_rtx (tree exp)
|
||
{
|
||
rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_SUM);
|
||
rtx mem;
|
||
|
||
addr = convert_memory_address (Pmode, addr);
|
||
|
||
mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
|
||
|
||
/* Get an expression we can use to find the attributes to assign to MEM.
|
||
If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
|
||
we can. First remove any nops. */
|
||
while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
|
||
|| TREE_CODE (exp) == NON_LVALUE_EXPR)
|
||
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
|
||
exp = TREE_OPERAND (exp, 0);
|
||
|
||
if (TREE_CODE (exp) == ADDR_EXPR)
|
||
{
|
||
exp = TREE_OPERAND (exp, 0);
|
||
set_mem_attributes (mem, exp, 0);
|
||
}
|
||
else if (POINTER_TYPE_P (TREE_TYPE (exp)))
|
||
{
|
||
exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
|
||
/* memcpy, memset and other builtin stringops can alias with anything. */
|
||
set_mem_alias_set (mem, 0);
|
||
}
|
||
|
||
return mem;
|
||
}
|
||
|
||
/* Built-in functions to perform an untyped call and return. */
|
||
|
||
/* For each register that may be used for calling a function, this
|
||
gives a mode used to copy the register's value. VOIDmode indicates
|
||
the register is not used for calling a function. If the machine
|
||
has register windows, this gives only the outbound registers.
|
||
INCOMING_REGNO gives the corresponding inbound register. */
|
||
static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
|
||
|
||
/* For each register that may be used for returning values, this gives
|
||
a mode used to copy the register's value. VOIDmode indicates the
|
||
register is not used for returning values. If the machine has
|
||
register windows, this gives only the outbound registers.
|
||
INCOMING_REGNO gives the corresponding inbound register. */
|
||
static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
|
||
|
||
/* For each register that may be used for calling a function, this
|
||
gives the offset of that register into the block returned by
|
||
__builtin_apply_args. 0 indicates that the register is not
|
||
used for calling a function. */
|
||
static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
|
||
|
||
/* 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];
|
||
}
|
||
|
||
/* Return the size required for the block returned by __builtin_apply_args,
|
||
and initialize apply_args_mode. */
|
||
|
||
static int
|
||
apply_args_size (void)
|
||
{
|
||
static int size = -1;
|
||
int align;
|
||
unsigned int regno;
|
||
enum machine_mode mode;
|
||
|
||
/* The values computed by this function never change. */
|
||
if (size < 0)
|
||
{
|
||
/* The first value is the incoming arg-pointer. */
|
||
size = GET_MODE_SIZE (Pmode);
|
||
|
||
/* The second value is the structure value address unless this is
|
||
passed as an "invisible" first argument. */
|
||
if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
|
||
size += GET_MODE_SIZE (Pmode);
|
||
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if (FUNCTION_ARG_REGNO_P (regno))
|
||
{
|
||
/* 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;
|
||
|
||
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;
|
||
|
||
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 ();
|
||
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
apply_args_reg_offset[regno] = size;
|
||
size += GET_MODE_SIZE (mode);
|
||
apply_args_mode[regno] = mode;
|
||
}
|
||
else
|
||
{
|
||
apply_args_mode[regno] = VOIDmode;
|
||
apply_args_reg_offset[regno] = 0;
|
||
}
|
||
}
|
||
return size;
|
||
}
|
||
|
||
/* Return the size required for the block returned by __builtin_apply,
|
||
and initialize apply_result_mode. */
|
||
|
||
static int
|
||
apply_result_size (void)
|
||
{
|
||
static int size = -1;
|
||
int align, regno;
|
||
enum machine_mode mode;
|
||
|
||
/* The values computed by this function never change. */
|
||
if (size < 0)
|
||
{
|
||
size = 0;
|
||
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if (FUNCTION_VALUE_REGNO_P (regno))
|
||
{
|
||
/* 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;
|
||
|
||
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;
|
||
|
||
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 ();
|
||
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
size += GET_MODE_SIZE (mode);
|
||
apply_result_mode[regno] = mode;
|
||
}
|
||
else
|
||
apply_result_mode[regno] = VOIDmode;
|
||
|
||
/* Allow targets that use untyped_call and untyped_return to override
|
||
the size so that machine-specific information can be stored here. */
|
||
#ifdef APPLY_RESULT_SIZE
|
||
size = APPLY_RESULT_SIZE;
|
||
#endif
|
||
}
|
||
return size;
|
||
}
|
||
|
||
#if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
|
||
/* Create a vector describing the result block RESULT. If SAVEP is true,
|
||
the result block is used to save the values; otherwise it is used to
|
||
restore the values. */
|
||
|
||
static rtx
|
||
result_vector (int savep, rtx result)
|
||
{
|
||
int regno, size, align, nelts;
|
||
enum machine_mode mode;
|
||
rtx reg, mem;
|
||
rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
|
||
|
||
size = nelts = 0;
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if ((mode = apply_result_mode[regno]) != VOIDmode)
|
||
{
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
|
||
mem = adjust_address (result, mode, size);
|
||
savevec[nelts++] = (savep
|
||
? gen_rtx_SET (VOIDmode, mem, reg)
|
||
: gen_rtx_SET (VOIDmode, reg, mem));
|
||
size += GET_MODE_SIZE (mode);
|
||
}
|
||
return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
|
||
}
|
||
#endif /* HAVE_untyped_call or HAVE_untyped_return */
|
||
|
||
/* Save the state required to perform an untyped call with the same
|
||
arguments as were passed to the current function. */
|
||
|
||
static rtx
|
||
expand_builtin_apply_args_1 (void)
|
||
{
|
||
rtx registers, tem;
|
||
int size, align, regno;
|
||
enum machine_mode mode;
|
||
rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
|
||
|
||
/* Create a block where the arg-pointer, structure value address,
|
||
and argument registers can be saved. */
|
||
registers = assign_stack_local (BLKmode, apply_args_size (), -1);
|
||
|
||
/* Walk past the arg-pointer and structure value address. */
|
||
size = GET_MODE_SIZE (Pmode);
|
||
if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
|
||
size += GET_MODE_SIZE (Pmode);
|
||
|
||
/* Save each register used in calling a function to the block. */
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if ((mode = apply_args_mode[regno]) != VOIDmode)
|
||
{
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
|
||
tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
|
||
|
||
emit_move_insn (adjust_address (registers, mode, size), tem);
|
||
size += GET_MODE_SIZE (mode);
|
||
}
|
||
|
||
/* Save the arg pointer to the block. */
|
||
tem = copy_to_reg (virtual_incoming_args_rtx);
|
||
#ifdef STACK_GROWS_DOWNWARD
|
||
/* We need the pointer as the caller actually passed them to us, not
|
||
as we might have pretended they were passed. Make sure it's a valid
|
||
operand, as emit_move_insn isn't expected to handle a PLUS. */
|
||
tem
|
||
= force_operand (plus_constant (tem, current_function_pretend_args_size),
|
||
NULL_RTX);
|
||
#endif
|
||
emit_move_insn (adjust_address (registers, Pmode, 0), tem);
|
||
|
||
size = GET_MODE_SIZE (Pmode);
|
||
|
||
/* Save the structure value address unless this is passed as an
|
||
"invisible" first argument. */
|
||
if (struct_incoming_value)
|
||
{
|
||
emit_move_insn (adjust_address (registers, Pmode, size),
|
||
copy_to_reg (struct_incoming_value));
|
||
size += GET_MODE_SIZE (Pmode);
|
||
}
|
||
|
||
/* Return the address of the block. */
|
||
return copy_addr_to_reg (XEXP (registers, 0));
|
||
}
|
||
|
||
/* __builtin_apply_args returns block of memory allocated on
|
||
the stack into which is stored the arg pointer, structure
|
||
value address, static chain, and all the registers that might
|
||
possibly be used in performing a function call. The code is
|
||
moved to the start of the function so the incoming values are
|
||
saved. */
|
||
|
||
static rtx
|
||
expand_builtin_apply_args (void)
|
||
{
|
||
/* Don't do __builtin_apply_args more than once in a function.
|
||
Save the result of the first call and reuse it. */
|
||
if (apply_args_value != 0)
|
||
return apply_args_value;
|
||
{
|
||
/* When this function is called, it means that registers must be
|
||
saved on entry to this function. So we migrate the
|
||
call to the first insn of this function. */
|
||
rtx temp;
|
||
rtx seq;
|
||
|
||
start_sequence ();
|
||
temp = expand_builtin_apply_args_1 ();
|
||
seq = get_insns ();
|
||
end_sequence ();
|
||
|
||
apply_args_value = temp;
|
||
|
||
/* Put the insns after the NOTE that starts the function.
|
||
If this is inside a start_sequence, make the outer-level insn
|
||
chain current, so the code is placed at the start of the
|
||
function. */
|
||
push_topmost_sequence ();
|
||
emit_insn_before (seq, NEXT_INSN (get_insns ()));
|
||
pop_topmost_sequence ();
|
||
return temp;
|
||
}
|
||
}
|
||
|
||
/* Perform an untyped call and save the state required to perform an
|
||
untyped return of whatever value was returned by the given function. */
|
||
|
||
static rtx
|
||
expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
|
||
{
|
||
int size, align, regno;
|
||
enum machine_mode mode;
|
||
rtx incoming_args, result, reg, dest, src, call_insn;
|
||
rtx old_stack_level = 0;
|
||
rtx call_fusage = 0;
|
||
rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
|
||
|
||
arguments = convert_memory_address (Pmode, arguments);
|
||
|
||
/* Create a block where the return registers can be saved. */
|
||
result = assign_stack_local (BLKmode, apply_result_size (), -1);
|
||
|
||
/* Fetch the arg pointer from the ARGUMENTS block. */
|
||
incoming_args = gen_reg_rtx (Pmode);
|
||
emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
|
||
#ifndef STACK_GROWS_DOWNWARD
|
||
incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
|
||
incoming_args, 0, OPTAB_LIB_WIDEN);
|
||
#endif
|
||
|
||
/* Perform postincrements before actually calling the function. */
|
||
emit_queue ();
|
||
|
||
/* Push a new argument block and copy the arguments. Do not allow
|
||
the (potential) memcpy call below to interfere with our stack
|
||
manipulations. */
|
||
do_pending_stack_adjust ();
|
||
NO_DEFER_POP;
|
||
|
||
/* Save the stack with nonlocal if available. */
|
||
#ifdef HAVE_save_stack_nonlocal
|
||
if (HAVE_save_stack_nonlocal)
|
||
emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
|
||
else
|
||
#endif
|
||
emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
|
||
|
||
/* Allocate a block of memory onto the stack and copy the memory
|
||
arguments to the outgoing arguments address. */
|
||
allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
|
||
dest = virtual_outgoing_args_rtx;
|
||
#ifndef STACK_GROWS_DOWNWARD
|
||
if (GET_CODE (argsize) == CONST_INT)
|
||
dest = plus_constant (dest, -INTVAL (argsize));
|
||
else
|
||
dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
|
||
#endif
|
||
dest = gen_rtx_MEM (BLKmode, dest);
|
||
set_mem_align (dest, PARM_BOUNDARY);
|
||
src = gen_rtx_MEM (BLKmode, incoming_args);
|
||
set_mem_align (src, PARM_BOUNDARY);
|
||
emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
|
||
|
||
/* Refer to the argument block. */
|
||
apply_args_size ();
|
||
arguments = gen_rtx_MEM (BLKmode, arguments);
|
||
set_mem_align (arguments, PARM_BOUNDARY);
|
||
|
||
/* Walk past the arg-pointer and structure value address. */
|
||
size = GET_MODE_SIZE (Pmode);
|
||
if (struct_value)
|
||
size += GET_MODE_SIZE (Pmode);
|
||
|
||
/* Restore each of the registers previously saved. Make USE insns
|
||
for each of these registers for use in making the call. */
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if ((mode = apply_args_mode[regno]) != VOIDmode)
|
||
{
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
reg = gen_rtx_REG (mode, regno);
|
||
emit_move_insn (reg, adjust_address (arguments, mode, size));
|
||
use_reg (&call_fusage, reg);
|
||
size += GET_MODE_SIZE (mode);
|
||
}
|
||
|
||
/* Restore the structure value address unless this is passed as an
|
||
"invisible" first argument. */
|
||
size = GET_MODE_SIZE (Pmode);
|
||
if (struct_value)
|
||
{
|
||
rtx value = gen_reg_rtx (Pmode);
|
||
emit_move_insn (value, adjust_address (arguments, Pmode, size));
|
||
emit_move_insn (struct_value, value);
|
||
if (GET_CODE (struct_value) == REG)
|
||
use_reg (&call_fusage, struct_value);
|
||
size += GET_MODE_SIZE (Pmode);
|
||
}
|
||
|
||
/* All arguments and registers used for the call are set up by now! */
|
||
function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
|
||
|
||
/* Ensure address is valid. SYMBOL_REF is already valid, so no need,
|
||
and we don't want to load it into a register as an optimization,
|
||
because prepare_call_address already did it if it should be done. */
|
||
if (GET_CODE (function) != SYMBOL_REF)
|
||
function = memory_address (FUNCTION_MODE, function);
|
||
|
||
/* Generate the actual call instruction and save the return value. */
|
||
#ifdef HAVE_untyped_call
|
||
if (HAVE_untyped_call)
|
||
emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
|
||
result, result_vector (1, result)));
|
||
else
|
||
#endif
|
||
#ifdef HAVE_call_value
|
||
if (HAVE_call_value)
|
||
{
|
||
rtx valreg = 0;
|
||
|
||
/* Locate the unique return register. It is not possible to
|
||
express a call that sets more than one return register using
|
||
call_value; use untyped_call for that. In fact, untyped_call
|
||
only needs to save the return registers in the given block. */
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if ((mode = apply_result_mode[regno]) != VOIDmode)
|
||
{
|
||
if (valreg)
|
||
abort (); /* HAVE_untyped_call required. */
|
||
valreg = gen_rtx_REG (mode, regno);
|
||
}
|
||
|
||
emit_call_insn (GEN_CALL_VALUE (valreg,
|
||
gen_rtx_MEM (FUNCTION_MODE, function),
|
||
const0_rtx, NULL_RTX, const0_rtx));
|
||
|
||
emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
|
||
}
|
||
else
|
||
#endif
|
||
abort ();
|
||
|
||
/* Find the CALL insn we just emitted, and attach the register usage
|
||
information. */
|
||
call_insn = last_call_insn ();
|
||
add_function_usage_to (call_insn, call_fusage);
|
||
|
||
/* Restore the stack. */
|
||
#ifdef HAVE_save_stack_nonlocal
|
||
if (HAVE_save_stack_nonlocal)
|
||
emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
|
||
else
|
||
#endif
|
||
emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
|
||
|
||
OK_DEFER_POP;
|
||
|
||
/* Return the address of the result block. */
|
||
result = copy_addr_to_reg (XEXP (result, 0));
|
||
return convert_memory_address (ptr_mode, result);
|
||
}
|
||
|
||
/* Perform an untyped return. */
|
||
|
||
static void
|
||
expand_builtin_return (rtx result)
|
||
{
|
||
int size, align, regno;
|
||
enum machine_mode mode;
|
||
rtx reg;
|
||
rtx call_fusage = 0;
|
||
|
||
result = convert_memory_address (Pmode, result);
|
||
|
||
apply_result_size ();
|
||
result = gen_rtx_MEM (BLKmode, result);
|
||
|
||
#ifdef HAVE_untyped_return
|
||
if (HAVE_untyped_return)
|
||
{
|
||
emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
|
||
emit_barrier ();
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
/* Restore the return value and note that each value is used. */
|
||
size = 0;
|
||
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
|
||
if ((mode = apply_result_mode[regno]) != VOIDmode)
|
||
{
|
||
align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
|
||
if (size % align != 0)
|
||
size = CEIL (size, align) * align;
|
||
reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
|
||
emit_move_insn (reg, adjust_address (result, mode, size));
|
||
|
||
push_to_sequence (call_fusage);
|
||
emit_insn (gen_rtx_USE (VOIDmode, reg));
|
||
call_fusage = get_insns ();
|
||
end_sequence ();
|
||
size += GET_MODE_SIZE (mode);
|
||
}
|
||
|
||
/* Put the USE insns before the return. */
|
||
emit_insn (call_fusage);
|
||
|
||
/* Return whatever values was restored by jumping directly to the end
|
||
of the function. */
|
||
expand_naked_return ();
|
||
}
|
||
|
||
/* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
|
||
|
||
static enum type_class
|
||
type_to_class (tree type)
|
||
{
|
||
switch (TREE_CODE (type))
|
||
{
|
||
case VOID_TYPE: return void_type_class;
|
||
case INTEGER_TYPE: return integer_type_class;
|
||
case CHAR_TYPE: return char_type_class;
|
||
case ENUMERAL_TYPE: return enumeral_type_class;
|
||
case BOOLEAN_TYPE: return boolean_type_class;
|
||
case POINTER_TYPE: return pointer_type_class;
|
||
case REFERENCE_TYPE: return reference_type_class;
|
||
case OFFSET_TYPE: return offset_type_class;
|
||
case REAL_TYPE: return real_type_class;
|
||
case COMPLEX_TYPE: return complex_type_class;
|
||
case FUNCTION_TYPE: return function_type_class;
|
||
case METHOD_TYPE: return method_type_class;
|
||
case RECORD_TYPE: return record_type_class;
|
||
case UNION_TYPE:
|
||
case QUAL_UNION_TYPE: return union_type_class;
|
||
case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
|
||
? string_type_class : array_type_class);
|
||
case SET_TYPE: return set_type_class;
|
||
case FILE_TYPE: return file_type_class;
|
||
case LANG_TYPE: return lang_type_class;
|
||
default: return no_type_class;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to __builtin_classify_type with arguments found in
|
||
ARGLIST. */
|
||
|
||
static rtx
|
||
expand_builtin_classify_type (tree arglist)
|
||
{
|
||
if (arglist != 0)
|
||
return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
|
||
return GEN_INT (no_type_class);
|
||
}
|
||
|
||
/* 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;
|
||
}
|
||
|
||
/* This helper macro, meant to be used in mathfn_built_in below,
|
||
determines which among a set of three builtin math functions is
|
||
appropriate for a given type mode. The `F' and `L' cases are
|
||
automatically generated from the `double' case. */
|
||
#define CASE_MATHFN(BUILT_IN_MATHFN) \
|
||
case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
|
||
fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
|
||
fcodel = BUILT_IN_MATHFN##L ; break;
|
||
|
||
/* Return mathematic function equivalent to FN but operating directly
|
||
on TYPE, if available. If we can't do the conversion, return zero. */
|
||
tree
|
||
mathfn_built_in (tree type, enum built_in_function fn)
|
||
{
|
||
const enum machine_mode type_mode = TYPE_MODE (type);
|
||
enum built_in_function fcode, fcodef, fcodel;
|
||
|
||
switch (fn)
|
||
{
|
||
CASE_MATHFN (BUILT_IN_ACOS)
|
||
CASE_MATHFN (BUILT_IN_ACOSH)
|
||
CASE_MATHFN (BUILT_IN_ASIN)
|
||
CASE_MATHFN (BUILT_IN_ASINH)
|
||
CASE_MATHFN (BUILT_IN_ATAN)
|
||
CASE_MATHFN (BUILT_IN_ATAN2)
|
||
CASE_MATHFN (BUILT_IN_ATANH)
|
||
CASE_MATHFN (BUILT_IN_CBRT)
|
||
CASE_MATHFN (BUILT_IN_CEIL)
|
||
CASE_MATHFN (BUILT_IN_COPYSIGN)
|
||
CASE_MATHFN (BUILT_IN_COS)
|
||
CASE_MATHFN (BUILT_IN_COSH)
|
||
CASE_MATHFN (BUILT_IN_DREM)
|
||
CASE_MATHFN (BUILT_IN_ERF)
|
||
CASE_MATHFN (BUILT_IN_ERFC)
|
||
CASE_MATHFN (BUILT_IN_EXP)
|
||
CASE_MATHFN (BUILT_IN_EXP10)
|
||
CASE_MATHFN (BUILT_IN_EXP2)
|
||
CASE_MATHFN (BUILT_IN_EXPM1)
|
||
CASE_MATHFN (BUILT_IN_FABS)
|
||
CASE_MATHFN (BUILT_IN_FDIM)
|
||
CASE_MATHFN (BUILT_IN_FLOOR)
|
||
CASE_MATHFN (BUILT_IN_FMA)
|
||
CASE_MATHFN (BUILT_IN_FMAX)
|
||
CASE_MATHFN (BUILT_IN_FMIN)
|
||
CASE_MATHFN (BUILT_IN_FMOD)
|
||
CASE_MATHFN (BUILT_IN_FREXP)
|
||
CASE_MATHFN (BUILT_IN_GAMMA)
|
||
CASE_MATHFN (BUILT_IN_HUGE_VAL)
|
||
CASE_MATHFN (BUILT_IN_HYPOT)
|
||
CASE_MATHFN (BUILT_IN_ILOGB)
|
||
CASE_MATHFN (BUILT_IN_INF)
|
||
CASE_MATHFN (BUILT_IN_J0)
|
||
CASE_MATHFN (BUILT_IN_J1)
|
||
CASE_MATHFN (BUILT_IN_JN)
|
||
CASE_MATHFN (BUILT_IN_LDEXP)
|
||
CASE_MATHFN (BUILT_IN_LGAMMA)
|
||
CASE_MATHFN (BUILT_IN_LLRINT)
|
||
CASE_MATHFN (BUILT_IN_LLROUND)
|
||
CASE_MATHFN (BUILT_IN_LOG)
|
||
CASE_MATHFN (BUILT_IN_LOG10)
|
||
CASE_MATHFN (BUILT_IN_LOG1P)
|
||
CASE_MATHFN (BUILT_IN_LOG2)
|
||
CASE_MATHFN (BUILT_IN_LOGB)
|
||
CASE_MATHFN (BUILT_IN_LRINT)
|
||
CASE_MATHFN (BUILT_IN_LROUND)
|
||
CASE_MATHFN (BUILT_IN_MODF)
|
||
CASE_MATHFN (BUILT_IN_NAN)
|
||
CASE_MATHFN (BUILT_IN_NANS)
|
||
CASE_MATHFN (BUILT_IN_NEARBYINT)
|
||
CASE_MATHFN (BUILT_IN_NEXTAFTER)
|
||
CASE_MATHFN (BUILT_IN_NEXTTOWARD)
|
||
CASE_MATHFN (BUILT_IN_POW)
|
||
CASE_MATHFN (BUILT_IN_POW10)
|
||
CASE_MATHFN (BUILT_IN_REMAINDER)
|
||
CASE_MATHFN (BUILT_IN_REMQUO)
|
||
CASE_MATHFN (BUILT_IN_RINT)
|
||
CASE_MATHFN (BUILT_IN_ROUND)
|
||
CASE_MATHFN (BUILT_IN_SCALB)
|
||
CASE_MATHFN (BUILT_IN_SCALBLN)
|
||
CASE_MATHFN (BUILT_IN_SCALBN)
|
||
CASE_MATHFN (BUILT_IN_SIGNIFICAND)
|
||
CASE_MATHFN (BUILT_IN_SIN)
|
||
CASE_MATHFN (BUILT_IN_SINCOS)
|
||
CASE_MATHFN (BUILT_IN_SINH)
|
||
CASE_MATHFN (BUILT_IN_SQRT)
|
||
CASE_MATHFN (BUILT_IN_TAN)
|
||
CASE_MATHFN (BUILT_IN_TANH)
|
||
CASE_MATHFN (BUILT_IN_TGAMMA)
|
||
CASE_MATHFN (BUILT_IN_TRUNC)
|
||
CASE_MATHFN (BUILT_IN_Y0)
|
||
CASE_MATHFN (BUILT_IN_Y1)
|
||
CASE_MATHFN (BUILT_IN_YN)
|
||
|
||
default:
|
||
return 0;
|
||
}
|
||
|
||
if (type_mode == TYPE_MODE (double_type_node))
|
||
return implicit_built_in_decls[fcode];
|
||
else if (type_mode == TYPE_MODE (float_type_node))
|
||
return implicit_built_in_decls[fcodef];
|
||
else if (type_mode == TYPE_MODE (long_double_type_node))
|
||
return implicit_built_in_decls[fcodel];
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
/* If errno must be maintained, expand the RTL to check if the result,
|
||
TARGET, of a built-in function call, EXP, is NaN, and if so set
|
||
errno to EDOM. */
|
||
|
||
static void
|
||
expand_errno_check (tree exp, rtx target)
|
||
{
|
||
rtx lab = gen_label_rtx ();
|
||
|
||
/* Test the result; if it is NaN, set errno=EDOM because
|
||
the argument was not in the domain. */
|
||
emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
|
||
0, lab);
|
||
|
||
#ifdef TARGET_EDOM
|
||
/* If this built-in doesn't throw an exception, set errno directly. */
|
||
if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
|
||
{
|
||
#ifdef GEN_ERRNO_RTX
|
||
rtx errno_rtx = GEN_ERRNO_RTX;
|
||
#else
|
||
rtx errno_rtx
|
||
= gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
|
||
#endif
|
||
emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
|
||
emit_label (lab);
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
/* We can't set errno=EDOM directly; let the library call do it.
|
||
Pop the arguments right away in case the call gets deleted. */
|
||
NO_DEFER_POP;
|
||
expand_call (exp, target, 0);
|
||
OK_DEFER_POP;
|
||
emit_label (lab);
|
||
}
|
||
|
||
|
||
/* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
|
||
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 (tree exp, rtx target, rtx subtarget)
|
||
{
|
||
optab builtin_optab;
|
||
rtx op0, insns, before_call;
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
enum machine_mode mode;
|
||
bool errno_set = false;
|
||
tree arg, narg;
|
||
|
||
if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg = TREE_VALUE (arglist);
|
||
|
||
switch (DECL_FUNCTION_CODE (fndecl))
|
||
{
|
||
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:
|
||
errno_set = ! tree_expr_nonnegative_p (arg);
|
||
builtin_optab = sqrt_optab;
|
||
break;
|
||
case BUILT_IN_EXP:
|
||
case BUILT_IN_EXPF:
|
||
case BUILT_IN_EXPL:
|
||
errno_set = true; builtin_optab = exp_optab; break;
|
||
case BUILT_IN_LOG:
|
||
case BUILT_IN_LOGF:
|
||
case BUILT_IN_LOGL:
|
||
errno_set = true; builtin_optab = log_optab; break;
|
||
case BUILT_IN_TAN:
|
||
case BUILT_IN_TANF:
|
||
case BUILT_IN_TANL:
|
||
builtin_optab = tan_optab; break;
|
||
case BUILT_IN_ATAN:
|
||
case BUILT_IN_ATANF:
|
||
case BUILT_IN_ATANL:
|
||
builtin_optab = atan_optab; break;
|
||
case BUILT_IN_FLOOR:
|
||
case BUILT_IN_FLOORF:
|
||
case BUILT_IN_FLOORL:
|
||
builtin_optab = floor_optab; break;
|
||
case BUILT_IN_CEIL:
|
||
case BUILT_IN_CEILF:
|
||
case BUILT_IN_CEILL:
|
||
builtin_optab = ceil_optab; break;
|
||
case BUILT_IN_TRUNC:
|
||
case BUILT_IN_TRUNCF:
|
||
case BUILT_IN_TRUNCL:
|
||
builtin_optab = btrunc_optab; break;
|
||
case BUILT_IN_ROUND:
|
||
case BUILT_IN_ROUNDF:
|
||
case BUILT_IN_ROUNDL:
|
||
builtin_optab = round_optab; break;
|
||
case BUILT_IN_NEARBYINT:
|
||
case BUILT_IN_NEARBYINTF:
|
||
case BUILT_IN_NEARBYINTL:
|
||
builtin_optab = nearbyint_optab; break;
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
/* Make a suitable register to place result in. */
|
||
mode = TYPE_MODE (TREE_TYPE (exp));
|
||
|
||
if (! flag_errno_math || ! HONOR_NANS (mode))
|
||
errno_set = false;
|
||
|
||
/* 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);
|
||
|
||
emit_queue ();
|
||
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)
|
||
{
|
||
if (errno_set)
|
||
expand_errno_check (exp, target);
|
||
|
||
/* 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 ();
|
||
}
|
||
|
||
before_call = get_last_insn ();
|
||
|
||
target = expand_call (exp, target, target == const0_rtx);
|
||
|
||
/* If this is a sqrt operation and we don't care about errno, try to
|
||
attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
|
||
This allows the semantics of the libcall to be visible to the RTL
|
||
optimizers. */
|
||
if (builtin_optab == sqrt_optab && !errno_set)
|
||
{
|
||
/* Search backwards through the insns emitted by expand_call looking
|
||
for the instruction with the REG_RETVAL note. */
|
||
rtx last = get_last_insn ();
|
||
while (last != before_call)
|
||
{
|
||
if (find_reg_note (last, REG_RETVAL, NULL))
|
||
{
|
||
rtx note = find_reg_note (last, REG_EQUAL, NULL);
|
||
/* Check that the REQ_EQUAL note is an EXPR_LIST with
|
||
two elements, i.e. symbol_ref(sqrt) and the operand. */
|
||
if (note
|
||
&& GET_CODE (note) == EXPR_LIST
|
||
&& GET_CODE (XEXP (note, 0)) == EXPR_LIST
|
||
&& XEXP (XEXP (note, 0), 1) != NULL_RTX
|
||
&& XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
|
||
{
|
||
rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
|
||
/* Check operand is a register with expected mode. */
|
||
if (operand
|
||
&& GET_CODE (operand) == REG
|
||
&& GET_MODE (operand) == mode)
|
||
{
|
||
/* Replace the REG_EQUAL note with a SQRT rtx. */
|
||
rtx equiv = gen_rtx_SQRT (mode, operand);
|
||
set_unique_reg_note (last, REG_EQUAL, equiv);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
last = PREV_INSN (last);
|
||
}
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
/* Expand a call to the builtin binary math functions (pow and atan2).
|
||
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_2 (tree exp, rtx target, rtx subtarget)
|
||
{
|
||
optab builtin_optab;
|
||
rtx op0, op1, insns;
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg0, arg1, temp, narg;
|
||
enum machine_mode mode;
|
||
bool errno_set = true;
|
||
bool stable = true;
|
||
|
||
if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg0 = TREE_VALUE (arglist);
|
||
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
switch (DECL_FUNCTION_CODE (fndecl))
|
||
{
|
||
case BUILT_IN_POW:
|
||
case BUILT_IN_POWF:
|
||
case BUILT_IN_POWL:
|
||
builtin_optab = pow_optab; break;
|
||
case BUILT_IN_ATAN2:
|
||
case BUILT_IN_ATAN2F:
|
||
case BUILT_IN_ATAN2L:
|
||
builtin_optab = atan2_optab; break;
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
/* 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)
|
||
return 0;
|
||
|
||
target = gen_reg_rtx (mode);
|
||
|
||
if (! flag_errno_math || ! HONOR_NANS (mode))
|
||
errno_set = false;
|
||
|
||
/* Alway stabilize the argument list. */
|
||
narg = save_expr (arg1);
|
||
if (narg != arg1)
|
||
{
|
||
arg1 = narg;
|
||
temp = build_tree_list (NULL_TREE, narg);
|
||
stable = false;
|
||
}
|
||
else
|
||
temp = TREE_CHAIN (arglist);
|
||
|
||
narg = save_expr (arg0);
|
||
if (narg != arg0)
|
||
{
|
||
arg0 = narg;
|
||
arglist = tree_cons (NULL_TREE, narg, temp);
|
||
stable = false;
|
||
}
|
||
else if (! stable)
|
||
arglist = tree_cons (NULL_TREE, arg0, temp);
|
||
|
||
if (! stable)
|
||
exp = build_function_call_expr (fndecl, arglist);
|
||
|
||
op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
|
||
op1 = expand_expr (arg1, 0, VOIDmode, 0);
|
||
|
||
emit_queue ();
|
||
start_sequence ();
|
||
|
||
/* Compute into TARGET.
|
||
Set TARGET to wherever the result comes back. */
|
||
target = expand_binop (mode, builtin_optab, op0, op1,
|
||
target, 0, OPTAB_DIRECT);
|
||
|
||
/* 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. */
|
||
if (target == 0)
|
||
{
|
||
end_sequence ();
|
||
return expand_call (exp, target, target == const0_rtx);
|
||
}
|
||
|
||
if (errno_set)
|
||
expand_errno_check (exp, target);
|
||
|
||
/* Output the entire sequence. */
|
||
insns = get_insns ();
|
||
end_sequence ();
|
||
emit_insn (insns);
|
||
|
||
return target;
|
||
}
|
||
|
||
/* To evaluate powi(x,n), the floating point value x raised to the
|
||
constant integer exponent n, we use a hybrid algorithm that
|
||
combines the "window method" with look-up tables. For an
|
||
introduction to exponentiation algorithms and "addition chains",
|
||
see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
|
||
"Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
|
||
3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
|
||
Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
|
||
|
||
/* Provide a default value for POWI_MAX_MULTS, the maximum number of
|
||
multiplications to inline before calling the system library's pow
|
||
function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
|
||
so this default never requires calling pow, powf or powl. */
|
||
|
||
#ifndef POWI_MAX_MULTS
|
||
#define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
|
||
#endif
|
||
|
||
/* The size of the "optimal power tree" lookup table. All
|
||
exponents less than this value are simply looked up in the
|
||
powi_table below. This threshold is also used to size the
|
||
cache of pseudo registers that hold intermediate results. */
|
||
#define POWI_TABLE_SIZE 256
|
||
|
||
/* The size, in bits of the window, used in the "window method"
|
||
exponentiation algorithm. This is equivalent to a radix of
|
||
(1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
|
||
#define POWI_WINDOW_SIZE 3
|
||
|
||
/* The following table is an efficient representation of an
|
||
"optimal power tree". For each value, i, the corresponding
|
||
value, j, in the table states than an optimal evaluation
|
||
sequence for calculating pow(x,i) can be found by evaluating
|
||
pow(x,j)*pow(x,i-j). An optimal power tree for the first
|
||
100 integers is given in Knuth's "Seminumerical algorithms". */
|
||
|
||
static const unsigned char powi_table[POWI_TABLE_SIZE] =
|
||
{
|
||
0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
|
||
4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
|
||
8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
|
||
12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
|
||
16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
|
||
20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
|
||
24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
|
||
28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
|
||
32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
|
||
36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
|
||
40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
|
||
44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
|
||
48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
|
||
52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
|
||
56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
|
||
60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
|
||
64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
|
||
68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
|
||
72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
|
||
76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
|
||
80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
|
||
84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
|
||
88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
|
||
92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
|
||
96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
|
||
100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
|
||
104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
|
||
108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
|
||
112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
|
||
116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
|
||
120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
|
||
124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
|
||
};
|
||
|
||
|
||
/* Return the number of multiplications required to calculate
|
||
powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
|
||
subroutine of powi_cost. CACHE is an array indicating
|
||
which exponents have already been calculated. */
|
||
|
||
static int
|
||
powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
|
||
{
|
||
/* If we've already calculated this exponent, then this evaluation
|
||
doesn't require any additional multiplications. */
|
||
if (cache[n])
|
||
return 0;
|
||
|
||
cache[n] = true;
|
||
return powi_lookup_cost (n - powi_table[n], cache)
|
||
+ powi_lookup_cost (powi_table[n], cache) + 1;
|
||
}
|
||
|
||
/* Return the number of multiplications required to calculate
|
||
powi(x,n) for an arbitrary x, given the exponent N. This
|
||
function needs to be kept in sync with expand_powi below. */
|
||
|
||
static int
|
||
powi_cost (HOST_WIDE_INT n)
|
||
{
|
||
bool cache[POWI_TABLE_SIZE];
|
||
unsigned HOST_WIDE_INT digit;
|
||
unsigned HOST_WIDE_INT val;
|
||
int result;
|
||
|
||
if (n == 0)
|
||
return 0;
|
||
|
||
/* Ignore the reciprocal when calculating the cost. */
|
||
val = (n < 0) ? -n : n;
|
||
|
||
/* Initialize the exponent cache. */
|
||
memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
|
||
cache[1] = true;
|
||
|
||
result = 0;
|
||
|
||
while (val >= POWI_TABLE_SIZE)
|
||
{
|
||
if (val & 1)
|
||
{
|
||
digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
|
||
result += powi_lookup_cost (digit, cache)
|
||
+ POWI_WINDOW_SIZE + 1;
|
||
val >>= POWI_WINDOW_SIZE;
|
||
}
|
||
else
|
||
{
|
||
val >>= 1;
|
||
result++;
|
||
}
|
||
}
|
||
|
||
return result + powi_lookup_cost (val, cache);
|
||
}
|
||
|
||
/* Recursive subroutine of expand_powi. This function takes the array,
|
||
CACHE, of already calculated exponents and an exponent N and returns
|
||
an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
|
||
|
||
static rtx
|
||
expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
|
||
{
|
||
unsigned HOST_WIDE_INT digit;
|
||
rtx target, result;
|
||
rtx op0, op1;
|
||
|
||
if (n < POWI_TABLE_SIZE)
|
||
{
|
||
if (cache[n])
|
||
return cache[n];
|
||
|
||
target = gen_reg_rtx (mode);
|
||
cache[n] = target;
|
||
|
||
op0 = expand_powi_1 (mode, n - powi_table[n], cache);
|
||
op1 = expand_powi_1 (mode, powi_table[n], cache);
|
||
}
|
||
else if (n & 1)
|
||
{
|
||
target = gen_reg_rtx (mode);
|
||
digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
|
||
op0 = expand_powi_1 (mode, n - digit, cache);
|
||
op1 = expand_powi_1 (mode, digit, cache);
|
||
}
|
||
else
|
||
{
|
||
target = gen_reg_rtx (mode);
|
||
op0 = expand_powi_1 (mode, n >> 1, cache);
|
||
op1 = op0;
|
||
}
|
||
|
||
result = expand_mult (mode, op0, op1, target, 0);
|
||
if (result != target)
|
||
emit_move_insn (target, result);
|
||
return target;
|
||
}
|
||
|
||
/* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
|
||
floating point operand in mode MODE, and N is the exponent. This
|
||
function needs to be kept in sync with powi_cost above. */
|
||
|
||
static rtx
|
||
expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
|
||
{
|
||
unsigned HOST_WIDE_INT val;
|
||
rtx cache[POWI_TABLE_SIZE];
|
||
rtx result;
|
||
|
||
if (n == 0)
|
||
return CONST1_RTX (mode);
|
||
|
||
val = (n < 0) ? -n : n;
|
||
|
||
memset (cache, 0, sizeof (cache));
|
||
cache[1] = x;
|
||
|
||
result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
|
||
|
||
/* If the original exponent was negative, reciprocate the result. */
|
||
if (n < 0)
|
||
result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
|
||
result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Expand a call to the pow 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_pow (tree exp, rtx target, rtx subtarget)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg0, arg1;
|
||
|
||
if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg0 = TREE_VALUE (arglist);
|
||
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
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);
|
||
n = real_to_integer (&c);
|
||
real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
|
||
if (real_identical (&c, &cint))
|
||
{
|
||
/* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
|
||
Otherwise, check the number of multiplications required.
|
||
Note that pow never sets errno for an integer exponent. */
|
||
if ((n >= -1 && n <= 2)
|
||
|| (flag_unsafe_math_optimizations
|
||
&& ! optimize_size
|
||
&& powi_cost (n) <= POWI_MAX_MULTS))
|
||
{
|
||
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
||
rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
|
||
op = force_reg (mode, op);
|
||
return expand_powi (op, mode, n);
|
||
}
|
||
}
|
||
}
|
||
return expand_builtin_mathfn_2 (exp, target, NULL_RTX);
|
||
}
|
||
|
||
/* Expand expression EXP which is a call to the strlen builtin. Return 0
|
||
if we failed the caller should emit a normal call, otherwise
|
||
try to get the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strlen (tree arglist, rtx target,
|
||
enum machine_mode target_mode)
|
||
{
|
||
if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
rtx pat;
|
||
tree len, src = TREE_VALUE (arglist);
|
||
rtx result, src_reg, char_rtx, before_strlen;
|
||
enum machine_mode insn_mode = target_mode, char_mode;
|
||
enum insn_code icode = CODE_FOR_nothing;
|
||
int align;
|
||
|
||
/* If the length can be computed at compile-time, return it. */
|
||
len = c_strlen (src, 0);
|
||
if (len)
|
||
return expand_expr (len, target, target_mode, EXPAND_NORMAL);
|
||
|
||
/* If the length can be computed at compile-time and is constant
|
||
integer, but there are side-effects in src, evaluate
|
||
src for side-effects, then return len.
|
||
E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
|
||
can be optimized into: i++; x = 3; */
|
||
len = c_strlen (src, 1);
|
||
if (len && TREE_CODE (len) == INTEGER_CST)
|
||
{
|
||
expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
return expand_expr (len, target, target_mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
|
||
|
||
/* If SRC is not a pointer type, don't do this operation inline. */
|
||
if (align == 0)
|
||
return 0;
|
||
|
||
/* Bail out if we can't compute strlen in the right mode. */
|
||
while (insn_mode != VOIDmode)
|
||
{
|
||
icode = strlen_optab->handlers[(int) insn_mode].insn_code;
|
||
if (icode != CODE_FOR_nothing)
|
||
break;
|
||
|
||
insn_mode = GET_MODE_WIDER_MODE (insn_mode);
|
||
}
|
||
if (insn_mode == VOIDmode)
|
||
return 0;
|
||
|
||
/* 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);
|
||
|
||
/* Make a place to hold the source address. We will not expand
|
||
the actual source until we are sure that the expansion will
|
||
not fail -- there are trees that cannot be expanded twice. */
|
||
src_reg = gen_reg_rtx (Pmode);
|
||
|
||
/* Mark the beginning of the strlen sequence so we can emit the
|
||
source operand later. */
|
||
before_strlen = get_last_insn ();
|
||
|
||
char_rtx = const0_rtx;
|
||
char_mode = insn_data[(int) icode].operand[2].mode;
|
||
if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
|
||
char_mode))
|
||
char_rtx = copy_to_mode_reg (char_mode, char_rtx);
|
||
|
||
pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
|
||
char_rtx, GEN_INT (align));
|
||
if (! pat)
|
||
return 0;
|
||
emit_insn (pat);
|
||
|
||
/* Now that we are assured of success, expand the source. */
|
||
start_sequence ();
|
||
pat = memory_address (BLKmode,
|
||
expand_expr (src, src_reg, ptr_mode, EXPAND_SUM));
|
||
if (pat != src_reg)
|
||
emit_move_insn (src_reg, pat);
|
||
pat = get_insns ();
|
||
end_sequence ();
|
||
|
||
if (before_strlen)
|
||
emit_insn_after (pat, before_strlen);
|
||
else
|
||
emit_insn_before (pat, get_insns ());
|
||
|
||
/* Return the value in the proper mode for this function. */
|
||
if (GET_MODE (result) == target_mode)
|
||
target = result;
|
||
else if (target != 0)
|
||
convert_move (target, result, 0);
|
||
else
|
||
target = convert_to_mode (target_mode, result, 0);
|
||
|
||
return target;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the strstr 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_strstr (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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);
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the strchr 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_strchr (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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;
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the strrchr 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_strrchr (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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;
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the strpbrk 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_strpbrk (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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);
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
|
||
bytes from constant string DATA + OFFSET and return it as target
|
||
constant. */
|
||
|
||
static rtx
|
||
builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
|
||
enum machine_mode mode)
|
||
{
|
||
const char *str = (const char *) data;
|
||
|
||
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. */
|
||
|
||
return c_readstr (str + offset, mode);
|
||
}
|
||
|
||
/* Expand a call to the memcpy builtin, with arguments in ARGLIST.
|
||
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_memcpy (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
tree dest = TREE_VALUE (arglist);
|
||
tree src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
const char *src_str;
|
||
unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
|
||
unsigned int dest_align
|
||
= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
||
rtx dest_mem, src_mem, dest_addr, len_rtx;
|
||
|
||
/* If DEST is not a pointer type, call the normal function. */
|
||
if (dest_align == 0)
|
||
return 0;
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* If either SRC is not a pointer type, don't do this
|
||
operation in-line. */
|
||
if (src_align == 0)
|
||
return 0;
|
||
|
||
dest_mem = get_memory_rtx (dest);
|
||
set_mem_align (dest_mem, dest_align);
|
||
len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
|
||
src_str = c_getstr (src);
|
||
|
||
/* If SRC is a string constant and block move would be done
|
||
by pieces, we can avoid loading the string from memory
|
||
and only stored the computed constants. */
|
||
if (src_str
|
||
&& GET_CODE (len_rtx) == CONST_INT
|
||
&& (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
|
||
&& can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
|
||
(void *) src_str, dest_align))
|
||
{
|
||
dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
|
||
builtin_memcpy_read_str,
|
||
(void *) src_str, dest_align, 0);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
src_mem = get_memory_rtx (src);
|
||
set_mem_align (src_mem, src_align);
|
||
|
||
/* Copy word part most expediently. */
|
||
dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
|
||
BLOCK_OP_NORMAL);
|
||
|
||
if (dest_addr == 0)
|
||
{
|
||
dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_addr = convert_memory_address (ptr_mode, dest_addr);
|
||
}
|
||
return dest_addr;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
|
||
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). 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. */
|
||
|
||
static rtx
|
||
expand_builtin_mempcpy (tree arglist, rtx target, enum machine_mode mode,
|
||
int endp)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
/* If return value is ignored, transform mempcpy into memcpy. */
|
||
else if (target == const0_rtx)
|
||
{
|
||
tree 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);
|
||
}
|
||
else
|
||
{
|
||
tree dest = TREE_VALUE (arglist);
|
||
tree src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
const char *src_str;
|
||
unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
|
||
unsigned int dest_align
|
||
= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
||
rtx dest_mem, src_mem, len_rtx;
|
||
|
||
/* 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 (endp == 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);
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
/* If LEN is not constant, call the normal function. */
|
||
if (! host_integerp (len, 1))
|
||
return 0;
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* 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);
|
||
src_str = c_getstr (src);
|
||
|
||
/* If SRC is a string constant and block move would be done
|
||
by pieces, we can avoid loading the string from memory
|
||
and only stored the computed constants. */
|
||
if (src_str
|
||
&& GET_CODE (len_rtx) == CONST_INT
|
||
&& (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
|
||
&& can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
|
||
(void *) src_str, dest_align))
|
||
{
|
||
dest_mem = get_memory_rtx (dest);
|
||
set_mem_align (dest_mem, dest_align);
|
||
dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
|
||
builtin_memcpy_read_str,
|
||
(void *) src_str, dest_align, endp);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
if (GET_CODE (len_rtx) == CONST_INT
|
||
&& can_move_by_pieces (INTVAL (len_rtx),
|
||
MIN (dest_align, src_align)))
|
||
{
|
||
dest_mem = get_memory_rtx (dest);
|
||
set_mem_align (dest_mem, dest_align);
|
||
src_mem = get_memory_rtx (src);
|
||
set_mem_align (src_mem, src_align);
|
||
dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
|
||
MIN (dest_align, src_align), endp);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the memmove builtin. Return 0
|
||
if we failed the caller should emit a normal call. */
|
||
|
||
static rtx
|
||
expand_builtin_memmove (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
tree dest = TREE_VALUE (arglist);
|
||
tree src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
|
||
unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
|
||
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 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);
|
||
}
|
||
|
||
/* If either SRC is not a pointer type, don't do this
|
||
operation in-line. */
|
||
if (src_align == 0)
|
||
return 0;
|
||
|
||
/* If src is categorized for a readonly section we can use
|
||
normal memcpy. */
|
||
if (readonly_data_expr (src))
|
||
{
|
||
tree const 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);
|
||
}
|
||
|
||
/* Otherwise, call the normal function. */
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the bcopy builtin. Return 0
|
||
if we failed the caller should emit a normal call. */
|
||
|
||
static rtx
|
||
expand_builtin_bcopy (tree arglist)
|
||
{
|
||
tree src, dest, size, newarglist;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return NULL_RTX;
|
||
|
||
src = TREE_VALUE (arglist);
|
||
dest = TREE_VALUE (TREE_CHAIN (arglist));
|
||
size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
|
||
/* 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. */
|
||
|
||
newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
|
||
newarglist = tree_cons (NULL_TREE, src, newarglist);
|
||
newarglist = tree_cons (NULL_TREE, dest, newarglist);
|
||
|
||
return expand_builtin_memmove (newarglist, const0_rtx, VOIDmode);
|
||
}
|
||
|
||
/* 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 arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
tree fn, len, src, dst;
|
||
|
||
if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
dst = TREE_VALUE (arglist);
|
||
|
||
/* 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);
|
||
|
||
fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
|
||
if (!fn)
|
||
return 0;
|
||
|
||
len = c_strlen (src, 1);
|
||
if (len == 0 || 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, dst, arglist);
|
||
return expand_expr (build_function_call_expr (fn, arglist),
|
||
target, mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
/* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
|
||
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_stpcpy (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
tree dst, src, len;
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* Ensure we get an actual string whose length can be evaluated at
|
||
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. */
|
||
src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
|
||
return 0;
|
||
|
||
dst = TREE_VALUE (arglist);
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
|
||
bytes from constant string DATA + OFFSET and return it as target
|
||
constant. */
|
||
|
||
static rtx
|
||
builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
|
||
enum machine_mode mode)
|
||
{
|
||
const char *str = (const char *) data;
|
||
|
||
if ((unsigned HOST_WIDE_INT) offset > strlen (str))
|
||
return const0_rtx;
|
||
|
||
return c_readstr (str + offset, mode);
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strncpy builtin. Return 0
|
||
if we failed the caller should emit a normal call. */
|
||
|
||
static rtx
|
||
expand_builtin_strncpy (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
|
||
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
tree fn;
|
||
|
||
/* 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))
|
||
{
|
||
/* 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);
|
||
}
|
||
|
||
/* 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're required to pad with trailing zeros if the requested
|
||
len is greater than strlen(s2)+1. In that case try to
|
||
use store_by_pieces, if it fails, punt. */
|
||
if (tree_int_cst_lt (slen, len))
|
||
{
|
||
tree dest = TREE_VALUE (arglist);
|
||
unsigned int dest_align
|
||
= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
||
const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
|
||
rtx dest_mem;
|
||
|
||
if (!p || dest_align == 0 || !host_integerp (len, 1)
|
||
|| !can_store_by_pieces (tree_low_cst (len, 1),
|
||
builtin_strncpy_read_str,
|
||
(void *) p, dest_align))
|
||
return 0;
|
||
|
||
dest_mem = get_memory_rtx (dest);
|
||
store_by_pieces (dest_mem, tree_low_cst (len, 1),
|
||
builtin_strncpy_read_str,
|
||
(void *) p, dest_align, 0);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
}
|
||
|
||
/* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
|
||
bytes from constant string DATA + OFFSET and return it as target
|
||
constant. */
|
||
|
||
static rtx
|
||
builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
|
||
enum machine_mode mode)
|
||
{
|
||
const char *c = (const char *) data;
|
||
char *p = alloca (GET_MODE_SIZE (mode));
|
||
|
||
memset (p, *c, GET_MODE_SIZE (mode));
|
||
|
||
return c_readstr (p, mode);
|
||
}
|
||
|
||
/* Callback routine for store_by_pieces. Return the RTL of a register
|
||
containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
|
||
char value given in the RTL register data. For example, if mode is
|
||
4 bytes wide, return the RTL for 0x01010101*data. */
|
||
|
||
static rtx
|
||
builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
|
||
enum machine_mode mode)
|
||
{
|
||
rtx target, coeff;
|
||
size_t size;
|
||
char *p;
|
||
|
||
size = GET_MODE_SIZE (mode);
|
||
if (size == 1)
|
||
return (rtx) data;
|
||
|
||
p = alloca (size);
|
||
memset (p, 1, size);
|
||
coeff = c_readstr (p, mode);
|
||
|
||
target = convert_to_mode (mode, (rtx) data, 1);
|
||
target = expand_mult (mode, target, coeff, NULL_RTX, 1);
|
||
return force_reg (mode, target);
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the memset 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_memset (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
tree dest = TREE_VALUE (arglist);
|
||
tree val = TREE_VALUE (TREE_CHAIN (arglist));
|
||
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||
char c;
|
||
|
||
unsigned int dest_align
|
||
= get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
|
||
rtx dest_mem, dest_addr, len_rtx;
|
||
|
||
/* If DEST is not a pointer type, don't do this
|
||
operation in-line. */
|
||
if (dest_align == 0)
|
||
return 0;
|
||
|
||
/* If the LEN parameter is zero, return DEST. */
|
||
if (integer_zerop (len))
|
||
{
|
||
/* Evaluate and ignore VAL in case it has side-effects. */
|
||
expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
return expand_expr (dest, target, mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
if (TREE_CODE (val) != INTEGER_CST)
|
||
{
|
||
rtx val_rtx;
|
||
|
||
if (!host_integerp (len, 1))
|
||
return 0;
|
||
|
||
if (optimize_size && tree_low_cst (len, 1) > 1)
|
||
return 0;
|
||
|
||
/* Assume that we can memset by pieces if we can store the
|
||
* the coefficients by pieces (in the required modes).
|
||
* We can't pass builtin_memset_gen_str as that emits RTL. */
|
||
c = 1;
|
||
if (!can_store_by_pieces (tree_low_cst (len, 1),
|
||
builtin_memset_read_str,
|
||
&c, dest_align))
|
||
return 0;
|
||
|
||
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);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
if (target_char_cast (val, &c))
|
||
return 0;
|
||
|
||
if (c)
|
||
{
|
||
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;
|
||
|
||
dest_mem = get_memory_rtx (dest);
|
||
store_by_pieces (dest_mem, tree_low_cst (len, 1),
|
||
builtin_memset_read_str,
|
||
&c, dest_align, 0);
|
||
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_mem = convert_memory_address (ptr_mode, dest_mem);
|
||
return dest_mem;
|
||
}
|
||
|
||
len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
|
||
|
||
dest_mem = get_memory_rtx (dest);
|
||
set_mem_align (dest_mem, dest_align);
|
||
dest_addr = clear_storage (dest_mem, len_rtx);
|
||
|
||
if (dest_addr == 0)
|
||
{
|
||
dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||
dest_addr = convert_memory_address (ptr_mode, dest_addr);
|
||
}
|
||
|
||
return dest_addr;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the bzero builtin. Return 0
|
||
if we failed the caller should emit a normal call. */
|
||
|
||
static rtx
|
||
expand_builtin_bzero (tree arglist)
|
||
{
|
||
tree dest, size, newarglist;
|
||
|
||
if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return NULL_RTX;
|
||
|
||
dest = TREE_VALUE (arglist);
|
||
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, convert (sizetype, size));
|
||
newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
|
||
newarglist = tree_cons (NULL_TREE, dest, newarglist);
|
||
|
||
return expand_builtin_memset (newarglist, const0_rtx, VOIDmode);
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the memcmp built-in function.
|
||
ARGLIST is the argument list for this call. Return 0 if we failed and 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_memcmp (tree exp ATTRIBUTE_UNUSED, tree arglist, rtx target,
|
||
enum machine_mode mode)
|
||
{
|
||
tree arg1, arg2, len;
|
||
const char *p1, *p2;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
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))
|
||
{
|
||
/* 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;
|
||
}
|
||
|
||
/* 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
|
||
{
|
||
rtx arg1_rtx, arg2_rtx, arg3_rtx;
|
||
rtx result;
|
||
rtx insn;
|
||
|
||
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;
|
||
|
||
#ifdef HAVE_cmpmemsi
|
||
if (HAVE_cmpmemsi)
|
||
insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
|
||
else
|
||
#endif
|
||
#ifdef HAVE_cmpstrsi
|
||
if (HAVE_cmpstrsi)
|
||
insn_mode = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
|
||
else
|
||
#endif
|
||
return 0;
|
||
|
||
/* If we don't have POINTER_TYPE, call the function. */
|
||
if (arg1_align == 0 || arg2_align == 0)
|
||
return 0;
|
||
|
||
/* 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);
|
||
|
||
arg1_rtx = get_memory_rtx (arg1);
|
||
arg2_rtx = get_memory_rtx (arg2);
|
||
arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
|
||
#ifdef HAVE_cmpmemsi
|
||
if (HAVE_cmpmemsi)
|
||
insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
|
||
GEN_INT (MIN (arg1_align, arg2_align)));
|
||
else
|
||
#endif
|
||
#ifdef HAVE_cmpstrsi
|
||
if (HAVE_cmpstrsi)
|
||
insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
|
||
GEN_INT (MIN (arg1_align, arg2_align)));
|
||
else
|
||
#endif
|
||
abort ();
|
||
|
||
if (insn)
|
||
emit_insn (insn);
|
||
else
|
||
emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
|
||
TYPE_MODE (integer_type_node), 3,
|
||
XEXP (arg1_rtx, 0), Pmode,
|
||
XEXP (arg2_rtx, 0), Pmode,
|
||
convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
|
||
TREE_UNSIGNED (sizetype)),
|
||
TYPE_MODE (sizetype));
|
||
|
||
/* Return the value in the proper mode for this function. */
|
||
mode = TYPE_MODE (TREE_TYPE (exp));
|
||
if (GET_MODE (result) == mode)
|
||
return result;
|
||
else if (target != 0)
|
||
{
|
||
convert_move (target, result, 0);
|
||
return target;
|
||
}
|
||
else
|
||
return convert_to_mode (mode, result, 0);
|
||
}
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strcmp builtin. Return 0
|
||
if we failed the caller should emit a normal call, otherwise try to get
|
||
the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg1, arg2;
|
||
const char *p1, *p2;
|
||
|
||
if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg1 = TREE_VALUE (arglist);
|
||
arg2 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
/* If both arguments are equal (and not volatile), return zero. */
|
||
if (operand_equal_p (arg1, arg2, 0))
|
||
return const0_rtx;
|
||
|
||
p1 = c_getstr (arg1);
|
||
p2 = c_getstr (arg2);
|
||
|
||
if (p1 && p2)
|
||
{
|
||
const int i = strcmp (p1, p2);
|
||
return (i < 0 ? constm1_rtx : (i > 0 ? const1_rtx : const0_rtx));
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
|
||
#ifdef HAVE_cmpstrsi
|
||
if (HAVE_cmpstrsi)
|
||
{
|
||
tree len, len1, len2;
|
||
rtx arg1_rtx, arg2_rtx, arg3_rtx;
|
||
rtx result, insn;
|
||
tree fndecl;
|
||
|
||
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;
|
||
|
||
len1 = c_strlen (arg1, 1);
|
||
len2 = c_strlen (arg2, 1);
|
||
|
||
if (len1)
|
||
len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
|
||
if (len2)
|
||
len2 = size_binop (PLUS_EXPR, ssize_int (1), 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. */
|
||
|
||
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 both arguments have side effects, we cannot optimize. */
|
||
if (!len || TREE_SIDE_EFFECTS (len))
|
||
return 0;
|
||
|
||
/* If we don't have POINTER_TYPE, call the function. */
|
||
if (arg1_align == 0 || arg2_align == 0)
|
||
return 0;
|
||
|
||
/* 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);
|
||
|
||
/* Stabilize the arguments in case gen_cmpstrsi fails. */
|
||
arg1 = save_expr (arg1);
|
||
arg2 = save_expr (arg2);
|
||
|
||
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);
|
||
|
||
/* 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. */
|
||
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);
|
||
}
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strncmp builtin. Return 0
|
||
if we failed the caller should emit a normal call, otherwise try to get
|
||
the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg1, arg2, arg3;
|
||
const char *p1, *p2;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
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))
|
||
{
|
||
/* 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;
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* If c_strlen can determine an expression for one of the string
|
||
lengths, and it doesn't have side effects, then emit cmpstrsi
|
||
using length MIN(strlen(string)+1, arg3). */
|
||
#ifdef HAVE_cmpstrsi
|
||
if (HAVE_cmpstrsi)
|
||
{
|
||
tree len, len1, len2;
|
||
rtx arg1_rtx, arg2_rtx, arg3_rtx;
|
||
rtx result, insn;
|
||
tree fndecl;
|
||
|
||
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;
|
||
|
||
len1 = c_strlen (arg1, 1);
|
||
len2 = c_strlen (arg2, 1);
|
||
|
||
if (len1)
|
||
len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
|
||
if (len2)
|
||
len2 = size_binop (PLUS_EXPR, ssize_int (1), 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. */
|
||
|
||
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 both arguments have side effects, we cannot optimize. */
|
||
if (!len || TREE_SIDE_EFFECTS (len))
|
||
return 0;
|
||
|
||
/* The actual new length parameter is MIN(len,arg3). */
|
||
len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
|
||
|
||
/* If we don't have POINTER_TYPE, call the function. */
|
||
if (arg1_align == 0 || arg2_align == 0)
|
||
return 0;
|
||
|
||
/* 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);
|
||
|
||
/* Stabilize the arguments in case gen_cmpstrsi fails. */
|
||
arg1 = save_expr (arg1);
|
||
arg2 = save_expr (arg2);
|
||
len = save_expr (len);
|
||
|
||
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);
|
||
|
||
/* 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. */
|
||
arglist = build_tree_list (NULL_TREE, len);
|
||
arglist = tree_cons (NULL_TREE, arg2, arglist);
|
||
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);
|
||
}
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strcat builtin.
|
||
Return 0 if we failed the caller should emit a normal call,
|
||
otherwise try to get the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strcat (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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 (p)
|
||
{
|
||
/* 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);
|
||
|
||
/* 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));
|
||
|
||
/* 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;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strncat builtin.
|
||
Return 0 if we failed the caller should emit a normal call,
|
||
otherwise try to get the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
else
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strspn builtin.
|
||
Return 0 if we failed the caller should emit a normal call,
|
||
otherwise try to get the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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 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;
|
||
}
|
||
}
|
||
|
||
/* Expand expression EXP, which is a call to the strcspn builtin.
|
||
Return 0 if we failed the caller should emit a normal call,
|
||
otherwise try to get the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
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 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;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to __builtin_saveregs, generating the result in TARGET,
|
||
if that's convenient. */
|
||
|
||
rtx
|
||
expand_builtin_saveregs (void)
|
||
{
|
||
rtx val, seq;
|
||
|
||
/* Don't do __builtin_saveregs more than once in a function.
|
||
Save the result of the first call and reuse it. */
|
||
if (saveregs_value != 0)
|
||
return saveregs_value;
|
||
|
||
/* When this function is called, it means that registers must be
|
||
saved on entry to this function. So we migrate the call to the
|
||
first insn of this function. */
|
||
|
||
start_sequence ();
|
||
|
||
/* Do whatever the machine needs done in this case. */
|
||
val = targetm.calls.expand_builtin_saveregs ();
|
||
|
||
seq = get_insns ();
|
||
end_sequence ();
|
||
|
||
saveregs_value = val;
|
||
|
||
/* Put the insns after the NOTE that starts the function. If this
|
||
is inside a start_sequence, make the outer-level insn chain current, so
|
||
the code is placed at the start of the function. */
|
||
push_topmost_sequence ();
|
||
emit_insn_after (seq, get_insns ());
|
||
pop_topmost_sequence ();
|
||
|
||
return val;
|
||
}
|
||
|
||
/* __builtin_args_info (N) returns word N of the arg space info
|
||
for the current function. The number and meanings of words
|
||
is controlled by the definition of CUMULATIVE_ARGS. */
|
||
|
||
static rtx
|
||
expand_builtin_args_info (tree arglist)
|
||
{
|
||
int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
|
||
int *word_ptr = (int *) ¤t_function_args_info;
|
||
|
||
if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
|
||
abort ();
|
||
|
||
if (arglist != 0)
|
||
{
|
||
if (!host_integerp (TREE_VALUE (arglist), 0))
|
||
error ("argument of `__builtin_args_info' must be constant");
|
||
else
|
||
{
|
||
HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
|
||
|
||
if (wordnum < 0 || wordnum >= nwords)
|
||
error ("argument of `__builtin_args_info' out of range");
|
||
else
|
||
return GEN_INT (word_ptr[wordnum]);
|
||
}
|
||
}
|
||
else
|
||
error ("missing argument in `__builtin_args_info'");
|
||
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* Expand ARGLIST, from a call to __builtin_next_arg. */
|
||
|
||
static rtx
|
||
expand_builtin_next_arg (tree arglist)
|
||
{
|
||
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");
|
||
|
||
return expand_binop (Pmode, add_optab,
|
||
current_function_internal_arg_pointer,
|
||
current_function_arg_offset_rtx,
|
||
NULL_RTX, 0, OPTAB_LIB_WIDEN);
|
||
}
|
||
|
||
/* Make it easier for the backends by protecting the valist argument
|
||
from multiple evaluations. */
|
||
|
||
static tree
|
||
stabilize_va_list (tree valist, int needs_lvalue)
|
||
{
|
||
if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
|
||
{
|
||
if (TREE_SIDE_EFFECTS (valist))
|
||
valist = save_expr (valist);
|
||
|
||
/* 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));
|
||
tree p2 = build_pointer_type (va_list_type_node);
|
||
|
||
valist = build1 (ADDR_EXPR, p2, valist);
|
||
valist = fold (build1 (NOP_EXPR, p1, valist));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tree pt;
|
||
|
||
if (! needs_lvalue)
|
||
{
|
||
if (! TREE_SIDE_EFFECTS (valist))
|
||
return valist;
|
||
|
||
pt = build_pointer_type (va_list_type_node);
|
||
valist = fold (build1 (ADDR_EXPR, pt, valist));
|
||
TREE_SIDE_EFFECTS (valist) = 1;
|
||
}
|
||
|
||
if (TREE_SIDE_EFFECTS (valist))
|
||
valist = save_expr (valist);
|
||
valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
|
||
valist));
|
||
}
|
||
|
||
return valist;
|
||
}
|
||
|
||
/* The "standard" definition of va_list is void*. */
|
||
|
||
tree
|
||
std_build_builtin_va_list (void)
|
||
{
|
||
return ptr_type_node;
|
||
}
|
||
|
||
/* The "standard" implementation of va_start: just assign `nextarg' to
|
||
the variable. */
|
||
|
||
void
|
||
std_expand_builtin_va_start (tree valist, rtx nextarg)
|
||
{
|
||
tree t;
|
||
|
||
t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
|
||
make_tree (ptr_type_node, nextarg));
|
||
TREE_SIDE_EFFECTS (t) = 1;
|
||
|
||
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
}
|
||
|
||
/* Expand ARGLIST, from a call to __builtin_va_start. */
|
||
|
||
static rtx
|
||
expand_builtin_va_start (tree arglist)
|
||
{
|
||
rtx nextarg;
|
||
tree chain, valist;
|
||
|
||
chain = TREE_CHAIN (arglist);
|
||
|
||
if (TREE_CHAIN (chain))
|
||
error ("too many arguments to function `va_start'");
|
||
|
||
nextarg = expand_builtin_next_arg (chain);
|
||
valist = stabilize_va_list (TREE_VALUE (arglist), 1);
|
||
|
||
#ifdef EXPAND_BUILTIN_VA_START
|
||
EXPAND_BUILTIN_VA_START (valist, nextarg);
|
||
#else
|
||
std_expand_builtin_va_start (valist, nextarg);
|
||
#endif
|
||
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* The "standard" implementation of va_arg: read the value from the
|
||
current (padded) address and increment by the (padded) size. */
|
||
|
||
rtx
|
||
std_expand_builtin_va_arg (tree valist, tree type)
|
||
{
|
||
tree addr_tree, t, type_size = NULL;
|
||
tree align, alignm1;
|
||
tree rounded_size;
|
||
rtx addr;
|
||
HOST_WIDE_INT boundary;
|
||
|
||
/* 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);
|
||
|
||
/* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
|
||
requires greater alignment, we must perform dynamic alignment. */
|
||
|
||
if (boundary > PARM_BOUNDARY)
|
||
{
|
||
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);
|
||
}
|
||
if (type == error_mark_node
|
||
|| (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
|
||
|| TREE_OVERFLOW (type_size))
|
||
rounded_size = size_zero_node;
|
||
else
|
||
rounded_size = fold (build (MULT_EXPR, sizetype,
|
||
fold (build (TRUNC_DIV_EXPR, sizetype,
|
||
fold (build (PLUS_EXPR, sizetype,
|
||
type_size, alignm1)),
|
||
align)),
|
||
align));
|
||
|
||
/* Get AP. */
|
||
addr_tree = valist;
|
||
if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
|
||
{
|
||
/* 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))))));
|
||
}
|
||
|
||
addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
|
||
addr = copy_to_reg (addr);
|
||
|
||
/* Compute new value for AP. */
|
||
if (! integer_zerop (rounded_size))
|
||
{
|
||
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);
|
||
}
|
||
|
||
return addr;
|
||
}
|
||
|
||
/* Expand __builtin_va_arg, which is not really a builtin function, but
|
||
a very special sort of operator. */
|
||
|
||
rtx
|
||
expand_builtin_va_arg (tree valist, tree type)
|
||
{
|
||
rtx addr, result;
|
||
tree promoted_type, want_va_type, have_va_type;
|
||
|
||
/* Verify that valist is of the proper type. */
|
||
|
||
want_va_type = va_list_type_node;
|
||
have_va_type = TREE_TYPE (valist);
|
||
if (TREE_CODE (want_va_type) == ARRAY_TYPE)
|
||
{
|
||
/* If va_list is an array type, the argument may have decayed
|
||
to a pointer type, e.g. by being passed to another function.
|
||
In that case, unwrap both types so that we can compare the
|
||
underlying records. */
|
||
if (TREE_CODE (have_va_type) == ARRAY_TYPE
|
||
|| TREE_CODE (have_va_type) == POINTER_TYPE)
|
||
{
|
||
want_va_type = TREE_TYPE (want_va_type);
|
||
have_va_type = TREE_TYPE (have_va_type);
|
||
}
|
||
}
|
||
if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
|
||
{
|
||
error ("first argument to `va_arg' not of type `va_list'");
|
||
addr = const0_rtx;
|
||
}
|
||
|
||
/* Generate a diagnostic for requesting data of a type that cannot
|
||
be passed through `...' due to type promotion at the call site. */
|
||
else if ((promoted_type = (*lang_hooks.types.type_promotes_to) (type))
|
||
!= type)
|
||
{
|
||
const char *name = "<anonymous type>", *pname = 0;
|
||
static bool gave_help;
|
||
|
||
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)));
|
||
}
|
||
|
||
/* Unfortunately, this is merely undefined, rather than a constraint
|
||
violation, so we cannot make this an error. If this call is never
|
||
executed, the program is still strictly conforming. */
|
||
warning ("`%s' is promoted to `%s' when passed through `...'",
|
||
name, pname);
|
||
if (! gave_help)
|
||
{
|
||
gave_help = true;
|
||
warning ("(so you should pass `%s' not `%s' to `va_arg')",
|
||
pname, name);
|
||
}
|
||
|
||
/* We can, however, treat "undefined" any way we please.
|
||
Call abort to encourage the user to fix the program. */
|
||
inform ("if this code is reached, the program will abort");
|
||
expand_builtin_trap ();
|
||
|
||
/* This is dead code, but go ahead and finish so that the
|
||
mode of the result comes out right. */
|
||
addr = const0_rtx;
|
||
}
|
||
else
|
||
{
|
||
/* Make it easier for the backends by protecting the valist argument
|
||
from multiple evaluations. */
|
||
valist = stabilize_va_list (valist, 0);
|
||
|
||
#ifdef EXPAND_BUILTIN_VA_ARG
|
||
addr = EXPAND_BUILTIN_VA_ARG (valist, type);
|
||
#else
|
||
addr = std_expand_builtin_va_arg (valist, type);
|
||
#endif
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
/* Expand ARGLIST, from a call to __builtin_va_end. */
|
||
|
||
static rtx
|
||
expand_builtin_va_end (tree arglist)
|
||
{
|
||
tree valist = TREE_VALUE (arglist);
|
||
|
||
/* Evaluate for side effects, if needed. I hate macros that don't
|
||
do that. */
|
||
if (TREE_SIDE_EFFECTS (valist))
|
||
expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
|
||
builtin rather than just as an assignment in stdarg.h because of the
|
||
nastiness of array-type va_list types. */
|
||
|
||
static rtx
|
||
expand_builtin_va_copy (tree arglist)
|
||
{
|
||
tree dst, src, t;
|
||
|
||
dst = TREE_VALUE (arglist);
|
||
src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
dst = stabilize_va_list (dst, 1);
|
||
src = stabilize_va_list (src, 0);
|
||
|
||
if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
|
||
{
|
||
t = build (MODIFY_EXPR, va_list_type_node, dst, src);
|
||
TREE_SIDE_EFFECTS (t) = 1;
|
||
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
}
|
||
else
|
||
{
|
||
rtx dstb, srcb, size;
|
||
|
||
/* Evaluate to pointers. */
|
||
dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
|
||
srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
|
||
size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
|
||
VOIDmode, EXPAND_NORMAL);
|
||
|
||
dstb = convert_memory_address (Pmode, dstb);
|
||
srcb = convert_memory_address (Pmode, srcb);
|
||
|
||
/* "Dereference" to BLKmode memories. */
|
||
dstb = gen_rtx_MEM (BLKmode, dstb);
|
||
set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
|
||
set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
|
||
srcb = gen_rtx_MEM (BLKmode, srcb);
|
||
set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
|
||
set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
|
||
|
||
/* Copy. */
|
||
emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
|
||
}
|
||
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* Expand a call to one of the builtin functions __builtin_frame_address or
|
||
__builtin_return_address. */
|
||
|
||
static rtx
|
||
expand_builtin_frame_address (tree fndecl, tree arglist)
|
||
{
|
||
/* The argument must be a nonnegative integer constant.
|
||
It counts the number of frames to scan up the stack.
|
||
The value is the return address saved in that frame. */
|
||
if (arglist == 0)
|
||
/* Warning about missing arg was already issued. */
|
||
return const0_rtx;
|
||
else if (! host_integerp (TREE_VALUE (arglist), 1))
|
||
{
|
||
if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
|
||
error ("invalid arg to `__builtin_frame_address'");
|
||
else
|
||
error ("invalid arg to `__builtin_return_address'");
|
||
return const0_rtx;
|
||
}
|
||
else
|
||
{
|
||
rtx tem
|
||
= expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
|
||
tree_low_cst (TREE_VALUE (arglist), 1),
|
||
hard_frame_pointer_rtx);
|
||
|
||
/* Some ports cannot access arbitrary stack frames. */
|
||
if (tem == NULL)
|
||
{
|
||
if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
|
||
warning ("unsupported arg to `__builtin_frame_address'");
|
||
else
|
||
warning ("unsupported arg to `__builtin_return_address'");
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* For __builtin_frame_address, return what we've got. */
|
||
if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
|
||
return tem;
|
||
|
||
if (GET_CODE (tem) != REG
|
||
&& ! CONSTANT_P (tem))
|
||
tem = copy_to_mode_reg (Pmode, tem);
|
||
return tem;
|
||
}
|
||
}
|
||
|
||
/* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
|
||
we failed and the caller should emit a normal call, otherwise try to get
|
||
the result in TARGET, if convenient. */
|
||
|
||
static rtx
|
||
expand_builtin_alloca (tree arglist, rtx target)
|
||
{
|
||
rtx op0;
|
||
rtx result;
|
||
|
||
if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
/* Compute the argument. */
|
||
op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
|
||
|
||
/* Allocate the desired space. */
|
||
result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
|
||
result = convert_memory_address (ptr_mode, result);
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Expand a call to a unary builtin. The arguments are in ARGLIST.
|
||
Return 0 if a normal call should be emitted rather than expanding the
|
||
function in-line. 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_unop (enum machine_mode target_mode, tree arglist, rtx target,
|
||
rtx subtarget, optab op_optab)
|
||
{
|
||
rtx op0;
|
||
if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
/* Compute the argument. */
|
||
op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
|
||
/* Compute op, into TARGET if possible.
|
||
Set TARGET to wherever the result comes back. */
|
||
target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
|
||
op_optab, op0, target, 1);
|
||
if (target == 0)
|
||
abort ();
|
||
|
||
return convert_to_mode (target_mode, target, 0);
|
||
}
|
||
|
||
/* If the string passed to fputs is a constant and is one character
|
||
long, we attempt to transform this call into __builtin_fputc(). */
|
||
|
||
static rtx
|
||
expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
|
||
{
|
||
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;
|
||
|
||
/* Verify the arguments in the original call. */
|
||
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))
|
||
{
|
||
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 ();
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* Expand a call to __builtin_expect. We return our argument and emit a
|
||
NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
|
||
a non-jump context. */
|
||
|
||
static rtx
|
||
expand_builtin_expect (tree arglist, rtx target)
|
||
{
|
||
tree exp, c;
|
||
rtx note, rtx_c;
|
||
|
||
if (arglist == NULL_TREE
|
||
|| TREE_CHAIN (arglist) == NULL_TREE)
|
||
return const0_rtx;
|
||
exp = TREE_VALUE (arglist);
|
||
c = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
if (TREE_CODE (c) != INTEGER_CST)
|
||
{
|
||
error ("second arg to `__builtin_expect' must be a constant");
|
||
c = integer_zero_node;
|
||
}
|
||
|
||
target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
|
||
|
||
/* Don't bother with expected value notes for integral constants. */
|
||
if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
|
||
{
|
||
/* We do need to force this into a register so that we can be
|
||
moderately sure to be able to correctly interpret the branch
|
||
condition later. */
|
||
target = force_reg (GET_MODE (target), target);
|
||
|
||
rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
|
||
|
||
note = emit_note (NOTE_INSN_EXPECTED_VALUE);
|
||
NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
/* Like expand_builtin_expect, except do this in a jump context. This is
|
||
called from do_jump if the conditional is a __builtin_expect. Return either
|
||
a list of insns to emit the jump or NULL if we cannot optimize
|
||
__builtin_expect. We need to optimize this at jump time so that machines
|
||
like the PowerPC don't turn the test into a SCC operation, and then jump
|
||
based on the test being 0/1. */
|
||
|
||
rtx
|
||
expand_builtin_expect_jump (tree exp, rtx if_false_label, rtx if_true_label)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg0 = TREE_VALUE (arglist);
|
||
tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
rtx ret = NULL_RTX;
|
||
|
||
/* Only handle __builtin_expect (test, 0) and
|
||
__builtin_expect (test, 1). */
|
||
if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
|
||
&& (integer_zerop (arg1) || integer_onep (arg1)))
|
||
{
|
||
rtx insn, drop_through_label, temp;
|
||
|
||
/* Expand the jump insns. */
|
||
start_sequence ();
|
||
do_jump (arg0, if_false_label, if_true_label);
|
||
ret = get_insns ();
|
||
|
||
drop_through_label = get_last_insn ();
|
||
if (drop_through_label && GET_CODE (drop_through_label) == NOTE)
|
||
drop_through_label = prev_nonnote_insn (drop_through_label);
|
||
if (drop_through_label && GET_CODE (drop_through_label) != CODE_LABEL)
|
||
drop_through_label = NULL_RTX;
|
||
end_sequence ();
|
||
|
||
if (! if_true_label)
|
||
if_true_label = drop_through_label;
|
||
if (! if_false_label)
|
||
if_false_label = drop_through_label;
|
||
|
||
/* Go through and add the expect's to each of the conditional jumps. */
|
||
insn = ret;
|
||
while (insn != NULL_RTX)
|
||
{
|
||
rtx next = NEXT_INSN (insn);
|
||
|
||
if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn))
|
||
{
|
||
rtx ifelse = SET_SRC (pc_set (insn));
|
||
rtx then_dest = XEXP (ifelse, 1);
|
||
rtx else_dest = XEXP (ifelse, 2);
|
||
int taken = -1;
|
||
|
||
/* First check if we recognize any of the labels. */
|
||
if (GET_CODE (then_dest) == LABEL_REF
|
||
&& XEXP (then_dest, 0) == if_true_label)
|
||
taken = 1;
|
||
else if (GET_CODE (then_dest) == LABEL_REF
|
||
&& XEXP (then_dest, 0) == if_false_label)
|
||
taken = 0;
|
||
else if (GET_CODE (else_dest) == LABEL_REF
|
||
&& XEXP (else_dest, 0) == if_false_label)
|
||
taken = 1;
|
||
else if (GET_CODE (else_dest) == LABEL_REF
|
||
&& XEXP (else_dest, 0) == if_true_label)
|
||
taken = 0;
|
||
/* Otherwise check where we drop through. */
|
||
else if (else_dest == pc_rtx)
|
||
{
|
||
if (next && GET_CODE (next) == NOTE)
|
||
next = next_nonnote_insn (next);
|
||
|
||
if (next && GET_CODE (next) == JUMP_INSN
|
||
&& any_uncondjump_p (next))
|
||
temp = XEXP (SET_SRC (pc_set (next)), 0);
|
||
else
|
||
temp = next;
|
||
|
||
/* TEMP is either a CODE_LABEL, NULL_RTX or something
|
||
else that can't possibly match either target label. */
|
||
if (temp == if_false_label)
|
||
taken = 1;
|
||
else if (temp == if_true_label)
|
||
taken = 0;
|
||
}
|
||
else if (then_dest == pc_rtx)
|
||
{
|
||
if (next && GET_CODE (next) == NOTE)
|
||
next = next_nonnote_insn (next);
|
||
|
||
if (next && GET_CODE (next) == JUMP_INSN
|
||
&& any_uncondjump_p (next))
|
||
temp = XEXP (SET_SRC (pc_set (next)), 0);
|
||
else
|
||
temp = next;
|
||
|
||
if (temp == if_false_label)
|
||
taken = 0;
|
||
else if (temp == if_true_label)
|
||
taken = 1;
|
||
}
|
||
|
||
if (taken != -1)
|
||
{
|
||
/* If the test is expected to fail, reverse the
|
||
probabilities. */
|
||
if (integer_zerop (arg1))
|
||
taken = 1 - taken;
|
||
predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
|
||
}
|
||
}
|
||
|
||
insn = next;
|
||
}
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
void
|
||
expand_builtin_trap (void)
|
||
{
|
||
#ifdef HAVE_trap
|
||
if (HAVE_trap)
|
||
emit_insn (gen_trap ());
|
||
else
|
||
#endif
|
||
emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
|
||
emit_barrier ();
|
||
}
|
||
|
||
/* Expand a call to fabs, fabsf or fabsl 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. SUBTARGET may be used as the target for computing
|
||
the operand. */
|
||
|
||
static rtx
|
||
expand_builtin_fabs (tree arglist, rtx target, rtx subtarget)
|
||
{
|
||
enum machine_mode mode;
|
||
tree arg;
|
||
rtx op0;
|
||
|
||
if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg = TREE_VALUE (arglist);
|
||
mode = TYPE_MODE (TREE_TYPE (arg));
|
||
op0 = expand_expr (arg, subtarget, VOIDmode, 0);
|
||
return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
|
||
}
|
||
|
||
/* 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. */
|
||
|
||
static rtx
|
||
expand_builtin_cabs (tree arglist, rtx target)
|
||
{
|
||
enum machine_mode mode;
|
||
tree arg;
|
||
rtx op0;
|
||
|
||
if (arglist == 0 || TREE_CHAIN (arglist))
|
||
return 0;
|
||
arg = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
|
||
|| TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
|
||
return 0;
|
||
|
||
mode = TYPE_MODE (TREE_TYPE (arg));
|
||
op0 = expand_expr (arg, NULL_RTX, VOIDmode, 0);
|
||
return expand_complex_abs (mode, op0, target, 0);
|
||
}
|
||
|
||
/* Create a new constant string literal and return a char* pointer to it.
|
||
The STRING_CST value is the LEN characters at STR. */
|
||
static tree
|
||
build_string_literal (int len, const char *str)
|
||
{
|
||
tree t, elem, index, type;
|
||
|
||
t = build_string (len, str);
|
||
elem = build_type_variant (char_type_node, 1, 0);
|
||
index = build_index_type (build_int_2 (len - 1, 0));
|
||
type = build_array_type (elem, index);
|
||
TREE_TYPE (t) = type;
|
||
TREE_CONSTANT (t) = 1;
|
||
TREE_READONLY (t) = 1;
|
||
TREE_STATIC (t) = 1;
|
||
|
||
type = build_pointer_type (type);
|
||
t = build1 (ADDR_EXPR, type, t);
|
||
|
||
type = build_pointer_type (elem);
|
||
t = build1 (NOP_EXPR, type, t);
|
||
return t;
|
||
}
|
||
|
||
/* Expand a call to printf or printf_unlocked with argument list ARGLIST.
|
||
Return 0 if a normal call should be emitted rather than transforming
|
||
the function inline. If convenient, the result should be placed in
|
||
TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
|
||
call. */
|
||
static rtx
|
||
expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode,
|
||
bool unlocked)
|
||
{
|
||
/* If we're using an unlocked function, assume the other unlocked
|
||
functions exist explicitly. */
|
||
tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
|
||
: implicit_built_in_decls[BUILT_IN_PUTCHAR];
|
||
tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
|
||
: implicit_built_in_decls[BUILT_IN_PUTS];
|
||
const char *fmt_str;
|
||
tree fn, fmt, arg;
|
||
|
||
/* If the return value is used, don't do the transformation. */
|
||
if (target != const0_rtx)
|
||
return 0;
|
||
|
||
/* Verify the required arguments in the original call. */
|
||
if (! arglist)
|
||
return 0;
|
||
fmt = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
|
||
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 0;
|
||
|
||
/* If the format specifier was "%s\n", call __builtin_puts(arg). */
|
||
if (strcmp (fmt_str, "%s\n") == 0)
|
||
{
|
||
if (! arglist
|
||
|| TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
|
||
|| TREE_CHAIN (arglist))
|
||
return 0;
|
||
fn = fn_puts;
|
||
}
|
||
/* If the format specifier was "%c", call __builtin_putchar(arg). */
|
||
else if (strcmp (fmt_str, "%c") == 0)
|
||
{
|
||
if (! arglist
|
||
|| TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
|
||
|| TREE_CHAIN (arglist))
|
||
return 0;
|
||
fn = fn_putchar;
|
||
}
|
||
else
|
||
{
|
||
/* We can't handle anything else with % args or %% ... yet. */
|
||
if (strchr (fmt_str, '%'))
|
||
return 0;
|
||
|
||
if (arglist)
|
||
return 0;
|
||
|
||
/* If the format specifier was "", printf does nothing. */
|
||
if (fmt_str[0] == '\0')
|
||
return const0_rtx;
|
||
/* If the format specifier has length of 1, call putchar. */
|
||
if (fmt_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_2 (fmt_str[0], 0);
|
||
arglist = build_tree_list (NULL_TREE, arg);
|
||
fn = fn_putchar;
|
||
}
|
||
else
|
||
{
|
||
/* If the format specifier was "string\n", call puts("string"). */
|
||
size_t len = strlen (fmt_str);
|
||
if (fmt_str[len - 1] == '\n')
|
||
{
|
||
/* Create a NUL-terminated string that's one char shorter
|
||
than the original, stripping off the trailing '\n'. */
|
||
char *newstr = (char *) alloca (len);
|
||
memcpy (newstr, fmt_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;
|
||
}
|
||
}
|
||
|
||
if (!fn)
|
||
return 0;
|
||
return expand_expr (build_function_call_expr (fn, arglist),
|
||
target, mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
/* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
|
||
Return 0 if a normal call should be emitted rather than transforming
|
||
the function inline. If convenient, the result should be placed in
|
||
TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
|
||
call. */
|
||
static rtx
|
||
expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode,
|
||
bool unlocked)
|
||
{
|
||
/* 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_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
|
||
: implicit_built_in_decls[BUILT_IN_FPUTS];
|
||
const char *fmt_str;
|
||
tree fn, fmt, fp, arg;
|
||
|
||
/* If the return value is used, don't do the transformation. */
|
||
if (target != const0_rtx)
|
||
return 0;
|
||
|
||
/* Verify the required arguments in the original call. */
|
||
if (! arglist)
|
||
return 0;
|
||
fp = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (fp)) != POINTER_TYPE)
|
||
return 0;
|
||
arglist = TREE_CHAIN (arglist);
|
||
if (! arglist)
|
||
return 0;
|
||
fmt = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
|
||
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 0;
|
||
|
||
/* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
|
||
if (strcmp (fmt_str, "%s") == 0)
|
||
{
|
||
if (! arglist
|
||
|| TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_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_fputs;
|
||
}
|
||
/* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
|
||
else if (strcmp (fmt_str, "%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;
|
||
}
|
||
else
|
||
{
|
||
/* We can't handle anything else with % args or %% ... yet. */
|
||
if (strchr (fmt_str, '%'))
|
||
return 0;
|
||
|
||
if (arglist)
|
||
return 0;
|
||
|
||
/* If the format specifier was "", fprintf does nothing. */
|
||
if (fmt_str[0] == '\0')
|
||
{
|
||
/* Evaluate and ignore FILE* argument for side-effects. */
|
||
expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
return const0_rtx;
|
||
}
|
||
|
||
/* When "string" doesn't contain %, replace all cases of
|
||
fprintf(stream,string) with fputs(string,stream). 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;
|
||
}
|
||
|
||
if (!fn)
|
||
return 0;
|
||
return expand_expr (build_function_call_expr (fn, arglist),
|
||
target, mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
/* Expand a call to sprintf with argument list 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 with
|
||
mode MODE. */
|
||
|
||
static rtx
|
||
expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
|
||
{
|
||
tree orig_arglist, dest, fmt;
|
||
const char *fmt_str;
|
||
|
||
orig_arglist = arglist;
|
||
|
||
/* Verify the required arguments in the original call. */
|
||
if (! arglist)
|
||
return 0;
|
||
dest = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (dest)) != POINTER_TYPE)
|
||
return 0;
|
||
arglist = TREE_CHAIN (arglist);
|
||
if (! arglist)
|
||
return 0;
|
||
fmt = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (fmt)) != POINTER_TYPE)
|
||
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 0;
|
||
|
||
/* If the format doesn't contain % args or %%, use strcpy. */
|
||
if (strchr (fmt_str, '%') == 0)
|
||
{
|
||
tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
|
||
tree exp;
|
||
|
||
if (arglist || ! fn)
|
||
return 0;
|
||
expand_expr (build_function_call_expr (fn, orig_arglist),
|
||
const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
if (target == const0_rtx)
|
||
return const0_rtx;
|
||
exp = build_int_2 (strlen (fmt_str), 0);
|
||
exp = fold (build1 (NOP_EXPR, integer_type_node, exp));
|
||
return expand_expr (exp, target, mode, EXPAND_NORMAL);
|
||
}
|
||
/* If the format is "%s", use strcpy if the result isn't used. */
|
||
else if (strcmp (fmt_str, "%s") == 0)
|
||
{
|
||
tree fn, arg, len;
|
||
fn = implicit_built_in_decls[BUILT_IN_STRCPY];
|
||
|
||
if (! fn)
|
||
return 0;
|
||
|
||
if (! arglist || TREE_CHAIN (arglist))
|
||
return 0;
|
||
arg = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
|
||
return 0;
|
||
|
||
if (target != const0_rtx)
|
||
{
|
||
len = c_strlen (arg, 1);
|
||
if (! len || TREE_CODE (len) != INTEGER_CST)
|
||
return 0;
|
||
}
|
||
else
|
||
len = NULL_TREE;
|
||
|
||
arglist = build_tree_list (NULL_TREE, arg);
|
||
arglist = tree_cons (NULL_TREE, dest, arglist);
|
||
expand_expr (build_function_call_expr (fn, arglist),
|
||
const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||
|
||
if (target == const0_rtx)
|
||
return const0_rtx;
|
||
return expand_expr (len, target, mode, EXPAND_NORMAL);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Expand an expression EXP that calls a built-in function,
|
||
with result going to TARGET if that's convenient
|
||
(and in mode MODE if that's convenient).
|
||
SUBTARGET may be used as the target for computing one of EXP's operands.
|
||
IGNORE is nonzero if the value is to be ignored. */
|
||
|
||
rtx
|
||
expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
|
||
int ignore)
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
|
||
enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
|
||
|
||
/* Perform postincrements before expanding builtin functions. */
|
||
emit_queue ();
|
||
|
||
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
|
||
return (*targetm.expand_builtin) (exp, target, subtarget, mode, ignore);
|
||
|
||
/* When not optimizing, generate calls to library functions for a certain
|
||
set of builtins. */
|
||
if (!optimize
|
||
&& !CALLED_AS_BUILT_IN (fndecl)
|
||
&& DECL_ASSEMBLER_NAME_SET_P (fndecl)
|
||
&& fcode != BUILT_IN_ALLOCA)
|
||
return expand_call (exp, target, ignore);
|
||
|
||
/* The built-in function expanders test for target == const0_rtx
|
||
to determine whether the function's result will be ignored. */
|
||
if (ignore)
|
||
target = const0_rtx;
|
||
|
||
/* If the result of a pure or const built-in function is ignored, and
|
||
none of its arguments are volatile, we can avoid expanding the
|
||
built-in call and just evaluate the arguments for side-effects. */
|
||
if (target == const0_rtx
|
||
&& (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
|
||
{
|
||
bool volatilep = false;
|
||
tree arg;
|
||
|
||
for (arg = arglist; arg; arg = TREE_CHAIN (arg))
|
||
if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
|
||
{
|
||
volatilep = true;
|
||
break;
|
||
}
|
||
|
||
if (! volatilep)
|
||
{
|
||
for (arg = arglist; arg; arg = TREE_CHAIN (arg))
|
||
expand_expr (TREE_VALUE (arg), const0_rtx,
|
||
VOIDmode, EXPAND_NORMAL);
|
||
return const0_rtx;
|
||
}
|
||
}
|
||
|
||
switch (fcode)
|
||
{
|
||
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:
|
||
target = expand_builtin_fabs (arglist, target, subtarget);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
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;
|
||
}
|
||
break;
|
||
|
||
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 ();
|
||
|
||
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:
|
||
/* Treat these like sqrt only if unsafe math optimizations are allowed,
|
||
because of possible accuracy problems. */
|
||
if (! flag_unsafe_math_optimizations)
|
||
break;
|
||
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:
|
||
target = expand_builtin_mathfn (exp, target, subtarget);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_POW:
|
||
case BUILT_IN_POWF:
|
||
case BUILT_IN_POWL:
|
||
if (! flag_unsafe_math_optimizations)
|
||
break;
|
||
target = expand_builtin_pow (exp, target, subtarget);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_ATAN2:
|
||
case BUILT_IN_ATAN2F:
|
||
case BUILT_IN_ATAN2L:
|
||
if (! flag_unsafe_math_optimizations)
|
||
break;
|
||
target = expand_builtin_mathfn_2 (exp, target, subtarget);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_APPLY_ARGS:
|
||
return expand_builtin_apply_args ();
|
||
|
||
/* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
|
||
FUNCTION with a copy of the parameters described by
|
||
ARGUMENTS, and ARGSIZE. It returns a block of memory
|
||
allocated on the stack into which is stored all the registers
|
||
that might possibly be used for returning the result of a
|
||
function. ARGUMENTS is the value returned by
|
||
__builtin_apply_args. ARGSIZE is the number of bytes of
|
||
arguments that must be copied. ??? How should this value be
|
||
computed? We'll also need a safe worst case value for varargs
|
||
functions. */
|
||
case BUILT_IN_APPLY:
|
||
if (!validate_arglist (arglist, POINTER_TYPE,
|
||
POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
|
||
&& !validate_arglist (arglist, REFERENCE_TYPE,
|
||
POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return const0_rtx;
|
||
else
|
||
{
|
||
int i;
|
||
tree t;
|
||
rtx ops[3];
|
||
|
||
for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
|
||
ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
|
||
|
||
return expand_builtin_apply (ops[0], ops[1], ops[2]);
|
||
}
|
||
|
||
/* __builtin_return (RESULT) causes the function to return the
|
||
value described by RESULT. RESULT is address of the block of
|
||
memory returned by __builtin_apply. */
|
||
case BUILT_IN_RETURN:
|
||
if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
|
||
expand_builtin_return (expand_expr (TREE_VALUE (arglist),
|
||
NULL_RTX, VOIDmode, 0));
|
||
return const0_rtx;
|
||
|
||
case BUILT_IN_SAVEREGS:
|
||
return expand_builtin_saveregs ();
|
||
|
||
case BUILT_IN_ARGS_INFO:
|
||
return expand_builtin_args_info (arglist);
|
||
|
||
/* Return the address of the first anonymous stack arg. */
|
||
case BUILT_IN_NEXT_ARG:
|
||
return expand_builtin_next_arg (arglist);
|
||
|
||
case BUILT_IN_CLASSIFY_TYPE:
|
||
return expand_builtin_classify_type (arglist);
|
||
|
||
case BUILT_IN_CONSTANT_P:
|
||
return expand_builtin_constant_p (arglist, target_mode);
|
||
|
||
case BUILT_IN_FRAME_ADDRESS:
|
||
case BUILT_IN_RETURN_ADDRESS:
|
||
return expand_builtin_frame_address (fndecl, arglist);
|
||
|
||
/* Returns the address of the area where the structure is returned.
|
||
0 otherwise. */
|
||
case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
|
||
if (arglist != 0
|
||
|| ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
|
||
|| GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
|
||
return const0_rtx;
|
||
else
|
||
return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
|
||
|
||
case BUILT_IN_ALLOCA:
|
||
target = expand_builtin_alloca (arglist, target);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_FFS:
|
||
case BUILT_IN_FFSL:
|
||
case BUILT_IN_FFSLL:
|
||
target = expand_builtin_unop (target_mode, arglist, target,
|
||
subtarget, ffs_optab);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_CLZ:
|
||
case BUILT_IN_CLZL:
|
||
case BUILT_IN_CLZLL:
|
||
target = expand_builtin_unop (target_mode, arglist, target,
|
||
subtarget, clz_optab);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_CTZ:
|
||
case BUILT_IN_CTZL:
|
||
case BUILT_IN_CTZLL:
|
||
target = expand_builtin_unop (target_mode, arglist, target,
|
||
subtarget, ctz_optab);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_POPCOUNT:
|
||
case BUILT_IN_POPCOUNTL:
|
||
case BUILT_IN_POPCOUNTLL:
|
||
target = expand_builtin_unop (target_mode, arglist, target,
|
||
subtarget, popcount_optab);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_PARITY:
|
||
case BUILT_IN_PARITYL:
|
||
case BUILT_IN_PARITYLL:
|
||
target = expand_builtin_unop (target_mode, arglist, target,
|
||
subtarget, parity_optab);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRLEN:
|
||
target = expand_builtin_strlen (arglist, target, target_mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRCPY:
|
||
target = expand_builtin_strcpy (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRNCPY:
|
||
target = expand_builtin_strncpy (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STPCPY:
|
||
target = expand_builtin_stpcpy (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRCAT:
|
||
target = expand_builtin_strcat (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRNCAT:
|
||
target = expand_builtin_strncat (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRSPN:
|
||
target = expand_builtin_strspn (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRCSPN:
|
||
target = expand_builtin_strcspn (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRSTR:
|
||
target = expand_builtin_strstr (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRPBRK:
|
||
target = expand_builtin_strpbrk (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_INDEX:
|
||
case BUILT_IN_STRCHR:
|
||
target = expand_builtin_strchr (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_RINDEX:
|
||
case BUILT_IN_STRRCHR:
|
||
target = expand_builtin_strrchr (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_MEMCPY:
|
||
target = expand_builtin_memcpy (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_MEMPCPY:
|
||
target = expand_builtin_mempcpy (arglist, target, mode, /*endp=*/ 1);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_MEMMOVE:
|
||
target = expand_builtin_memmove (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_BCOPY:
|
||
target = expand_builtin_bcopy (arglist);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_MEMSET:
|
||
target = expand_builtin_memset (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_BZERO:
|
||
target = expand_builtin_bzero (arglist);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRCMP:
|
||
target = expand_builtin_strcmp (exp, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_STRNCMP:
|
||
target = expand_builtin_strncmp (exp, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_BCMP:
|
||
case BUILT_IN_MEMCMP:
|
||
target = expand_builtin_memcmp (exp, arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_SETJMP:
|
||
target = expand_builtin_setjmp (arglist, target);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
/* __builtin_longjmp is passed a pointer to an array of five words.
|
||
It's similar to the C library longjmp function but works with
|
||
__builtin_setjmp above. */
|
||
case BUILT_IN_LONGJMP:
|
||
if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
break;
|
||
else
|
||
{
|
||
rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
|
||
VOIDmode, 0);
|
||
rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
|
||
NULL_RTX, VOIDmode, 0);
|
||
|
||
if (value != const1_rtx)
|
||
{
|
||
error ("__builtin_longjmp second argument must be 1");
|
||
return const0_rtx;
|
||
}
|
||
|
||
expand_builtin_longjmp (buf_addr, value);
|
||
return const0_rtx;
|
||
}
|
||
|
||
case BUILT_IN_TRAP:
|
||
expand_builtin_trap ();
|
||
return const0_rtx;
|
||
|
||
case BUILT_IN_PRINTF:
|
||
target = expand_builtin_printf (arglist, target, mode, false);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_PRINTF_UNLOCKED:
|
||
target = expand_builtin_printf (arglist, target, mode, true);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_FPUTS:
|
||
target = expand_builtin_fputs (arglist, target, false);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_FPUTS_UNLOCKED:
|
||
target = expand_builtin_fputs (arglist, target, true);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_FPRINTF:
|
||
target = expand_builtin_fprintf (arglist, target, mode, false);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_FPRINTF_UNLOCKED:
|
||
target = expand_builtin_fprintf (arglist, target, mode, true);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
case BUILT_IN_SPRINTF:
|
||
target = expand_builtin_sprintf (arglist, target, mode);
|
||
if (target)
|
||
return target;
|
||
break;
|
||
|
||
/* Various hooks for the DWARF 2 __throw routine. */
|
||
case BUILT_IN_UNWIND_INIT:
|
||
expand_builtin_unwind_init ();
|
||
return const0_rtx;
|
||
case BUILT_IN_DWARF_CFA:
|
||
return virtual_cfa_rtx;
|
||
#ifdef DWARF2_UNWIND_INFO
|
||
case BUILT_IN_DWARF_SP_COLUMN:
|
||
return expand_builtin_dwarf_sp_column ();
|
||
case BUILT_IN_INIT_DWARF_REG_SIZES:
|
||
expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
|
||
return const0_rtx;
|
||
#endif
|
||
case BUILT_IN_FROB_RETURN_ADDR:
|
||
return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
|
||
case BUILT_IN_EXTRACT_RETURN_ADDR:
|
||
return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
|
||
case BUILT_IN_EH_RETURN:
|
||
expand_builtin_eh_return (TREE_VALUE (arglist),
|
||
TREE_VALUE (TREE_CHAIN (arglist)));
|
||
return const0_rtx;
|
||
#ifdef EH_RETURN_DATA_REGNO
|
||
case BUILT_IN_EH_RETURN_DATA_REGNO:
|
||
return expand_builtin_eh_return_data_regno (arglist);
|
||
#endif
|
||
case BUILT_IN_EXTEND_POINTER:
|
||
return expand_builtin_extend_pointer (TREE_VALUE (arglist));
|
||
|
||
case BUILT_IN_VA_START:
|
||
case BUILT_IN_STDARG_START:
|
||
return expand_builtin_va_start (arglist);
|
||
case BUILT_IN_VA_END:
|
||
return expand_builtin_va_end (arglist);
|
||
case BUILT_IN_VA_COPY:
|
||
return expand_builtin_va_copy (arglist);
|
||
case BUILT_IN_EXPECT:
|
||
return expand_builtin_expect (arglist, target);
|
||
case BUILT_IN_PREFETCH:
|
||
expand_builtin_prefetch (arglist);
|
||
return const0_rtx;
|
||
|
||
|
||
default: /* just do library call, if unknown builtin */
|
||
if (!DECL_ASSEMBLER_NAME_SET_P (fndecl))
|
||
error ("built-in function `%s' not currently supported",
|
||
IDENTIFIER_POINTER (DECL_NAME (fndecl)));
|
||
}
|
||
|
||
/* The switch statement above can drop through to cause the function
|
||
to be called normally. */
|
||
return expand_call (exp, target, ignore);
|
||
}
|
||
|
||
/* Determine whether a tree node represents a call to a built-in
|
||
function. If the tree T is a call to a built-in function with
|
||
the right number of arguments of the appropriate types, return
|
||
the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
|
||
Otherwise the return value is END_BUILTINS. */
|
||
|
||
enum built_in_function
|
||
builtin_mathfn_code (tree t)
|
||
{
|
||
tree fndecl, arglist, parmlist;
|
||
tree argtype, parmtype;
|
||
|
||
if (TREE_CODE (t) != CALL_EXPR
|
||
|| TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
|
||
return END_BUILTINS;
|
||
|
||
fndecl = get_callee_fndecl (t);
|
||
if (fndecl == NULL_TREE
|
||
|| TREE_CODE (fndecl) != FUNCTION_DECL
|
||
|| ! DECL_BUILT_IN (fndecl)
|
||
|| DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
|
||
return END_BUILTINS;
|
||
|
||
arglist = TREE_OPERAND (t, 1);
|
||
parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
||
for (; parmlist; parmlist = TREE_CHAIN (parmlist))
|
||
{
|
||
/* If a function doesn't take a variable number of arguments,
|
||
the last element in the list will have type `void'. */
|
||
parmtype = TREE_VALUE (parmlist);
|
||
if (VOID_TYPE_P (parmtype))
|
||
{
|
||
if (arglist)
|
||
return END_BUILTINS;
|
||
return DECL_FUNCTION_CODE (fndecl);
|
||
}
|
||
|
||
if (! arglist)
|
||
return END_BUILTINS;
|
||
|
||
argtype = TREE_TYPE (TREE_VALUE (arglist));
|
||
|
||
if (SCALAR_FLOAT_TYPE_P (parmtype))
|
||
{
|
||
if (! SCALAR_FLOAT_TYPE_P (argtype))
|
||
return END_BUILTINS;
|
||
}
|
||
else if (COMPLEX_FLOAT_TYPE_P (parmtype))
|
||
{
|
||
if (! COMPLEX_FLOAT_TYPE_P (argtype))
|
||
return END_BUILTINS;
|
||
}
|
||
else if (POINTER_TYPE_P (parmtype))
|
||
{
|
||
if (! POINTER_TYPE_P (argtype))
|
||
return END_BUILTINS;
|
||
}
|
||
else if (INTEGRAL_TYPE_P (parmtype))
|
||
{
|
||
if (! INTEGRAL_TYPE_P (argtype))
|
||
return END_BUILTINS;
|
||
}
|
||
else
|
||
return END_BUILTINS;
|
||
|
||
arglist = TREE_CHAIN (arglist);
|
||
}
|
||
|
||
/* Variable-length argument list. */
|
||
return DECL_FUNCTION_CODE (fndecl);
|
||
}
|
||
|
||
/* Fold a call to __builtin_constant_p, if we know it will evaluate to a
|
||
constant. ARGLIST is the argument list of the call. */
|
||
|
||
static tree
|
||
fold_builtin_constant_p (tree arglist)
|
||
{
|
||
if (arglist == 0)
|
||
return 0;
|
||
|
||
arglist = TREE_VALUE (arglist);
|
||
|
||
/* We return 1 for a numeric type that's known to be a constant
|
||
value at compile-time or for an aggregate type that's a
|
||
literal constant. */
|
||
STRIP_NOPS (arglist);
|
||
|
||
/* If we know this is a constant, emit the constant of one. */
|
||
if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
|
||
|| (TREE_CODE (arglist) == CONSTRUCTOR
|
||
&& TREE_CONSTANT (arglist))
|
||
|| (TREE_CODE (arglist) == ADDR_EXPR
|
||
&& TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST))
|
||
return integer_one_node;
|
||
|
||
/* If this expression has side effects, show we don't know it to be a
|
||
constant. Likewise if it's a pointer or aggregate type since in
|
||
those case we only want literals, since those are only optimized
|
||
when generating RTL, not later.
|
||
And finally, if we are compiling an initializer, not code, we
|
||
need to return a definite result now; there's not going to be any
|
||
more optimization done. */
|
||
if (TREE_SIDE_EFFECTS (arglist)
|
||
|| AGGREGATE_TYPE_P (TREE_TYPE (arglist))
|
||
|| POINTER_TYPE_P (TREE_TYPE (arglist))
|
||
|| cfun == 0)
|
||
return integer_zero_node;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold a call to __builtin_classify_type. */
|
||
|
||
static tree
|
||
fold_builtin_classify_type (tree arglist)
|
||
{
|
||
if (arglist == 0)
|
||
return build_int_2 (no_type_class, 0);
|
||
|
||
return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
|
||
}
|
||
|
||
/* Fold a call to __builtin_inf or __builtin_huge_val. */
|
||
|
||
static tree
|
||
fold_builtin_inf (tree type, int warn)
|
||
{
|
||
REAL_VALUE_TYPE real;
|
||
|
||
if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
|
||
warning ("target format does not support infinity");
|
||
|
||
real_inf (&real);
|
||
return build_real (type, real);
|
||
}
|
||
|
||
/* Fold a call to __builtin_nan or __builtin_nans. */
|
||
|
||
static tree
|
||
fold_builtin_nan (tree arglist, tree type, int quiet)
|
||
{
|
||
REAL_VALUE_TYPE real;
|
||
const char *str;
|
||
|
||
if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
str = c_getstr (TREE_VALUE (arglist));
|
||
if (!str)
|
||
return 0;
|
||
|
||
if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
|
||
return 0;
|
||
|
||
return build_real (type, real);
|
||
}
|
||
|
||
/* Return true if the floating point expression T has an integer value.
|
||
We also allow +Inf, -Inf and NaN to be considered integer values. */
|
||
|
||
static bool
|
||
integer_valued_real_p (tree t)
|
||
{
|
||
switch (TREE_CODE (t))
|
||
{
|
||
case FLOAT_EXPR:
|
||
return true;
|
||
|
||
case ABS_EXPR:
|
||
case SAVE_EXPR:
|
||
case NON_LVALUE_EXPR:
|
||
return integer_valued_real_p (TREE_OPERAND (t, 0));
|
||
|
||
case COMPOUND_EXPR:
|
||
case MODIFY_EXPR:
|
||
case BIND_EXPR:
|
||
return integer_valued_real_p (TREE_OPERAND (t, 1));
|
||
|
||
case PLUS_EXPR:
|
||
case MINUS_EXPR:
|
||
case MULT_EXPR:
|
||
case MIN_EXPR:
|
||
case MAX_EXPR:
|
||
return integer_valued_real_p (TREE_OPERAND (t, 0))
|
||
&& integer_valued_real_p (TREE_OPERAND (t, 1));
|
||
|
||
case COND_EXPR:
|
||
return integer_valued_real_p (TREE_OPERAND (t, 1))
|
||
&& integer_valued_real_p (TREE_OPERAND (t, 2));
|
||
|
||
case REAL_CST:
|
||
if (! TREE_CONSTANT_OVERFLOW (t))
|
||
{
|
||
REAL_VALUE_TYPE c, cint;
|
||
|
||
c = TREE_REAL_CST (t);
|
||
real_trunc (&cint, TYPE_MODE (TREE_TYPE (t)), &c);
|
||
return real_identical (&c, &cint);
|
||
}
|
||
|
||
case NOP_EXPR:
|
||
{
|
||
tree type = TREE_TYPE (TREE_OPERAND (t, 0));
|
||
if (TREE_CODE (type) == INTEGER_TYPE)
|
||
return true;
|
||
if (TREE_CODE (type) == REAL_TYPE)
|
||
return integer_valued_real_p (TREE_OPERAND (t, 0));
|
||
break;
|
||
}
|
||
|
||
case CALL_EXPR:
|
||
switch (builtin_mathfn_code (t))
|
||
{
|
||
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:
|
||
return true;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/* EXP is assumed to be builtin call where truncation can be propagated
|
||
across (for instance floor((double)f) == (double)floorf (f).
|
||
Do the transformation. */
|
||
|
||
static tree
|
||
fold_trunc_transparent_mathfn (tree exp)
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
|
||
tree arg;
|
||
|
||
if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg = TREE_VALUE (arglist);
|
||
/* Integer rounding functions are idempotent. */
|
||
if (fcode == builtin_mathfn_code (arg))
|
||
return arg;
|
||
|
||
/* 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 arg;
|
||
|
||
if (optimize)
|
||
{
|
||
tree arg0 = strip_float_extensions (arg);
|
||
tree ftype = TREE_TYPE (exp);
|
||
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 convert (ftype,
|
||
build_function_call_expr (decl, arglist));
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* 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. */
|
||
|
||
static tree
|
||
fold_builtin_cabs (tree fndecl, tree arglist, tree type)
|
||
{
|
||
tree arg;
|
||
|
||
if (!arglist || TREE_CHAIN (arglist))
|
||
return NULL_TREE;
|
||
|
||
arg = TREE_VALUE (arglist);
|
||
if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
|
||
|| TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
|
||
return NULL_TREE;
|
||
|
||
/* Evaluate cabs of a constant at compile-time. */
|
||
if (flag_unsafe_math_optimizations
|
||
&& TREE_CODE (arg) == COMPLEX_CST
|
||
&& TREE_CODE (TREE_REALPART (arg)) == REAL_CST
|
||
&& TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
|
||
&& ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
|
||
&& ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
|
||
{
|
||
REAL_VALUE_TYPE r, i;
|
||
|
||
r = TREE_REAL_CST (TREE_REALPART (arg));
|
||
i = TREE_REAL_CST (TREE_IMAGPART (arg));
|
||
|
||
real_arithmetic (&r, MULT_EXPR, &r, &r);
|
||
real_arithmetic (&i, MULT_EXPR, &i, &i);
|
||
real_arithmetic (&r, PLUS_EXPR, &r, &i);
|
||
if (real_sqrt (&r, TYPE_MODE (type), &r)
|
||
|| ! flag_trapping_math)
|
||
return build_real (type, r);
|
||
}
|
||
|
||
/* If either part is zero, cabs is fabs of the other. */
|
||
if (TREE_CODE (arg) == COMPLEX_EXPR
|
||
&& real_zerop (TREE_OPERAND (arg, 0)))
|
||
return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1)));
|
||
if (TREE_CODE (arg) == COMPLEX_EXPR
|
||
&& real_zerop (TREE_OPERAND (arg, 1)))
|
||
return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0)));
|
||
|
||
if (flag_unsafe_math_optimizations)
|
||
{
|
||
enum built_in_function fcode;
|
||
tree sqrtfn;
|
||
|
||
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;
|
||
|
||
if (sqrtfn != NULL_TREE)
|
||
{
|
||
tree rpart, ipart, result, arglist;
|
||
|
||
arg = save_expr (arg);
|
||
|
||
rpart = fold (build1 (REALPART_EXPR, type, arg));
|
||
ipart = fold (build1 (IMAGPART_EXPR, type, arg));
|
||
|
||
rpart = save_expr (rpart);
|
||
ipart = save_expr (ipart);
|
||
|
||
result = fold (build (PLUS_EXPR, type,
|
||
fold (build (MULT_EXPR, type,
|
||
rpart, rpart)),
|
||
fold (build (MULT_EXPR, type,
|
||
ipart, ipart))));
|
||
|
||
arglist = build_tree_list (NULL_TREE, result);
|
||
return build_function_call_expr (sqrtfn, arglist);
|
||
}
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Fold function call to builtin trunc, truncf or truncl. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_trunc (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg;
|
||
|
||
if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
/* Optimize trunc of constant value. */
|
||
arg = TREE_VALUE (arglist);
|
||
if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
|
||
{
|
||
REAL_VALUE_TYPE r, x;
|
||
tree type = TREE_TYPE (exp);
|
||
|
||
x = TREE_REAL_CST (arg);
|
||
real_trunc (&r, TYPE_MODE (type), &x);
|
||
return build_real (type, r);
|
||
}
|
||
|
||
return fold_trunc_transparent_mathfn (exp);
|
||
}
|
||
|
||
/* Fold function call to builtin floor, floorf or floorl. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_floor (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg;
|
||
|
||
if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
/* Optimize floor 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 (exp);
|
||
REAL_VALUE_TYPE r;
|
||
|
||
real_floor (&r, TYPE_MODE (type), &x);
|
||
return build_real (type, r);
|
||
}
|
||
}
|
||
|
||
return fold_trunc_transparent_mathfn (exp);
|
||
}
|
||
|
||
/* Fold function call to builtin ceil, ceilf or ceill. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_ceil (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg;
|
||
|
||
if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
/* Optimize ceil 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 (exp);
|
||
REAL_VALUE_TYPE r;
|
||
|
||
real_ceil (&r, TYPE_MODE (type), &x);
|
||
return build_real (type, r);
|
||
}
|
||
}
|
||
|
||
return fold_trunc_transparent_mathfn (exp);
|
||
}
|
||
|
||
/* Fold function call to builtin ffs, clz, ctz, popcount and parity
|
||
and their long and long long variants (i.e. ffsl and ffsll).
|
||
Return NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_bitop (tree exp)
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg;
|
||
|
||
if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
|
||
return NULL_TREE;
|
||
|
||
/* Optimize for constant argument. */
|
||
arg = TREE_VALUE (arglist);
|
||
if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
|
||
{
|
||
HOST_WIDE_INT hi, width, result;
|
||
unsigned HOST_WIDE_INT lo;
|
||
tree type, t;
|
||
|
||
type = TREE_TYPE (arg);
|
||
width = TYPE_PRECISION (type);
|
||
lo = TREE_INT_CST_LOW (arg);
|
||
|
||
/* Clear all the bits that are beyond the type's precision. */
|
||
if (width > HOST_BITS_PER_WIDE_INT)
|
||
{
|
||
hi = TREE_INT_CST_HIGH (arg);
|
||
if (width < 2 * HOST_BITS_PER_WIDE_INT)
|
||
hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
|
||
}
|
||
else
|
||
{
|
||
hi = 0;
|
||
if (width < HOST_BITS_PER_WIDE_INT)
|
||
lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
|
||
}
|
||
|
||
switch (DECL_FUNCTION_CODE (fndecl))
|
||
{
|
||
case BUILT_IN_FFS:
|
||
case BUILT_IN_FFSL:
|
||
case BUILT_IN_FFSLL:
|
||
if (lo != 0)
|
||
result = exact_log2 (lo & -lo) + 1;
|
||
else if (hi != 0)
|
||
result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
|
||
else
|
||
result = 0;
|
||
break;
|
||
|
||
case BUILT_IN_CLZ:
|
||
case BUILT_IN_CLZL:
|
||
case BUILT_IN_CLZLL:
|
||
if (hi != 0)
|
||
result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
|
||
else if (lo != 0)
|
||
result = width - floor_log2 (lo) - 1;
|
||
else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
|
||
result = width;
|
||
break;
|
||
|
||
case BUILT_IN_CTZ:
|
||
case BUILT_IN_CTZL:
|
||
case BUILT_IN_CTZLL:
|
||
if (lo != 0)
|
||
result = exact_log2 (lo & -lo);
|
||
else if (hi != 0)
|
||
result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
|
||
else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
|
||
result = width;
|
||
break;
|
||
|
||
case BUILT_IN_POPCOUNT:
|
||
case BUILT_IN_POPCOUNTL:
|
||
case BUILT_IN_POPCOUNTLL:
|
||
result = 0;
|
||
while (lo)
|
||
result++, lo &= lo - 1;
|
||
while (hi)
|
||
result++, hi &= hi - 1;
|
||
break;
|
||
|
||
case BUILT_IN_PARITY:
|
||
case BUILT_IN_PARITYL:
|
||
case BUILT_IN_PARITYLL:
|
||
result = 0;
|
||
while (lo)
|
||
result++, lo &= lo - 1;
|
||
while (hi)
|
||
result++, hi &= hi - 1;
|
||
result &= 1;
|
||
break;
|
||
|
||
default:
|
||
abort();
|
||
}
|
||
|
||
t = build_int_2 (result, 0);
|
||
TREE_TYPE (t) = TREE_TYPE (exp);
|
||
return t;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Return true if EXPR is the real constant contained in VALUE. */
|
||
|
||
static bool
|
||
real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
|
||
{
|
||
STRIP_NOPS (expr);
|
||
|
||
return ((TREE_CODE (expr) == REAL_CST
|
||
&& ! 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))));
|
||
}
|
||
|
||
/* A subroutine of fold_builtin to fold the various logarithmic
|
||
functions. EXP is the CALL_EXPR of a call to a builtin log*
|
||
function. VALUE is the base of the log* function. */
|
||
|
||
static tree
|
||
fold_builtin_logarithm (tree exp, const REAL_VALUE_TYPE *value)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
|
||
if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree type = TREE_TYPE (TREE_TYPE (fndecl));
|
||
tree arg = TREE_VALUE (arglist);
|
||
const enum built_in_function fcode = builtin_mathfn_code (arg);
|
||
|
||
/* Optimize log*(1.0) = 0.0. */
|
||
if (real_onep (arg))
|
||
return build_real (type, dconst0);
|
||
|
||
/* Optimize logN(N) = 1.0. If N can't be truncated to MODE
|
||
exactly, then only do this if flag_unsafe_math_optimizations. */
|
||
if (exact_real_truncate (TYPE_MODE (type), value)
|
||
|| flag_unsafe_math_optimizations)
|
||
{
|
||
const REAL_VALUE_TYPE value_truncate =
|
||
real_value_truncate (TYPE_MODE (type), *value);
|
||
if (real_dconstp (arg, &value_truncate))
|
||
return build_real (type, dconst1);
|
||
}
|
||
|
||
/* Special case, optimize logN(expN(x)) = x. */
|
||
if (flag_unsafe_math_optimizations
|
||
&& ((value == &dconste
|
||
&& (fcode == BUILT_IN_EXP
|
||
|| fcode == BUILT_IN_EXPF
|
||
|| fcode == BUILT_IN_EXPL))
|
||
|| (value == &dconst2
|
||
&& (fcode == BUILT_IN_EXP2
|
||
|| fcode == BUILT_IN_EXP2F
|
||
|| fcode == BUILT_IN_EXP2L))
|
||
|| (value == &dconst10
|
||
&& (fcode == BUILT_IN_EXP10
|
||
|| fcode == BUILT_IN_EXP10F
|
||
|| fcode == BUILT_IN_EXP10L))))
|
||
return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
|
||
|
||
/* 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). */
|
||
if (flag_unsafe_math_optimizations)
|
||
{
|
||
tree exponent = 0, x = 0;
|
||
|
||
switch (fcode)
|
||
{
|
||
case BUILT_IN_EXP:
|
||
case BUILT_IN_EXPF:
|
||
case BUILT_IN_EXPL:
|
||
/* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
|
||
x = build_real (type,
|
||
real_value_truncate (TYPE_MODE (type), dconste));
|
||
exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
break;
|
||
case BUILT_IN_EXP2:
|
||
case BUILT_IN_EXP2F:
|
||
case BUILT_IN_EXP2L:
|
||
/* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
|
||
x = build_real (type, dconst2);
|
||
exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
break;
|
||
case BUILT_IN_EXP10:
|
||
case BUILT_IN_EXP10F:
|
||
case BUILT_IN_EXP10L:
|
||
case BUILT_IN_POW10:
|
||
case BUILT_IN_POW10F:
|
||
case BUILT_IN_POW10L:
|
||
/* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
|
||
x = build_real (type, dconst10);
|
||
exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
break;
|
||
case BUILT_IN_SQRT:
|
||
case BUILT_IN_SQRTF:
|
||
case BUILT_IN_SQRTL:
|
||
/* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
|
||
x = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
exponent = build_real (type, dconsthalf);
|
||
break;
|
||
case BUILT_IN_CBRT:
|
||
case BUILT_IN_CBRTF:
|
||
case BUILT_IN_CBRTL:
|
||
/* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
|
||
x = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
|
||
dconstthird));
|
||
break;
|
||
case BUILT_IN_POW:
|
||
case BUILT_IN_POWF:
|
||
case BUILT_IN_POWL:
|
||
/* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
|
||
x = TREE_VALUE (TREE_OPERAND (arg, 1));
|
||
exponent = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
/* Now perform the optimization. */
|
||
if (x && exponent)
|
||
{
|
||
tree logfn;
|
||
arglist = build_tree_list (NULL_TREE, x);
|
||
logfn = build_function_call_expr (fndecl, arglist);
|
||
return fold (build (MULT_EXPR, type, exponent, logfn));
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* A subroutine of fold_builtin to fold the various exponent
|
||
functions. EXP is the CALL_EXPR of a call to a builtin function.
|
||
VALUE is the value which will be raised to a power. */
|
||
|
||
static tree
|
||
fold_builtin_exponent (tree exp, const REAL_VALUE_TYPE *value)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
|
||
if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree type = TREE_TYPE (TREE_TYPE (fndecl));
|
||
tree arg = TREE_VALUE (arglist);
|
||
|
||
/* Optimize exp*(0.0) = 1.0. */
|
||
if (real_zerop (arg))
|
||
return build_real (type, dconst1);
|
||
|
||
/* Optimize expN(1.0) = N. */
|
||
if (real_onep (arg))
|
||
{
|
||
REAL_VALUE_TYPE cst;
|
||
|
||
real_convert (&cst, TYPE_MODE (type), value);
|
||
return build_real (type, cst);
|
||
}
|
||
|
||
/* Attempt to evaluate expN(integer) at compile-time. */
|
||
if (flag_unsafe_math_optimizations
|
||
&& TREE_CODE (arg) == REAL_CST
|
||
&& ! TREE_CONSTANT_OVERFLOW (arg))
|
||
{
|
||
REAL_VALUE_TYPE cint;
|
||
REAL_VALUE_TYPE c;
|
||
HOST_WIDE_INT n;
|
||
|
||
c = TREE_REAL_CST (arg);
|
||
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;
|
||
|
||
real_powi (&x, TYPE_MODE (type), value, n);
|
||
return build_real (type, x);
|
||
}
|
||
}
|
||
|
||
/* Optimize expN(logN(x)) = x. */
|
||
if (flag_unsafe_math_optimizations)
|
||
{
|
||
const enum built_in_function fcode = builtin_mathfn_code (arg);
|
||
|
||
if ((value == &dconste
|
||
&& (fcode == BUILT_IN_LOG
|
||
|| fcode == BUILT_IN_LOGF
|
||
|| fcode == BUILT_IN_LOGL))
|
||
|| (value == &dconst2
|
||
&& (fcode == BUILT_IN_LOG2
|
||
|| fcode == BUILT_IN_LOG2F
|
||
|| fcode == BUILT_IN_LOG2L))
|
||
|| (value == &dconst10
|
||
&& (fcode == BUILT_IN_LOG10
|
||
|| fcode == BUILT_IN_LOG10F
|
||
|| fcode == BUILT_IN_LOG10L)))
|
||
return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin memcpy. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_memcpy (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree dest, src, len;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_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)));
|
||
|
||
/* If the LEN parameter is zero, return DEST. */
|
||
if (integer_zerop (len))
|
||
return omit_one_operand (TREE_TYPE (exp), dest, src);
|
||
|
||
/* 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);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin mempcpy. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_mempcpy (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree dest, src, len;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_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)));
|
||
|
||
/* If the LEN parameter is zero, return DEST. */
|
||
if (integer_zerop (len))
|
||
return omit_one_operand (TREE_TYPE (exp), dest, src);
|
||
|
||
/* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
|
||
if (operand_equal_p (src, dest, 0))
|
||
{
|
||
tree temp = convert (TREE_TYPE (dest), len);
|
||
temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
|
||
return convert (TREE_TYPE (exp), temp);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin memmove. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_memmove (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree dest, src, len;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_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)));
|
||
|
||
/* If the LEN parameter is zero, return DEST. */
|
||
if (integer_zerop (len))
|
||
return omit_one_operand (TREE_TYPE (exp), dest, src);
|
||
|
||
/* 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);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin strcpy. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_strcpy (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree dest, src;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
dest = TREE_VALUE (arglist);
|
||
src = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
/* If SRC and DEST are the same (and not volatile), return DEST. */
|
||
if (operand_equal_p (src, dest, 0))
|
||
return convert (TREE_TYPE (exp), dest);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin strncpy. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_strncpy (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree dest, src, len;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_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)));
|
||
|
||
/* If the LEN parameter is zero, return DEST. */
|
||
if (integer_zerop (len))
|
||
return omit_one_operand (TREE_TYPE (exp), dest, src);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin memcmp. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_memcmp (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg1, arg2, len;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
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))
|
||
{
|
||
tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
|
||
return omit_one_operand (TREE_TYPE (exp), temp, arg1);
|
||
}
|
||
|
||
/* If ARG1 and ARG2 are the same (and not volatile), return zero. */
|
||
if (operand_equal_p (arg1, arg2, 0))
|
||
return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin strcmp. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_strcmp (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg1, arg2;
|
||
const char *p1, *p2;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
arg1 = TREE_VALUE (arglist);
|
||
arg2 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
/* If ARG1 and ARG2 are the same (and not volatile), return zero. */
|
||
if (operand_equal_p (arg1, arg2, 0))
|
||
return convert (TREE_TYPE (exp), integer_zero_node);
|
||
|
||
p1 = c_getstr (arg1);
|
||
p2 = c_getstr (arg2);
|
||
|
||
if (p1 && p2)
|
||
{
|
||
tree temp;
|
||
const int i = strcmp (p1, p2);
|
||
if (i < 0)
|
||
temp = integer_minus_one_node;
|
||
else if (i > 0)
|
||
temp = integer_one_node;
|
||
else
|
||
temp = integer_zero_node;
|
||
return convert (TREE_TYPE (exp), temp);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Fold function call to builtin strncmp. Return
|
||
NULL_TREE if no simplification can be made. */
|
||
|
||
static tree
|
||
fold_builtin_strncmp (tree exp)
|
||
{
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree arg1, arg2, len;
|
||
const char *p1, *p2;
|
||
|
||
if (!validate_arglist (arglist,
|
||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||
return 0;
|
||
|
||
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))
|
||
{
|
||
tree temp = omit_one_operand (TREE_TYPE (exp), integer_zero_node, arg2);
|
||
return omit_one_operand (TREE_TYPE (exp), temp, arg1);
|
||
}
|
||
|
||
/* If ARG1 and ARG2 are the same (and not volatile), return zero. */
|
||
if (operand_equal_p (arg1, arg2, 0))
|
||
return omit_one_operand (TREE_TYPE (exp), integer_zero_node, len);
|
||
|
||
p1 = c_getstr (arg1);
|
||
p2 = c_getstr (arg2);
|
||
|
||
if (host_integerp (len, 1) && p1 && p2)
|
||
{
|
||
tree temp;
|
||
const int i = strncmp (p1, p2, tree_low_cst (len, 1));
|
||
if (i < 0)
|
||
temp = integer_minus_one_node;
|
||
else if (i > 0)
|
||
temp = integer_one_node;
|
||
else
|
||
temp = integer_zero_node;
|
||
return convert (TREE_TYPE (exp), temp);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Used by constant folding to eliminate some builtin calls early. EXP is
|
||
the CALL_EXPR of a call to a builtin function. */
|
||
|
||
tree
|
||
fold_builtin (tree exp)
|
||
{
|
||
tree fndecl = get_callee_fndecl (exp);
|
||
tree arglist = TREE_OPERAND (exp, 1);
|
||
tree type = TREE_TYPE (TREE_TYPE (fndecl));
|
||
|
||
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
|
||
return 0;
|
||
|
||
switch (DECL_FUNCTION_CODE (fndecl))
|
||
{
|
||
case BUILT_IN_CONSTANT_P:
|
||
return fold_builtin_constant_p (arglist);
|
||
|
||
case BUILT_IN_CLASSIFY_TYPE:
|
||
return fold_builtin_classify_type (arglist);
|
||
|
||
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;
|
||
|
||
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;
|
||
|
||
case BUILT_IN_CABS:
|
||
case BUILT_IN_CABSF:
|
||
case BUILT_IN_CABSL:
|
||
return fold_builtin_cabs (fndecl, arglist, type);
|
||
|
||
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);
|
||
|
||
/* 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(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);
|
||
}
|
||
|
||
/* 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;
|
||
|
||
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);
|
||
|
||
/* Optimize sin(0.0) = 0.0. */
|
||
if (real_zerop (arg))
|
||
return arg;
|
||
}
|
||
break;
|
||
|
||
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);
|
||
|
||
/* 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 arglist = build_tree_list (NULL_TREE,
|
||
TREE_OPERAND (arg, 0));
|
||
return build_function_call_expr (fndecl, arglist);
|
||
}
|
||
}
|
||
break;
|
||
|
||
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;
|
||
|
||
case BUILT_IN_TAN:
|
||
case BUILT_IN_TANF:
|
||
case BUILT_IN_TANL:
|
||
if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
{
|
||
enum built_in_function fcode;
|
||
tree arg = TREE_VALUE (arglist);
|
||
|
||
/* 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));
|
||
}
|
||
break;
|
||
|
||
case BUILT_IN_ATAN:
|
||
case BUILT_IN_ATANF:
|
||
case BUILT_IN_ATANL:
|
||
if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
|
||
{
|
||
tree arg = TREE_VALUE (arglist);
|
||
|
||
/* 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);
|
||
cst.exp -= 2;
|
||
return build_real (type, cst);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case BUILT_IN_POW:
|
||
case BUILT_IN_POWF:
|
||
case BUILT_IN_POWL:
|
||
if (validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
|
||
{
|
||
enum built_in_function fcode;
|
||
tree arg0 = TREE_VALUE (arglist);
|
||
tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||
|
||
/* 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 c;
|
||
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 (build (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;
|
||
|
||
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;
|
||
|
||
if (sqrtfn != NULL_TREE)
|
||
{
|
||
tree arglist = build_tree_list (NULL_TREE, arg0);
|
||
return build_function_call_expr (sqrtfn, arglist);
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
|
||
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;
|
||
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
|
||
/* 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)));
|
||
|
||
arglist = tree_cons (NULL_TREE, narg0,
|
||
build_tree_list (NULL_TREE, narg1));
|
||
return build_function_call_expr (fndecl, arglist);
|
||
}
|
||
|
||
/* 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);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case BUILT_IN_INF:
|
||
case BUILT_IN_INFF:
|
||
case BUILT_IN_INFL:
|
||
return fold_builtin_inf (type, true);
|
||
|
||
case BUILT_IN_HUGE_VAL:
|
||
case BUILT_IN_HUGE_VALF:
|
||
case BUILT_IN_HUGE_VALL:
|
||
return fold_builtin_inf (type, false);
|
||
|
||
case BUILT_IN_NAN:
|
||
case BUILT_IN_NANF:
|
||
case BUILT_IN_NANL:
|
||
return fold_builtin_nan (arglist, type, true);
|
||
|
||
case BUILT_IN_NANS:
|
||
case BUILT_IN_NANSF:
|
||
case BUILT_IN_NANSL:
|
||
return fold_builtin_nan (arglist, type, false);
|
||
|
||
case BUILT_IN_FLOOR:
|
||
case BUILT_IN_FLOORF:
|
||
case BUILT_IN_FLOORL:
|
||
return fold_builtin_floor (exp);
|
||
|
||
case BUILT_IN_CEIL:
|
||
case BUILT_IN_CEILF:
|
||
case BUILT_IN_CEILL:
|
||
return fold_builtin_ceil (exp);
|
||
|
||
case BUILT_IN_TRUNC:
|
||
case BUILT_IN_TRUNCF:
|
||
case BUILT_IN_TRUNCL:
|
||
return fold_builtin_trunc (exp);
|
||
|
||
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 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 BUILT_IN_MEMCPY:
|
||
return fold_builtin_memcpy (exp);
|
||
|
||
case BUILT_IN_MEMPCPY:
|
||
return fold_builtin_mempcpy (exp);
|
||
|
||
case BUILT_IN_MEMMOVE:
|
||
return fold_builtin_memmove (exp);
|
||
|
||
case BUILT_IN_STRCPY:
|
||
return fold_builtin_strcpy (exp);
|
||
|
||
case BUILT_IN_STRNCPY:
|
||
return fold_builtin_strncpy (exp);
|
||
|
||
case BUILT_IN_MEMCMP:
|
||
return fold_builtin_memcmp (exp);
|
||
|
||
case BUILT_IN_STRCMP:
|
||
return fold_builtin_strcmp (exp);
|
||
|
||
case BUILT_IN_STRNCMP:
|
||
return fold_builtin_strncmp (exp);
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Conveniently construct a function call expression. */
|
||
|
||
tree
|
||
build_function_call_expr (tree fn, tree arglist)
|
||
{
|
||
tree call_expr;
|
||
|
||
call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
|
||
call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
|
||
call_expr, arglist);
|
||
return fold (call_expr);
|
||
}
|
||
|
||
/* This function validates the types of a function call argument list
|
||
represented as a tree chain of parameters against a specified list
|
||
of tree_codes. If the last specifier is a 0, that represents an
|
||
ellipses, otherwise the last specifier must be a VOID_TYPE. */
|
||
|
||
static int
|
||
validate_arglist (tree arglist, ...)
|
||
{
|
||
enum tree_code code;
|
||
int res = 0;
|
||
va_list ap;
|
||
|
||
va_start (ap, arglist);
|
||
|
||
do
|
||
{
|
||
code = va_arg (ap, enum tree_code);
|
||
switch (code)
|
||
{
|
||
case 0:
|
||
/* This signifies an ellipses, any further arguments are all ok. */
|
||
res = 1;
|
||
goto end;
|
||
case VOID_TYPE:
|
||
/* This signifies an endlink, if no arguments remain, return
|
||
true, otherwise return false. */
|
||
res = arglist == 0;
|
||
goto end;
|
||
default:
|
||
/* If no parameters remain or the parameter's code does not
|
||
match the specified code, return false. Otherwise continue
|
||
checking any remaining arguments. */
|
||
if (arglist == 0
|
||
|| code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
|
||
goto end;
|
||
break;
|
||
}
|
||
arglist = TREE_CHAIN (arglist);
|
||
}
|
||
while (1);
|
||
|
||
/* We need gotos here since we can only have one VA_CLOSE in a
|
||
function. */
|
||
end: ;
|
||
va_end (ap);
|
||
|
||
return res;
|
||
}
|
||
|
||
/* Default target-specific builtin expander that does nothing. */
|
||
|
||
rtx
|
||
default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
|
||
rtx target ATTRIBUTE_UNUSED,
|
||
rtx subtarget ATTRIBUTE_UNUSED,
|
||
enum machine_mode mode ATTRIBUTE_UNUSED,
|
||
int ignore ATTRIBUTE_UNUSED)
|
||
{
|
||
return NULL_RTX;
|
||
}
|
||
|
||
/* Instantiate all remaining CONSTANT_P_RTX nodes. */
|
||
|
||
void
|
||
purge_builtin_constant_p (void)
|
||
{
|
||
rtx insn, set, arg, new, note;
|
||
|
||
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))))
|
||
{
|
||
arg = XEXP (arg, 0);
|
||
new = CONSTANT_P (arg) ? const1_rtx : const0_rtx;
|
||
validate_change (insn, &SET_SRC (set), new, 0);
|
||
|
||
/* Remove the REG_EQUAL note from the insn. */
|
||
if ((note = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
|
||
remove_note (insn, note);
|
||
}
|
||
}
|
||
|
||
/* Returns true is EXP represents data that would potentially reside
|
||
in a readonly section. */
|
||
|
||
static bool
|
||
readonly_data_expr (tree exp)
|
||
{
|
||
STRIP_NOPS (exp);
|
||
|
||
if (TREE_CODE (exp) == ADDR_EXPR)
|
||
return decl_readonly_section (TREE_OPERAND (exp, 0), 0);
|
||
else
|
||
return false;
|
||
}
|