/* Expand builtin functions.

Copyright (C) 1988-2013 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 3, 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 COPYING3. If not see

<http://www.gnu.org/licenses/>. */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "machmode.h"

#include "rtl.h"

#include "tree.h"

#include "realmpfr.h"

#include "gimple.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 "predict.h"

#include "tm_p.h"

#include "target.h"

#include "langhooks.h"

#include "basic-block.h"

#include "tree-mudflap.h"

#include "tree-flow.h"

#include "value-prof.h"

#include "diagnostic-core.h"

#include "builtins.h"

#ifndef PAD_VARARGS_DOWN

#define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN

#endif

static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));

struct target_builtins default_target_builtins;

#if SWITCHABLE_TARGET

struct target_builtins *this_target_builtins = &default_target_builtins;

#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, COND) #X,

const char * 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. */

builtin_info_type builtin_info;

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, tree);

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 void expand_builtin_update_setjmp_buf (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_mathfn_3 (tree, rtx, rtx);

static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);

static rtx expand_builtin_interclass_mathfn (tree, rtx);

static rtx expand_builtin_sincos (tree);

static rtx expand_builtin_cexpi (tree, rtx);

static rtx expand_builtin_int_roundingfn (tree, rtx);

static rtx expand_builtin_int_roundingfn_2 (tree, rtx);

static rtx expand_builtin_next_arg (void);

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, rtx, enum machine_mode);

static rtx expand_builtin_strcmp (tree, rtx);

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_memcpy (tree, rtx);

static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);

static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,

enum machine_mode, int);

static rtx expand_builtin_strcpy (tree, rtx);

static rtx expand_builtin_strcpy_args (tree, tree, rtx);

static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);

static rtx expand_builtin_strncpy (tree, rtx);

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_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);

static rtx expand_builtin_bzero (tree);

static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);

static rtx expand_builtin_alloca (tree, bool);

static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);

static rtx expand_builtin_frame_address (tree, tree);

static tree stabilize_va_list_loc (location_t, tree, int);

static rtx expand_builtin_expect (tree, rtx);

static tree fold_builtin_constant_p (tree);

static tree fold_builtin_expect (location_t, tree, tree);

static tree fold_builtin_classify_type (tree);

static tree fold_builtin_strlen (location_t, tree, tree);

static tree fold_builtin_inf (location_t, tree, int);

static tree fold_builtin_nan (tree, tree, int);

static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);

static bool validate_arg (const_tree, enum tree_code code);

static bool integer_valued_real_p (tree);

static tree fold_trunc_transparent_mathfn (location_t, tree, tree);

static bool readonly_data_expr (tree);

static rtx expand_builtin_fabs (tree, rtx, rtx);

static rtx expand_builtin_signbit (tree, rtx);

static tree fold_builtin_sqrt (location_t, tree, tree);

static tree fold_builtin_cbrt (location_t, tree, tree);

static tree fold_builtin_pow (location_t, tree, tree, tree, tree);

static tree fold_builtin_powi (location_t, tree, tree, tree, tree);

static tree fold_builtin_cos (location_t, tree, tree, tree);

static tree fold_builtin_cosh (location_t, tree, tree, tree);

static tree fold_builtin_tan (tree, tree);

static tree fold_builtin_trunc (location_t, tree, tree);

static tree fold_builtin_floor (location_t, tree, tree);

static tree fold_builtin_ceil (location_t, tree, tree);

static tree fold_builtin_round (location_t, tree, tree);

static tree fold_builtin_int_roundingfn (location_t, tree, tree);

static tree fold_builtin_bitop (tree, tree);

static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);

static tree fold_builtin_strchr (location_t, tree, tree, tree);

static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);

static tree fold_builtin_memcmp (location_t, tree, tree, tree);

static tree fold_builtin_strcmp (location_t, tree, tree);

static tree fold_builtin_strncmp (location_t, tree, tree, tree);

static tree fold_builtin_signbit (location_t, tree, tree);

static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);

static tree fold_builtin_isascii (location_t, tree);

static tree fold_builtin_toascii (location_t, tree);

static tree fold_builtin_isdigit (location_t, tree);

static tree fold_builtin_fabs (location_t, tree, tree);

static tree fold_builtin_abs (location_t, tree, tree);

static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,

enum tree_code);

static tree fold_builtin_n (location_t, tree, tree *, int, bool);

static tree fold_builtin_0 (location_t, tree, bool);

static tree fold_builtin_1 (location_t, tree, tree, bool);

static tree fold_builtin_2 (location_t, tree, tree, tree, bool);

static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);

static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);

static tree fold_builtin_varargs (location_t, tree, tree, bool);

static tree fold_builtin_strpbrk (location_t, tree, tree, tree);

static tree fold_builtin_strstr (location_t, tree, tree, tree);

static tree fold_builtin_strrchr (location_t, tree, tree, tree);

static tree fold_builtin_strcat (location_t, tree, tree);

static tree fold_builtin_strncat (location_t, tree, tree, tree);

static tree fold_builtin_strspn (location_t, tree, tree);

static tree fold_builtin_strcspn (location_t, tree, tree);

static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);

static tree fold_builtin_snprintf (location_t, tree, tree, tree, tree, int);

static rtx expand_builtin_object_size (tree);

static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,

enum built_in_function);

static void maybe_emit_chk_warning (tree, enum built_in_function);

static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);

static void maybe_emit_free_warning (tree);

static tree fold_builtin_object_size (tree, tree);

static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);

static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);

static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);

static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);

static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,

enum built_in_function);

static bool init_target_chars (void);

static unsigned HOST_WIDE_INT target_newline;

static unsigned HOST_WIDE_INT target_percent;

static unsigned HOST_WIDE_INT target_c;

static unsigned HOST_WIDE_INT target_s;

static char target_percent_c[3];

static char target_percent_s[3];

static char target_percent_s_newline[4];

static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),

const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);

static tree do_mpfr_arg2 (tree, tree, tree,

int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));

static tree do_mpfr_arg3 (tree, tree, tree, tree,

int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));

static tree do_mpfr_sincos (tree, tree, tree);

static tree do_mpfr_bessel_n (tree, tree, tree,

int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),

const REAL_VALUE_TYPE *, bool);

static tree do_mpfr_remquo (tree, tree, tree);

static tree do_mpfr_lgamma_r (tree, tree, tree);

static void expand_builtin_sync_synchronize (void);

/* Return true if NAME starts with __builtin_ or __sync_. */

static bool

is_builtin_name (const char *name)

{

if (strncmp (name, "__builtin_", 10) == 0)

return true;

if (strncmp (name, "__sync_", 7) == 0)

return true;

if (strncmp (name, "__atomic_", 9) == 0)

return true;

return false;

}

/* Return true if DECL is a function symbol representing a built-in. */

bool

is_builtin_fn (tree decl)

{

return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);

}

/* Return true if NODE should be considered for inline expansion regardless

of the optimization level. This means whenever a function is invoked with

its "internal" name, which normally contains the prefix "__builtin". */

static bool

called_as_built_in (tree node)

{

/* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since

we want the name used to call the function, not the name it

will have. */

const char *name = IDENTIFIER_POINTER (DECL_NAME (node));

return is_builtin_name (name);

}

/* Compute values M and N such that M divides (address of EXP - N) and such

that N < M. If these numbers can be determined, store M in alignp and N in

*BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to

*alignp and any bit-offset to *bitposp.

Note that the address (and thus the alignment) computed here is based

on the address to which a symbol resolves, whereas DECL_ALIGN is based

on the address at which an object is actually located. These two

addresses are not always the same. For example, on ARM targets,

the address &foo of a Thumb function foo() has the lowest bit set,

whereas foo() itself starts on an even address.

If ADDR_P is true we are taking the address of the memory reference EXP

and thus cannot rely on the access taking place. */

static bool

get_object_alignment_2 (tree exp, unsigned int *alignp,

unsigned HOST_WIDE_INT *bitposp, bool addr_p)

{

HOST_WIDE_INT bitsize, bitpos;

tree offset;

enum machine_mode mode;

int unsignedp, volatilep;

unsigned int inner, align = BITS_PER_UNIT;

bool known_alignment = false;

/* Get the innermost object and the constant (bitpos) and possibly

variable (offset) offset of the access. */

exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,

&mode, &unsignedp, &volatilep, true);

/* Extract alignment information from the innermost object and

possibly adjust bitpos and offset. */

if (TREE_CODE (exp) == FUNCTION_DECL)

{

/* Function addresses can encode extra information besides their

alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION

allows the low bit to be used as a virtual bit, we know

that the address itself must be at least 2-byte aligned. */

if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)

align = 2 * BITS_PER_UNIT;

}

else if (TREE_CODE (exp) == LABEL_DECL)

;

else if (TREE_CODE (exp) == CONST_DECL)

{

/* The alignment of a CONST_DECL is determined by its initializer. */

exp = DECL_INITIAL (exp);

align = TYPE_ALIGN (TREE_TYPE (exp));

#ifdef CONSTANT_ALIGNMENT

if (CONSTANT_CLASS_P (exp))

align = (unsigned) CONSTANT_ALIGNMENT (exp, align);

#endif

known_alignment = true;

}

else if (DECL_P (exp))

{

align = DECL_ALIGN (exp);

known_alignment = true;

}

else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)

{

align = TYPE_ALIGN (TREE_TYPE (exp));

}

else if (TREE_CODE (exp) == INDIRECT_REF

|| TREE_CODE (exp) == MEM_REF

|| TREE_CODE (exp) == TARGET_MEM_REF)

{

tree addr = TREE_OPERAND (exp, 0);

unsigned ptr_align;

unsigned HOST_WIDE_INT ptr_bitpos;

if (TREE_CODE (addr) == BIT_AND_EXPR

&& TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)

{

align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))

& -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));

align *= BITS_PER_UNIT;

addr = TREE_OPERAND (addr, 0);

}

known_alignment

= get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);

align = MAX (ptr_align, align);

/* The alignment of the pointer operand in a TARGET_MEM_REF

has to take the variable offset parts into account. */

if (TREE_CODE (exp) == TARGET_MEM_REF)

{

if (TMR_INDEX (exp))

{

unsigned HOST_WIDE_INT step = 1;

if (TMR_STEP (exp))

step = TREE_INT_CST_LOW (TMR_STEP (exp));

align = MIN (align, (step & -step) * BITS_PER_UNIT);

}

if (TMR_INDEX2 (exp))

align = BITS_PER_UNIT;

known_alignment = false;

}

/* When EXP is an actual memory reference then we can use

TYPE_ALIGN of a pointer indirection to derive alignment.

Do so only if get_pointer_alignment_1 did not reveal absolute

alignment knowledge and if using that alignment would

improve the situation. */

if (!addr_p && !known_alignment

&& TYPE_ALIGN (TREE_TYPE (exp)) > align)

align = TYPE_ALIGN (TREE_TYPE (exp));

else

{

/* Else adjust bitpos accordingly. */

bitpos += ptr_bitpos;

if (TREE_CODE (exp) == MEM_REF

|| TREE_CODE (exp) == TARGET_MEM_REF)

bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;

}

}

else if (TREE_CODE (exp) == STRING_CST)

{

/* STRING_CST are the only constant objects we allow to be not

wrapped inside a CONST_DECL. */

align = TYPE_ALIGN (TREE_TYPE (exp));

#ifdef CONSTANT_ALIGNMENT

if (CONSTANT_CLASS_P (exp))

align = (unsigned) CONSTANT_ALIGNMENT (exp, align);

#endif

known_alignment = true;

}

/* If there is a non-constant offset part extract the maximum

alignment that can prevail. */

inner = ~0U;

while (offset)

{

tree next_offset;

if (TREE_CODE (offset) == PLUS_EXPR)

{

next_offset = TREE_OPERAND (offset, 0);

offset = TREE_OPERAND (offset, 1);

}

else

next_offset = NULL;

if (host_integerp (offset, 1))

{

/* Any overflow in calculating offset_bits won't change

the alignment. */

unsigned offset_bits

= ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);

if (offset_bits)

inner = MIN (inner, (offset_bits & -offset_bits));

}

else if (TREE_CODE (offset) == MULT_EXPR

&& host_integerp (TREE_OPERAND (offset, 1), 1))

{

/* Any overflow in calculating offset_factor won't change

the alignment. */

unsigned offset_factor

= ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)

* BITS_PER_UNIT);

if (offset_factor)

inner = MIN (inner, (offset_factor & -offset_factor));

}

else

{

inner = MIN (inner, BITS_PER_UNIT);

break;

}

offset = next_offset;

}

/* Alignment is innermost object alignment adjusted by the constant

and non-constant offset parts. */

align = MIN (align, inner);

*alignp = align;

*bitposp = bitpos & (*alignp - 1);

return known_alignment;

}

/* For a memory reference expression EXP compute values M and N such that M

divides (&EXP - N) and such that N < M. If these numbers can be determined,

store M in alignp and N in *BITPOSP and return true. Otherwise return false

and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */

bool

get_object_alignment_1 (tree exp, unsigned int *alignp,

unsigned HOST_WIDE_INT *bitposp)

{

return get_object_alignment_2 (exp, alignp, bitposp, false);

}

/* Return the alignment in bits of EXP, an object. */

unsigned int

get_object_alignment (tree exp)

{

unsigned HOST_WIDE_INT bitpos = 0;

unsigned int align;

get_object_alignment_1 (exp, &align, &bitpos);

/* align and bitpos now specify known low bits of the pointer.

ptr & (align - 1) == bitpos. */

if (bitpos != 0)

align = (bitpos & -bitpos);

return align;

}

/* For a pointer valued expression EXP compute values M and N such that M

divides (EXP - N) and such that N < M. If these numbers can be determined,

store M in alignp and N in *BITPOSP and return true. Return false if

the results are just a conservative approximation.

If EXP is not a pointer, false is returned too. */

bool

get_pointer_alignment_1 (tree exp, unsigned int *alignp,

unsigned HOST_WIDE_INT *bitposp)

{

STRIP_NOPS (exp);

if (TREE_CODE (exp) == ADDR_EXPR)

return get_object_alignment_2 (TREE_OPERAND (exp, 0),

alignp, bitposp, true);

else if (TREE_CODE (exp) == SSA_NAME

&& POINTER_TYPE_P (TREE_TYPE (exp)))

{

unsigned int ptr_align, ptr_misalign;

struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);

if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign))

{

*bitposp = ptr_misalign * BITS_PER_UNIT;

*alignp = ptr_align * BITS_PER_UNIT;

/* We cannot really tell whether this result is an approximation. */

return true;

}

else

{

*bitposp = 0;

*alignp = BITS_PER_UNIT;

return false;

}

}

else if (TREE_CODE (exp) == INTEGER_CST)

{

*alignp = BIGGEST_ALIGNMENT;

*bitposp = ((TREE_INT_CST_LOW (exp) * BITS_PER_UNIT)

& (BIGGEST_ALIGNMENT - 1));

return true;

}

*bitposp = 0;

*alignp = BITS_PER_UNIT;

return false;

}

/* Return the alignment in bits of EXP, a pointer valued expression.

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. */

unsigned int

get_pointer_alignment (tree exp)

{

unsigned HOST_WIDE_INT bitpos = 0;

unsigned int align;

get_pointer_alignment_1 (exp, &align, &bitpos);

/* align and bitpos now specify known low bits of the pointer.

ptr & (align - 1) == bitpos. */

if (bitpos != 0)

align = (bitpos & -bitpos);

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. */

tree

c_strlen (tree src, int only_value)

{

tree offset_node;

HOST_WIDE_INT offset;

int max;

const char *ptr;

location_t loc;

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);

loc = EXPR_LOC_OR_HERE (src);

src = string_constant (src, &offset_node);

if (src == 0)

return NULL_TREE;

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 NULL_TREE;

/* 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_loc (loc, 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)

{

/* Suppress multiple warnings for propagated constant strings. */

if (! TREE_NO_WARNING (src))

{

warning_at (loc, 0, "offset outside bounds of constant string");

TREE_NO_WARNING (src) = 1;

}

return NULL_TREE;

}

/* 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;

gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);

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;

gcc_assert (j < HOST_BITS_PER_DOUBLE_INT);

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 to by

P. */

static int

target_char_cast (tree cst, char *p)

{

unsigned HOST_WIDE_INT val, hostval;

if (TREE_CODE (cst) != INTEGER_CST

|| CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)

return 1;

val = TREE_INT_CST_LOW (cst);

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;

}

/* Similar to save_expr, but assumes that arbitrary code is not executed

in between the multiple evaluations. In particular, we assume that a

non-addressable local variable will not be modified. */

static tree

builtin_save_expr (tree exp)

{

if (TREE_CODE (exp) == SSA_NAME

|| (TREE_ADDRESSABLE (exp) == 0

&& (TREE_CODE (exp) == PARM_DECL

|| (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))

return exp;

return save_expr (exp);

}

/* 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). */

static rtx

expand_builtin_return_addr (enum built_in_function fndecl_code, int count)

{

int i;

#ifdef INITIAL_FRAME_ADDRESS_RTX

rtx tem = INITIAL_FRAME_ADDRESS_RTX;

#else

rtx tem;

/* For a zero count with __builtin_return_address, we don't care what

frame address we return, because target-specific definitions will

override us. Therefore frame pointer elimination is OK, and using

the soft frame pointer is OK.

For a nonzero count, or a zero count with __builtin_frame_address,

we require a stable offset from the current frame pointer to the

previous one, so we must use the hard frame pointer, and

we must disable frame pointer elimination. */

if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)

tem = frame_pointer_rtx;

else

{

tem = hard_frame_pointer_rtx;

/* Tell reload not to eliminate the frame pointer. */

crtl->accesses_prior_frames = 1;

}

#endif

/* 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_frame_mem (Pmode, tem);

tem = copy_to_reg (tem);

}

/* For __builtin_frame_address, return what we've got. But, on

the SPARC for example, we may have to add a bias. */

if (fndecl_code == BUILT_IN_FRAME_ADDRESS)

#ifdef FRAME_ADDR_RTX

return FRAME_ADDR_RTX (tem);

#else

return tem;

#endif

/* 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 (Pmode, tem, GET_MODE_SIZE (Pmode)));

tem = gen_frame_mem (Pmode, tem);

#endif

return tem;

}

/* Alias set used for setjmp buffer. */

static alias_set_type setjmp_alias_set = -1;

/* Construct the leading half of a __builtin_setjmp call. Control will

return to RECEIVER_LABEL. This is also called directly by the 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));

/* 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. */

mem = gen_rtx_MEM (Pmode, buf_addr);

set_mem_alias_set (mem, setjmp_alias_set);

emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());

mem = gen_rtx_MEM (Pmode, plus_constant (Pmode, 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 (Pmode, buf_addr,

2 * GET_MODE_SIZE (Pmode)));

set_mem_alias_set (stack_save, setjmp_alias_set);

emit_stack_save (SAVE_NONLOCAL, &stack_save);

/* 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

/* We have a nonlocal label. */

cfun->has_nonlocal_label = 1;

}

/* Construct the trailing part of a __builtin_setjmp call. This is

also called directly by the SJLJ exception handling code. */

void

expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)

{

rtx chain;

/* Clobber the FP when we get here, so we have to make sure it's

marked as used by this function. */

emit_use (hard_frame_pointer_rtx);

/* Mark the static chain as clobbered here so life information

doesn't get messed up for it. */

chain = targetm.calls.static_chain (current_function_decl, true);

if (chain && REG_P (chain))

emit_clobber (chain);

/* Now put in the code to restore the frame pointer, and argument

pointer, if needed. */

#ifdef HAVE_nonlocal_goto

if (! HAVE_nonlocal_goto)

#endif

{

emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);

/* This might change the hard frame pointer in ways that aren't

apparent to early optimization passes, so force a clobber. */

emit_clobber (hard_frame_pointer_rtx);

}

#if !HARD_FRAME_POINTER_IS_ARG_POINTER

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 (crtl->args.internal_arg_pointer,

copy_to_reg (get_arg_pointer_save_area ()));

}

}

#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 */ }

/* 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. Similarly, we must block

(frame-related) register values to be used across this code. */

emit_insn (gen_blockage ());

}

/* __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. */

static 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);

/* DRAP is needed for stack realign if longjmp is expanded to current

function */

if (SUPPORTS_STACK_ALIGNMENT)

crtl->need_drap = true;

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 require that the user must pass a second argument of 1, because

that is what builtin_setjmp will return. */

gcc_assert (value == const1_rtx);

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 (Pmode, buf_addr,

GET_MODE_SIZE (Pmode)));

stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode, 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);