#include "config.h"
#include "system.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))
#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
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) STRINGX(X),
const char *const built_in_names[(int) END_BUILTINS] =
{
#include "builtins.def"
};
#undef DEF_BUILTIN
tree built_in_decls[(int) END_BUILTINS];
static int get_pointer_alignment PARAMS ((tree, unsigned int));
static tree c_strlen PARAMS ((tree));
static const char *c_getstr PARAMS ((tree));
static rtx c_readstr PARAMS ((const char *,
enum machine_mode));
static int target_char_cast PARAMS ((tree, char *));
static rtx get_memory_rtx PARAMS ((tree));
static int apply_args_size PARAMS ((void));
static int apply_result_size PARAMS ((void));
#if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
static rtx result_vector PARAMS ((int, rtx));
#endif
static rtx expand_builtin_setjmp PARAMS ((tree, rtx));
static void expand_builtin_prefetch PARAMS ((tree));
static rtx expand_builtin_apply_args PARAMS ((void));
static rtx expand_builtin_apply_args_1 PARAMS ((void));
static rtx expand_builtin_apply PARAMS ((rtx, rtx, rtx));
static void expand_builtin_return PARAMS ((rtx));
static enum type_class type_to_class PARAMS ((tree));
static rtx expand_builtin_classify_type PARAMS ((tree));
static rtx expand_builtin_mathfn PARAMS ((tree, rtx, rtx));
static rtx expand_builtin_constant_p PARAMS ((tree));
static rtx expand_builtin_args_info PARAMS ((tree));
static rtx expand_builtin_next_arg PARAMS ((tree));
static rtx expand_builtin_va_start PARAMS ((tree));
static rtx expand_builtin_va_end PARAMS ((tree));
static rtx expand_builtin_va_copy PARAMS ((tree));
static rtx expand_builtin_memcmp PARAMS ((tree, tree, rtx,
enum machine_mode));
static rtx expand_builtin_strcmp PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strncmp PARAMS ((tree, rtx,
enum machine_mode));
static rtx builtin_memcpy_read_str PARAMS ((PTR, HOST_WIDE_INT,
enum machine_mode));
static rtx expand_builtin_strcat PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strncat PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strspn PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strcspn PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_memcpy PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strcpy PARAMS ((tree, rtx,
enum machine_mode));
static rtx builtin_strncpy_read_str PARAMS ((PTR, HOST_WIDE_INT,
enum machine_mode));
static rtx expand_builtin_strncpy PARAMS ((tree, rtx,
enum machine_mode));
static rtx builtin_memset_read_str PARAMS ((PTR, HOST_WIDE_INT,
enum machine_mode));
static rtx builtin_memset_gen_str PARAMS ((PTR, HOST_WIDE_INT,
enum machine_mode));
static rtx expand_builtin_memset PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_bzero PARAMS ((tree));
static rtx expand_builtin_strlen PARAMS ((tree, rtx));
static rtx expand_builtin_strstr PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strpbrk PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strchr PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_strrchr PARAMS ((tree, rtx,
enum machine_mode));
static rtx expand_builtin_alloca PARAMS ((tree, rtx));
static rtx expand_builtin_ffs PARAMS ((tree, rtx, rtx));
static rtx expand_builtin_frame_address PARAMS ((tree));
static rtx expand_builtin_fputs PARAMS ((tree, int, int));
static tree stabilize_va_list PARAMS ((tree, int));
static rtx expand_builtin_expect PARAMS ((tree, rtx));
static tree fold_builtin_constant_p PARAMS ((tree));
static tree fold_builtin_classify_type PARAMS ((tree));
static tree fold_builtin_inf PARAMS ((tree, int));
static tree fold_builtin_nan PARAMS ((tree, tree, int));
static tree build_function_call_expr PARAMS ((tree, tree));
static int validate_arglist PARAMS ((tree, ...));
static int
get_pointer_alignment (exp, max_align)
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 (! 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:
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;
}
}
}
static tree
c_strlen (src)
tree src;
{
tree offset_node;
HOST_WIDE_INT offset;
int max;
const char *ptr;
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)
{
int i;
for (i = 0; i < max; i++)
if (ptr[i] == 0)
return 0;
return size_diffop (size_int (max), offset_node);
}
if (offset_node == 0)
offset = 0;
else if (! host_integerp (offset_node, 0))
offset = -1;
else
offset = tree_low_cst (offset_node, 0);
if (offset < 0 || offset > max)
{
warning ("offset outside bounds of constant string");
return 0;
}
return ssize_int (strlen (ptr + offset));
}
static const char *
c_getstr (src)
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);
}
static rtx
c_readstr (str, mode)
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);
}
static int
target_char_cast (cst, p)
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;
}
rtx
expand_builtin_return_addr (fndecl_code, count, tem)
enum built_in_function fndecl_code;
int count;
rtx tem;
{
int i;
#ifdef SETUP_FRAME_ADDRESSES
if (count > 0)
SETUP_FRAME_ADDRESSES ();
#endif
#ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
count--;
#endif
for (i = 0; i < count; i++)
{
#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);
}
if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
return tem;
#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;
}
static HOST_WIDE_INT setjmp_alias_set = -1;
void
expand_builtin_setjmp_setup (buf_addr, receiver_label)
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 ();
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (buf_addr) != Pmode)
buf_addr = convert_memory_address (Pmode, buf_addr);
#endif
buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
emit_queue ();
#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);
#ifdef HAVE_builtin_setjmp_setup
if (HAVE_builtin_setjmp_setup)
emit_insn (gen_builtin_setjmp_setup (buf_addr));
#endif
current_function_calls_setjmp = 1;
current_function_has_nonlocal_label = 1;
}
void
expand_builtin_setjmp_receiver (receiver_label)
rtx receiver_label ATTRIBUTE_UNUSED;
{
emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
#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
{
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
{ }
emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
}
static rtx
expand_builtin_setjmp (arglist, target)
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);
emit_move_insn (target, const0_rtx);
emit_jump_insn (gen_jump (cont_lab));
emit_barrier ();
emit_label (next_lab);
expand_builtin_setjmp_receiver (next_lab);
emit_move_insn (target, const1_rtx);
emit_label (cont_lab);
current_function_has_nonlocal_label = 1;
nonlocal_goto_handler_labels
= gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
return target;
}
void
expand_builtin_longjmp (buf_addr, value)
rtx buf_addr, 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 ();
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (buf_addr) != Pmode)
buf_addr = convert_memory_address (Pmode, buf_addr);
#endif
buf_addr = force_reg (Pmode, buf_addr);
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);
#if HAVE_nonlocal_goto
if (HAVE_nonlocal_goto)
emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
else
#endif
{
lab = copy_to_reg (lab);
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);
}
}
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;
}
}
static void
expand_builtin_prefetch (arglist)
tree arglist;
{
tree arg0, arg1, arg2;
rtx op0, op1, op2;
if (!validate_arglist (arglist, POINTER_TYPE, 0))
return;
arg0 = TREE_VALUE (arglist);
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);
}
op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
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);
if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
{
warning ("invalid second arg to __builtin_prefetch; using zero");
op1 = const0_rtx;
}
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);
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))
{
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE(op0) != Pmode)
op0 = convert_memory_address (Pmode, op0);
#endif
op0 = force_reg (Pmode, op0);
}
emit_insn (gen_prefetch (op0, op1, op2));
}
else
#endif
op0 = protect_from_queue (op0, 0);
if (GET_CODE (op0) != MEM && side_effects_p (op0))
emit_insn (op0);
}
static rtx
get_memory_rtx (exp)
tree exp;
{
rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_SUM);
rtx mem;
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (addr) != Pmode)
addr = convert_memory_address (Pmode, addr);
#endif
mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
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);
set_mem_alias_set (mem, 0);
}
return mem;
}
static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
int
apply_args_register_offset (regno)
int regno;
{
apply_args_size ();
#ifdef OUTGOING_REGNO
regno = OUTGOING_REGNO (regno);
#endif
return apply_args_reg_offset[regno];
}
static int
apply_args_size ()
{
static int size = -1;
int align;
unsigned int regno;
enum machine_mode mode;
if (size < 0)
{
size = GET_MODE_SIZE (Pmode);
if (struct_value_rtx)
size += GET_MODE_SIZE (Pmode);
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (FUNCTION_ARG_REGNO_P (regno))
{
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;
}
static int
apply_result_size ()
{
static int size = -1;
int align, regno;
enum machine_mode mode;
if (size < 0)
{
size = 0;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (FUNCTION_VALUE_REGNO_P (regno))
{
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;
#ifdef APPLY_RESULT_SIZE
size = APPLY_RESULT_SIZE;
#endif
}
return size;
}
#if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
static rtx
result_vector (savep, result)
int savep;
rtx result;
{
int regno, size, align, nelts;
enum machine_mode mode;
rtx reg, mem;
rtx *savevec = (rtx *) 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
static rtx
expand_builtin_apply_args_1 ()
{
rtx registers;
int size, align, regno;
enum machine_mode mode;
registers = assign_stack_local (BLKmode, apply_args_size (), -1);
size = GET_MODE_SIZE (Pmode);
if (struct_value_rtx)
size += GET_MODE_SIZE (Pmode);
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if ((mode = apply_args_mode[regno]) != VOIDmode)
{
rtx tem;
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);
}
emit_move_insn (adjust_address (registers, Pmode, 0),
copy_to_reg (virtual_incoming_args_rtx));
size = GET_MODE_SIZE (Pmode);
if (struct_value_incoming_rtx)
{
emit_move_insn (adjust_address (registers, Pmode, size),
copy_to_reg (struct_value_incoming_rtx));
size += GET_MODE_SIZE (Pmode);
}
return copy_addr_to_reg (XEXP (registers, 0));
}
static rtx
expand_builtin_apply_args ()
{
if (apply_args_value != 0)
return apply_args_value;
{
rtx temp;
rtx seq;
start_sequence ();
temp = expand_builtin_apply_args_1 ();
seq = get_insns ();
end_sequence ();
apply_args_value = temp;
push_topmost_sequence ();
emit_insn_before (seq, NEXT_INSN (get_insns ()));
pop_topmost_sequence ();
return temp;
}
}
static rtx
expand_builtin_apply (function, arguments, argsize)
rtx function, arguments, 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;
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (arguments) != Pmode)
arguments = convert_memory_address (Pmode, arguments);
#endif
result = assign_stack_local (BLKmode, apply_result_size (), -1);
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
emit_queue ();
do_pending_stack_adjust ();
NO_DEFER_POP;
#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);
dest = allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
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);
apply_args_size ();
arguments = gen_rtx_MEM (BLKmode, arguments);
set_mem_align (arguments, PARM_BOUNDARY);
size = GET_MODE_SIZE (Pmode);
if (struct_value_rtx)
size += GET_MODE_SIZE (Pmode);
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);
}
size = GET_MODE_SIZE (Pmode);
if (struct_value_rtx)
{
rtx value = gen_reg_rtx (Pmode);
emit_move_insn (value, adjust_address (arguments, Pmode, size));
emit_move_insn (struct_value_rtx, value);
if (GET_CODE (struct_value_rtx) == REG)
use_reg (&call_fusage, struct_value_rtx);
size += GET_MODE_SIZE (Pmode);
}
function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
if (GET_CODE (function) != SYMBOL_REF)
function = memory_address (FUNCTION_MODE, function);
#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;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if ((mode = apply_result_mode[regno]) != VOIDmode)
{
if (valreg)
abort ();
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 ();
for (call_insn = get_last_insn ();
call_insn && GET_CODE (call_insn) != CALL_INSN;
call_insn = PREV_INSN (call_insn))
;
if (! call_insn)
abort ();
if (CALL_INSN_FUNCTION_USAGE (call_insn))
{
rtx link;
for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
link = XEXP (link, 1))
;
XEXP (link, 1) = call_fusage;
}
else
CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
#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 copy_addr_to_reg (XEXP (result, 0));
}
static void
expand_builtin_return (result)
rtx result;
{
int size, align, regno;
enum machine_mode mode;
rtx reg;
rtx call_fusage = 0;
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (result) != Pmode)
result = convert_memory_address (Pmode, result);
#endif
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
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);
}
emit_insn (call_fusage);
expand_null_return ();
}
static enum type_class
type_to_class (type)
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;
}
}
static rtx
expand_builtin_classify_type (arglist)
tree arglist;
{
if (arglist != 0)
return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
return GEN_INT (no_type_class);
}
static rtx
expand_builtin_constant_p (exp)
tree exp;
{
tree arglist = TREE_OPERAND (exp, 1);
enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
rtx tmp;
if (arglist == 0)
return const0_rtx;
arglist = TREE_VALUE (arglist);
tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);
tmp = gen_rtx_CONSTANT_P_RTX (value_mode, tmp);
return tmp;
}
static rtx
expand_builtin_mathfn (exp, target, subtarget)
tree exp;
rtx target, subtarget;
{
optab builtin_optab;
rtx op0, insns;
tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
tree arglist = TREE_OPERAND (exp, 1);
enum machine_mode argmode;
if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
return 0;
if (TREE_CODE (TREE_VALUE (arglist)) != VAR_DECL
&& TREE_CODE (TREE_VALUE (arglist)) != PARM_DECL)
{
exp = copy_node (exp);
TREE_OPERAND (exp, 1) = arglist;
TREE_VALUE (arglist) = save_expr (TREE_VALUE (arglist));
arglist = copy_node (arglist);
}
op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
emit_queue ();
start_sequence ();
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:
builtin_optab = sqrt_optab; break;
case BUILT_IN_EXP:
case BUILT_IN_EXPF:
case BUILT_IN_EXPL:
builtin_optab = exp_optab; break;
case BUILT_IN_LOG:
case BUILT_IN_LOGF:
case BUILT_IN_LOGL:
builtin_optab = log_optab; break;
default:
abort ();
}
argmode = TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist)));
target = expand_unop (argmode, builtin_optab, op0, target, 0);
if (target == 0)
{
end_sequence ();
return 0;
}
if (flag_errno_math && HONOR_NANS (argmode))
{
rtx lab1;
lab1 = gen_label_rtx ();
emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
0, lab1);
#ifdef TARGET_EDOM
{
#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));
}
#else
NO_DEFER_POP;
expand_call (exp, target, 0);
OK_DEFER_POP;
#endif
emit_label (lab1);
}
insns = get_insns ();
end_sequence ();
emit_insn (insns);
return target;
}
static rtx
expand_builtin_strlen (exp, target)
tree exp;
rtx target;
{
tree arglist = TREE_OPERAND (exp, 1);
enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
return 0;
else
{
rtx pat;
tree src = TREE_VALUE (arglist);
int align
= get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
rtx result, src_reg, char_rtx, before_strlen;
enum machine_mode insn_mode = value_mode, char_mode;
enum insn_code icode = CODE_FOR_nothing;
if (align == 0)
return 0;
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;
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);
src_reg = gen_reg_rtx (Pmode);
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);
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 ());
if (GET_MODE (result) == value_mode)
target = result;
else if (target != 0)
convert_move (target, result, 0);
else
target = convert_to_mode (value_mode, result, 0);
return target;
}
}
static rtx
expand_builtin_strstr (arglist, target, mode)
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 expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
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 = built_in_decls[BUILT_IN_STRCHR];
if (!fn)
return 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);
}
}
static rtx
expand_builtin_strchr (arglist, target, mode)
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 expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
s1, ssize_int (r - p1))),
target, mode, EXPAND_NORMAL);
}
return 0;
}
}
static rtx
expand_builtin_strrchr (arglist, target, mode)
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 expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
s1, ssize_int (r - p1))),
target, mode, EXPAND_NORMAL);
}
if (! integer_zerop (s2))
return 0;
fn = built_in_decls[BUILT_IN_STRCHR];
if (!fn)
return 0;
return expand_expr (build_function_call_expr (fn, arglist),
target, mode, EXPAND_NORMAL);
}
}
static rtx
expand_builtin_strpbrk (arglist, target, mode)
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 expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
s1, ssize_int (r - p1))),
target, mode, EXPAND_NORMAL);
}
if (p2[0] == '\0')
{
expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
if (p2[1] != '\0')
return 0;
fn = built_in_decls[BUILT_IN_STRCHR];
if (!fn)
return 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);
}
}
static rtx
builtin_memcpy_read_str (data, offset, mode)
PTR 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 ();
return c_readstr (str + offset, mode);
}
static rtx
expand_builtin_memcpy (arglist, target, mode)
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_align == 0)
return 0;
if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
{
expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
return expand_expr (dest, target, mode, EXPAND_NORMAL);
}
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_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,
(PTR) src_str, dest_align))
{
store_by_pieces (dest_mem, INTVAL (len_rtx),
builtin_memcpy_read_str,
(PTR) src_str, dest_align);
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_mem) != ptr_mode)
dest_mem = convert_memory_address (ptr_mode, dest_mem);
#endif
return dest_mem;
}
src_mem = get_memory_rtx (src);
set_mem_align (src_mem, src_align);
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);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_addr) != ptr_mode)
dest_addr = convert_memory_address (ptr_mode, dest_addr);
#endif
}
return dest_addr;
}
}
static rtx
expand_builtin_strcpy (exp, target, mode)
tree exp;
rtx target;
enum machine_mode mode;
{
tree arglist = TREE_OPERAND (exp, 1);
tree fn, len;
if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
return 0;
fn = built_in_decls[BUILT_IN_MEMCPY];
if (!fn)
return 0;
len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
if (len == 0)
return 0;
len = size_binop (PLUS_EXPR, len, ssize_int (1));
chainon (arglist, build_tree_list (NULL_TREE, len));
return expand_expr (build_function_call_expr (fn, arglist),
target, mode, EXPAND_NORMAL);
}
static rtx
builtin_strncpy_read_str (data, offset, mode)
PTR 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);
}
static rtx
expand_builtin_strncpy (arglist, target, mode)
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)));
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
tree fn;
if (TREE_CODE (len) != INTEGER_CST)
return 0;
if (integer_zerop (len))
{
expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
VOIDmode, EXPAND_NORMAL);
return expand_expr (TREE_VALUE (arglist), target, mode,
EXPAND_NORMAL);
}
if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
return 0;
slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
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,
(PTR) 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,
(PTR) p, dest_align);
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_mem) != ptr_mode)
dest_mem = convert_memory_address (ptr_mode, dest_mem);
#endif
return dest_mem;
}
fn = built_in_decls[BUILT_IN_MEMCPY];
if (!fn)
return 0;
return expand_expr (build_function_call_expr (fn, arglist),
target, mode, EXPAND_NORMAL);
}
}
static rtx
builtin_memset_read_str (data, offset, mode)
PTR 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);
}
static rtx
builtin_memset_gen_str (data, offset, mode)
PTR 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);
}
static rtx
expand_builtin_memset (exp, target, mode)
tree exp;
rtx target;
enum machine_mode mode;
{
tree arglist = TREE_OPERAND (exp, 1);
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_align == 0)
return 0;
if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
{
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;
c = 1;
if (!can_store_by_pieces (tree_low_cst (len, 1),
builtin_memset_read_str,
(PTR) &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,
(PTR) val_rtx, dest_align);
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_mem) != ptr_mode)
dest_mem = convert_memory_address (ptr_mode, dest_mem);
#endif
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, (PTR) &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,
(PTR) &c, dest_align);
dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_mem) != ptr_mode)
dest_mem = convert_memory_address (ptr_mode, dest_mem);
#endif
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);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dest_addr) != ptr_mode)
dest_addr = convert_memory_address (ptr_mode, dest_addr);
#endif
}
return dest_addr;
}
}
static rtx
expand_builtin_bzero (exp)
tree exp;
{
tree arglist = TREE_OPERAND (exp, 1);
tree dest, size, newarglist;
rtx result;
if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
return NULL_RTX;
dest = TREE_VALUE (arglist);
size = TREE_VALUE (TREE_CHAIN (arglist));
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);
TREE_OPERAND (exp, 1) = newarglist;
result = expand_builtin_memset (exp, const0_rtx, VOIDmode);
TREE_OPERAND (exp, 1) = arglist;
return result;
}
static rtx
expand_builtin_memcmp (exp, arglist, target, mode)
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 (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
{
expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
p1 = c_getstr (arg1);
p2 = c_getstr (arg2);
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 (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
{
tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
tree cst_uchar_ptr_node = build_pointer_type (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
{
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
= insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
if (arg1_align == 0 || arg2_align == 0)
return 0;
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);
if (!HAVE_cmpstrsi)
insn = NULL_RTX;
else
insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
GEN_INT (MIN (arg1_align, arg2_align)));
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));
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;
}
static rtx
expand_builtin_strcmp (exp, target, mode)
tree exp;
rtx target;
enum machine_mode mode;
{
tree arglist = TREE_OPERAND (exp, 1);
tree arg1, arg2, len, len2, fn;
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));
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 ((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);
}
len = c_strlen (arg1);
len2 = c_strlen (arg2);
if (len)
len = size_binop (PLUS_EXPR, ssize_int (1), len);
if (len2)
len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
if (!len || TREE_CODE (len) != INTEGER_CST)
{
if (len2 && !TREE_SIDE_EFFECTS (len2))
len = len2;
else if (len == 0)
return 0;
}
else if (len2 && TREE_CODE (len2) == INTEGER_CST
&& tree_int_cst_lt (len2, len))
len = len2;
if (TREE_SIDE_EFFECTS (len))
return 0;
fn = built_in_decls[BUILT_IN_MEMCMP];
if (!fn)
return 0;
chainon (arglist, build_tree_list (NULL_TREE, len));
return expand_expr (build_function_call_expr (fn, arglist),
target, mode, EXPAND_NORMAL);
}
static rtx
expand_builtin_strncmp (exp, target, mode)
tree exp;
rtx target;
enum machine_mode mode;
{
tree arglist = TREE_OPERAND (exp, 1);
tree fn, newarglist, len = 0;
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 (host_integerp (arg3, 1) && tree_low_cst (arg3, 1) == 0)
{
expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
p1 = c_getstr (arg1);
p2 = c_getstr (arg2);
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 (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 (p1)
len = c_strlen (arg1);
else if (p2)
len = c_strlen (arg2);
if (!len && !TREE_SIDE_EFFECTS (arg1))
len = c_strlen (arg1);
if (!len && !TREE_SIDE_EFFECTS (arg2))
len = c_strlen (arg2);
if (!len)
return 0;
fn = built_in_decls[BUILT_IN_MEMCMP];
if (!fn)
return 0;
len = fold (size_binop (PLUS_EXPR, len, ssize_int (1)));
len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
newarglist = build_tree_list (NULL_TREE, len);
newarglist = tree_cons (NULL_TREE, arg2, newarglist);
newarglist = tree_cons (NULL_TREE, arg1, newarglist);
return expand_expr (build_function_call_expr (fn, newarglist),
target, mode, EXPAND_NORMAL);
}
static rtx
expand_builtin_strcat (arglist, target, mode)
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 && *p == '\0')
return expand_expr (dst, target, mode, EXPAND_NORMAL);
return 0;
}
}
static rtx
expand_builtin_strncat (arglist, target, mode)
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 (integer_zerop (len) || (p && *p == '\0'))
{
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 (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 = built_in_decls[BUILT_IN_STRCAT];
if (!fn)
return 0;
return expand_expr (build_function_call_expr (fn, newarglist),
target, mode, EXPAND_NORMAL);
}
return 0;
}
}
static rtx
expand_builtin_strspn (arglist, target, mode)
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 (p1 && p2)
{
const size_t r = strspn (p1, p2);
return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
}
if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
{
expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
return 0;
}
}
static rtx
expand_builtin_strcspn (arglist, target, mode)
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 (p1 && p2)
{
const size_t r = strcspn (p1, p2);
return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
}
if (p1 && *p1 == '\0')
{
expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
if (p2 && *p2 == '\0')
{
tree newarglist = build_tree_list (NULL_TREE, s1),
fn = built_in_decls[BUILT_IN_STRLEN];
if (!fn)
return 0;
return expand_expr (build_function_call_expr (fn, newarglist),
target, mode, EXPAND_NORMAL);
}
return 0;
}
}
rtx
expand_builtin_saveregs ()
{
rtx val, seq;
if (saveregs_value != 0)
return saveregs_value;
start_sequence ();
#ifdef EXPAND_BUILTIN_SAVEREGS
val = EXPAND_BUILTIN_SAVEREGS ();
#else
error ("__builtin_saveregs not supported by this target");
val = const0_rtx;
#endif
seq = get_insns ();
end_sequence ();
saveregs_value = val;
push_topmost_sequence ();
emit_insn_after (seq, get_insns ());
pop_topmost_sequence ();
return val;
}
static rtx
expand_builtin_args_info (exp)
tree exp;
{
tree arglist = TREE_OPERAND (exp, 1);
int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
int *word_ptr = (int *) ¤t_function_args_info;
#if 0
int i;
tree type, elts, result;
#endif
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;
#if 0
for (i = 0; i < nwords; i++)
elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0));
type = build_array_type (integer_type_node,
build_index_type (build_int_2 (nwords, 0)));
result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts));
TREE_CONSTANT (result) = 1;
TREE_STATIC (result) = 1;
result = build1 (INDIRECT_REF, build_pointer_type (type), result);
TREE_CONSTANT (result) = 1;
return expand_expr (result, NULL_RTX, VOIDmode, 0);
#endif
}
static rtx
expand_builtin_next_arg (arglist)
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);
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
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);
}
static tree
stabilize_va_list (valist, needs_lvalue)
tree valist;
int needs_lvalue;
{
if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
{
if (TREE_SIDE_EFFECTS (valist))
valist = save_expr (valist);
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;
}
void
std_expand_builtin_va_start (valist, nextarg)
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);
}
static rtx
expand_builtin_va_start (arglist)
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;
}
rtx
std_expand_builtin_va_arg (valist, type)
tree valist, type;
{
tree addr_tree, t, type_size = NULL;
tree align, alignm1;
tree rounded_size;
rtx addr;
HOST_WIDE_INT boundary;
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);
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));
addr_tree = valist;
if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
{
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);
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;
}
rtx
expand_builtin_va_arg (valist, type)
tree valist, type;
{
rtx addr, result;
tree promoted_type, want_va_type, have_va_type;
want_va_type = va_list_type_node;
have_va_type = TREE_TYPE (valist);
if (TREE_CODE (want_va_type) == ARRAY_TYPE)
{
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;
}
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)));
}
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);
}
expand_builtin_trap ();
addr = const0_rtx;
}
else
{
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
}
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (addr) != Pmode)
addr = convert_memory_address (Pmode, addr);
#endif
result = gen_rtx_MEM (TYPE_MODE (type), addr);
set_mem_alias_set (result, get_varargs_alias_set ());
return result;
}
static rtx
expand_builtin_va_end (arglist)
tree arglist;
{
tree valist = TREE_VALUE (arglist);
#ifdef EXPAND_BUILTIN_VA_END
valist = stabilize_va_list (valist, 0);
EXPAND_BUILTIN_VA_END (arglist);
#else
if (TREE_SIDE_EFFECTS (valist))
expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
#endif
return const0_rtx;
}
static rtx
expand_builtin_va_copy (arglist)
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;
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);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (dstb) != Pmode)
dstb = convert_memory_address (Pmode, dstb);
if (GET_MODE (srcb) != Pmode)
srcb = convert_memory_address (Pmode, srcb);
#endif
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));
emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
}
return const0_rtx;
}
static rtx
expand_builtin_frame_address (exp)
tree exp;
{
tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
tree arglist = TREE_OPERAND (exp, 1);
if (arglist == 0)
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);
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;
}
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;
}
}
static rtx
expand_builtin_alloca (arglist, target)
tree arglist;
rtx target;
{
rtx op0;
rtx result;
if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
return 0;
op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
#ifdef POINTERS_EXTEND_UNSIGNED
if (GET_MODE (result) != ptr_mode)
result = convert_memory_address (ptr_mode, result);
#endif
return result;
}
static rtx
expand_builtin_ffs (arglist, target, subtarget)
tree arglist;
rtx target, subtarget;
{
rtx op0;
if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
return 0;
op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
ffs_optab, op0, target, 1);
if (target == 0)
abort ();
return target;
}
static rtx
expand_builtin_fputs (arglist, ignore, unlocked)
tree arglist;
int ignore;
int unlocked;
{
tree len, fn;
tree fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
: built_in_decls[BUILT_IN_FPUTC];
tree fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
: built_in_decls[BUILT_IN_FWRITE];
if (!ignore || !fn_fputc || !fn_fwrite)
return 0;
if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
return 0;
if (!(len = c_strlen (TREE_VALUE (arglist)))
|| TREE_CODE (len) != INTEGER_CST)
return 0;
switch (compare_tree_int (len, 1))
{
case -1:
{
expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
VOIDmode, EXPAND_NORMAL);
return const0_rtx;
}
case 0:
{
const char *p = c_getstr (TREE_VALUE (arglist));
if (p != NULL)
{
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;
}
}
case 1:
{
tree string_arg = TREE_VALUE (arglist);
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 ();
}
return expand_expr (build_function_call_expr (fn, arglist),
(ignore ? const0_rtx : NULL_RTX),
VOIDmode, EXPAND_NORMAL);
}
static rtx
expand_builtin_expect (arglist, target)
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);
if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
{
target = force_reg (GET_MODE (target), target);
rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
note = emit_note (NULL, NOTE_INSN_EXPECTED_VALUE);
NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
}
return target;
}
rtx
expand_builtin_expect_jump (exp, if_false_label, if_true_label)
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;
if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
&& (integer_zerop (arg1) || integer_onep (arg1)))
{
int num_jumps = 0;
rtx insn;
switch (unsafe_for_reeval (arg0))
{
case 0:
break;
case 1:
arg0 = unsave_expr (arg0);
break;
case 2:
return NULL_RTX;
}
start_sequence ();
do_jump (arg0, if_false_label, if_true_label);
ret = get_insns ();
end_sequence ();
insn = ret;
while (insn != NULL_RTX)
{
rtx next = NEXT_INSN (insn);
rtx pattern;
if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn)
&& (pattern = pc_set (insn)) != NULL_RTX)
{
rtx ifelse = SET_SRC (pattern);
rtx label;
int taken;
if (GET_CODE (ifelse) != IF_THEN_ELSE)
goto do_next_insn;
if (GET_CODE (XEXP (ifelse, 1)) == LABEL_REF)
{
taken = 1;
label = XEXP (XEXP (ifelse, 1), 0);
}
else if (GET_CODE (XEXP (ifelse, 2)) == LABEL_REF)
{
taken = 0;
label = XEXP (XEXP (ifelse, 2), 0);
}
else if (GET_CODE (XEXP (ifelse, 1)) == RETURN)
{
taken = 1;
label = NULL_RTX;
}
else if (GET_CODE (XEXP (ifelse, 2)) == RETURN)
{
taken = 0;
label = NULL_RTX;
}
else
goto do_next_insn;
if (integer_zerop (arg1))
taken = 1 - taken;
if (label == NULL_RTX)
;
else if (label == if_false_label)
taken = 1 - taken;
else if (label != if_true_label)
goto do_next_insn;
num_jumps++;
predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
}
do_next_insn:
insn = next;
}
if (num_jumps == 0)
ret = NULL_RTX;
}
return ret;
}
void
expand_builtin_trap ()
{
#ifdef HAVE_trap
if (HAVE_trap)
emit_insn (gen_trap ());
else
#endif
emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
emit_barrier ();
}
rtx
expand_builtin (exp, target, subtarget, mode, ignore)
tree exp;
rtx target;
rtx subtarget;
enum machine_mode mode;
int ignore;
{
tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
tree arglist = TREE_OPERAND (exp, 1);
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
emit_queue ();
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
return (*targetm.expand_builtin) (exp, target, subtarget, mode, ignore);
if (!optimize && !CALLED_AS_BUILT_IN (fndecl))
switch (fcode)
{
case BUILT_IN_SQRT:
case BUILT_IN_SQRTF:
case BUILT_IN_SQRTL:
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_MEMSET:
case BUILT_IN_MEMCPY:
case BUILT_IN_MEMCMP:
case BUILT_IN_BCMP:
case BUILT_IN_BZERO:
case BUILT_IN_INDEX:
case BUILT_IN_RINDEX:
case BUILT_IN_STRCHR:
case BUILT_IN_STRRCHR:
case BUILT_IN_STRLEN:
case BUILT_IN_STRCPY:
case BUILT_IN_STRNCPY:
case BUILT_IN_STRNCMP:
case BUILT_IN_STRSTR:
case BUILT_IN_STRPBRK:
case BUILT_IN_STRCAT:
case BUILT_IN_STRNCAT:
case BUILT_IN_STRSPN:
case BUILT_IN_STRCSPN:
case BUILT_IN_STRCMP:
case BUILT_IN_FFS:
case BUILT_IN_PUTCHAR:
case BUILT_IN_PUTS:
case BUILT_IN_PRINTF:
case BUILT_IN_FPUTC:
case BUILT_IN_FPUTS:
case BUILT_IN_FWRITE:
case BUILT_IN_PUTCHAR_UNLOCKED:
case BUILT_IN_PUTS_UNLOCKED:
case BUILT_IN_PRINTF_UNLOCKED:
case BUILT_IN_FPUTC_UNLOCKED:
case BUILT_IN_FPUTS_UNLOCKED:
case BUILT_IN_FWRITE_UNLOCKED:
return expand_call (exp, target, ignore);
default:
break;
}
switch (fcode)
{
case BUILT_IN_ABS:
case BUILT_IN_LABS:
case BUILT_IN_LLABS:
case BUILT_IN_IMAXABS:
case BUILT_IN_FABS:
case BUILT_IN_FABSF:
case BUILT_IN_FABSL:
abort ();
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:
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:
if (! flag_unsafe_math_optimizations)
break;
case BUILT_IN_SQRT:
case BUILT_IN_SQRTF:
case BUILT_IN_SQRTL:
target = expand_builtin_mathfn (exp, target, subtarget);
if (target)
return target;
break;
case BUILT_IN_APPLY_ARGS:
return expand_builtin_apply_args ();
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]);
}
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 (exp);
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 (exp);
case BUILT_IN_FRAME_ADDRESS:
case BUILT_IN_RETURN_ADDRESS:
return expand_builtin_frame_address (exp);
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:
target = expand_builtin_ffs (arglist, target, subtarget);
if (target)
return target;
break;
case BUILT_IN_STRLEN:
target = expand_builtin_strlen (exp, target);
if (target)
return target;
break;
case BUILT_IN_STRCPY:
target = expand_builtin_strcpy (exp, 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_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_MEMSET:
target = expand_builtin_memset (exp, target, mode);
if (target)
return target;
break;
case BUILT_IN_BZERO:
target = expand_builtin_bzero (exp);
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;
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_FPUTS:
target = expand_builtin_fputs (arglist, ignore, 0);
if (target)
return target;
break;
case BUILT_IN_FPUTS_UNLOCKED:
target = expand_builtin_fputs (arglist, ignore, 1);
if (target)
return target;
break;
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_FP_REGNUM:
return expand_builtin_dwarf_fp_regnum ();
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_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;
case BUILT_IN___CFSTRINGMAKECONSTANTSTRING:
error ("CFString literal expression not constant");
return const0_rtx;
default:
if (!DECL_ASSEMBLER_NAME_SET_P (fndecl))
error ("built-in function `%s' not currently supported",
IDENTIFIER_POINTER (DECL_NAME (fndecl)));
}
return expand_call (exp, target, ignore);
}
static tree
fold_builtin_constant_p (arglist)
tree arglist;
{
if (arglist == 0)
return 0;
arglist = TREE_VALUE (arglist);
STRIP_NOPS (arglist);
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 (TREE_SIDE_EFFECTS (arglist) || cse_not_expected
|| AGGREGATE_TYPE_P (TREE_TYPE (arglist))
|| POINTER_TYPE_P (TREE_TYPE (arglist))
|| cfun == 0)
return integer_zero_node;
return 0;
}
static tree
fold_builtin_classify_type (arglist)
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);
}
static tree
fold_builtin_inf (type, warn)
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);
}
static tree
fold_builtin_nan (arglist, type, quiet)
tree arglist, 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);
}
tree
fold_builtin (exp)
tree exp;
{
tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
tree arglist = TREE_OPERAND (exp, 1);
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
return 0;
switch (fcode)
{
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));
if (len)
{
if (size_type_node)
len = convert (size_type_node, len);
return len;
}
}
break;
case BUILT_IN___CFSTRINGMAKECONSTANTSTRING:
if (!flag_constant_cfstrings)
{
error ("built-in function `%s' requires `-fconstant-cfstrings' flag",
IDENTIFIER_POINTER (DECL_NAME (fndecl)));
return error_mark_node;
}
if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
{
tree offset_node;
tree literal = string_constant (TREE_VALUE (arglist), &offset_node);
if (literal)
return build_cfstring_ascii (literal);
}
break;
case BUILT_IN_INF:
case BUILT_IN_INFF:
case BUILT_IN_INFL:
return fold_builtin_inf (TREE_TYPE (TREE_TYPE (fndecl)), true);
case BUILT_IN_HUGE_VAL:
case BUILT_IN_HUGE_VALF:
case BUILT_IN_HUGE_VALL:
return fold_builtin_inf (TREE_TYPE (TREE_TYPE (fndecl)), false);
case BUILT_IN_NAN:
case BUILT_IN_NANF:
case BUILT_IN_NANL:
return fold_builtin_nan (arglist, TREE_TYPE (TREE_TYPE (fndecl)), true);
case BUILT_IN_NANS:
case BUILT_IN_NANSF:
case BUILT_IN_NANSL:
return fold_builtin_nan (arglist, TREE_TYPE (TREE_TYPE (fndecl)), false);
default:
break;
}
return 0;
}
static tree
build_function_call_expr (fn, arglist)
tree fn, 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);
TREE_SIDE_EFFECTS (call_expr) = 1;
return fold (call_expr);
}
static int
validate_arglist VPARAMS ((tree arglist, ...))
{
enum tree_code code;
int res = 0;
VA_OPEN (ap, arglist);
VA_FIXEDARG (ap, tree, arglist);
do
{
code = va_arg (ap, enum tree_code);
switch (code)
{
case 0:
res = 1;
goto end;
case VOID_TYPE:
res = arglist == 0;
goto end;
default:
if (arglist == 0
|| code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
goto end;
break;
}
arglist = TREE_CHAIN (arglist);
}
while (1);
end: ;
VA_CLOSE (ap);
return res;
}
void
default_init_builtins ()
{
}
rtx
default_expand_builtin (exp, target, subtarget, mode, ignore)
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;
}