+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * tree-core.h (function_decl::function_code): Change type to
+ unsigned int.
+ * tree.h (DECL_FUNCTION_CODE): Rename old definition to...
+ (DECL_UNCHECKED_FUNCTION_CODE): ...this.
+ (DECL_BUILT_IN_CLASS): Make an rvalue macro only.
+ (DECL_FUNCTION_CODE): New function. Assert that the built-in class
+ is BUILT_IN_NORMAL.
+ (DECL_MD_FUNCTION_CODE, DECL_FE_FUNCTION_CODE): New functions.
+ (set_decl_built_in_function, copy_decl_built_in_function): Likewise.
+ (fndecl_built_in_p): Change the type of the "name" argument to
+ unsigned int.
+ * builtins.c (expand_builtin): Move DECL_FUNCTION_CODE use
+ after check for DECL_BUILT_IN_CLASS.
+ * cgraphclones.c (build_function_decl_skip_args): Use
+ set_decl_built_in_function.
+ * ipa-param-manipulation.c (ipa_modify_formal_parameters): Likewise.
+ * ipa-split.c (split_function): Likewise.
+ * langhooks.c (add_builtin_function_common): Likewise.
+ * omp-simd-clone.c (simd_clone_create): Likewise.
+ * tree-streamer-in.c (unpack_ts_function_decl_value_fields): Likewise.
+ * config/darwin.c (darwin_init_cfstring_builtins): Likewise.
+ (darwin_fold_builtin): Use DECL_MD_FUNCTION_CODE instead of
+ DECL_FUNCTION_CODE.
+ * fold-const.c (operand_equal_p): Compare DECL_UNCHECKED_FUNCTION_CODE
+ instead of DECL_FUNCTION_CODE.
+ * lto-streamer-out.c (hash_tree): Use DECL_UNCHECKED_FUNCTION_CODE
+ instead of DECL_FUNCTION_CODE.
+ * tree-streamer-out.c (pack_ts_function_decl_value_fields): Likewise.
+ * print-tree.c (print_node): Use DECL_MD_FUNCTION_CODE when
+ printing DECL_BUILT_IN_MD. Handle DECL_BUILT_IN_FRONTEND.
+ * config/aarch64/aarch64-builtins.c (aarch64_expand_builtin)
+ (aarch64_fold_builtin, aarch64_gimple_fold_builtin): Use
+ DECL_MD_FUNCTION_CODE instead of DECL_FUNCTION_CODE.
+ * config/aarch64/aarch64.c (aarch64_builtin_reciprocal): Likewise.
+ * config/alpha/alpha.c (alpha_expand_builtin, alpha_fold_builtin):
+ (alpha_gimple_fold_builtin): Likewise.
+ * config/arc/arc.c (arc_expand_builtin): Likewise.
+ * config/arm/arm-builtins.c (arm_expand_builtin): Likewise.
+ * config/avr/avr-c.c (avr_resolve_overloaded_builtin): Likewise.
+ * config/avr/avr.c (avr_expand_builtin, avr_fold_builtin): Likewise.
+ * config/bfin/bfin.c (bfin_expand_builtin): Likewise.
+ * config/c6x/c6x.c (c6x_expand_builtin): Likewise.
+ * config/frv/frv.c (frv_expand_builtin): Likewise.
+ * config/gcn/gcn.c (gcn_expand_builtin_1): Likewise.
+ (gcn_expand_builtin): Likewise.
+ * config/i386/i386-builtins.c (ix86_builtin_reciprocal): Likewise.
+ (fold_builtin_cpu): Likewise.
+ * config/i386/i386-expand.c (ix86_expand_builtin): Likewise.
+ * config/i386/i386.c (ix86_fold_builtin): Likewise.
+ (ix86_gimple_fold_builtin): Likewise.
+ * config/ia64/ia64.c (ia64_fold_builtin): Likewise.
+ (ia64_expand_builtin): Likewise.
+ * config/iq2000/iq2000.c (iq2000_expand_builtin): Likewise.
+ * config/mips/mips.c (mips_expand_builtin): Likewise.
+ * config/msp430/msp430.c (msp430_expand_builtin): Likewise.
+ * config/nds32/nds32-intrinsic.c (nds32_expand_builtin_impl): Likewise.
+ * config/nios2/nios2.c (nios2_expand_builtin): Likewise.
+ * config/nvptx/nvptx.c (nvptx_expand_builtin): Likewise.
+ * config/pa/pa.c (pa_expand_builtin): Likewise.
+ * config/pru/pru.c (pru_expand_builtin): Likewise.
+ * config/riscv/riscv-builtins.c (riscv_expand_builtin): Likewise.
+ * config/rs6000/rs6000-c.c (altivec_resolve_overloaded_builtin):
+ Likewise.
+ * config/rs6000/rs6000-call.c (htm_expand_builtin): Likewise.
+ (altivec_expand_dst_builtin, altivec_expand_builtin): Likewise.
+ (rs6000_gimple_fold_builtin, rs6000_expand_builtin): Likewise.
+ * config/rs6000/rs6000.c (rs6000_builtin_md_vectorized_function)
+ (rs6000_builtin_reciprocal): Likewise.
+ * config/rx/rx.c (rx_expand_builtin): Likewise.
+ * config/s390/s390-c.c (s390_resolve_overloaded_builtin): Likewise.
+ * config/s390/s390.c (s390_expand_builtin): Likewise.
+ * config/sh/sh.c (sh_expand_builtin): Likewise.
+ * config/sparc/sparc.c (sparc_expand_builtin): Likewise.
+ (sparc_fold_builtin): Likewise.
+ * config/spu/spu-c.c (spu_resolve_overloaded_builtin): Likewise.
+ * config/spu/spu.c (spu_expand_builtin): Likewise.
+ * config/stormy16/stormy16.c (xstormy16_expand_builtin): Likewise.
+ * config/tilegx/tilegx.c (tilegx_expand_builtin): Likewise.
+ * config/tilepro/tilepro.c (tilepro_expand_builtin): Likewise.
+ * config/xtensa/xtensa.c (xtensa_fold_builtin): Likewise.
+ (xtensa_expand_builtin): Likewise.
+
2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
PR middle-end/91421
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * gcc-interface/trans.c (gigi): Call set_decl_buillt_in_function.
+ (Call_to_gnu): Use DECL_FE_FUNCTION_CODE instead of DECL_FUNCTION_CODE.
+
2019-08-13 Eric Botcazou <ebotcazou@adacore.com>
* ali.ads (Linker_Option_Record): Remove Original_Pos component.
build_function_type_list (integer_type_node, jmpbuf_ptr_type,
NULL_TREE),
NULL_TREE, is_default, true, true, true, false, false, NULL, Empty);
- DECL_BUILT_IN_CLASS (setjmp_decl) = BUILT_IN_NORMAL;
- DECL_FUNCTION_CODE (setjmp_decl) = BUILT_IN_SETJMP;
+ set_decl_built_in_function (setjmp_decl, BUILT_IN_NORMAL, BUILT_IN_SETJMP);
/* update_setjmp_buf updates a setjmp buffer from the current stack pointer
address. */
(get_identifier ("__builtin_update_setjmp_buf"), NULL_TREE,
build_function_type_list (void_type_node, jmpbuf_ptr_type, NULL_TREE),
NULL_TREE, is_default, true, true, true, false, false, NULL, Empty);
- DECL_BUILT_IN_CLASS (update_setjmp_buf_decl) = BUILT_IN_NORMAL;
- DECL_FUNCTION_CODE (update_setjmp_buf_decl) = BUILT_IN_UPDATE_SETJMP_BUF;
+ set_decl_built_in_function (update_setjmp_buf_decl, BUILT_IN_NORMAL,
+ BUILT_IN_UPDATE_SETJMP_BUF);
/* Indicate that it never returns. */
ftype = build_function_type_list (void_type_node,
tree pred_cst = build_int_cst (integer_type_node, PRED_BUILTIN_EXPECT);
enum internal_fn icode = IFN_BUILTIN_EXPECT;
- switch (DECL_FUNCTION_CODE (gnu_subprog))
+ switch (DECL_FE_FUNCTION_CODE (gnu_subprog))
{
case BUILT_IN_EXPECT:
break;
int ignore)
{
tree fndecl = get_callee_fndecl (exp);
- enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
int flags;
redundant checks and be sure, that possible overflow will be detected
by ASan. */
+ enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
if ((flag_sanitize & SANITIZE_ADDRESS) && asan_intercepted_p (fcode))
return expand_call (exp, target, ignore);
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * c-common.c (resolve_overloaded_builtin): Use
+ copy_decl_built_in_function.
+
2019-08-13 Martin Sebor <msebor@redhat.com>
PR c/80619
resolve_overloaded_builtin (location_t loc, tree function,
vec<tree, va_gc> *params)
{
- enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
-
/* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
Those are not valid to call with a pointer to _Bool (or C++ bool)
and so must be rejected. */
}
/* Handle BUILT_IN_NORMAL here. */
+ enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
switch (orig_code)
{
case BUILT_IN_SPECULATION_SAFE_VALUE_N:
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * c-decl.c (merge_decls): Use copy_decl_built_in_function.
+
2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
PR middle-end/91421
{
/* If redeclaring a builtin function, it stays built in.
But it gets tagged as having been declared. */
- DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
- DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
+ copy_decl_built_in_function (newdecl, olddecl);
C_DECL_DECLARED_BUILTIN (newdecl) = 1;
if (new_is_prototype)
{
if (fndecl_built_in_p (new_decl)
&& args_to_skip
&& !bitmap_empty_p (args_to_skip))
- {
- DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
- DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
- }
+ set_decl_built_in_function (new_decl, NOT_BUILT_IN, 0);
/* The FE might have information and assumptions about the other
arguments. */
DECL_LANG_SPECIFIC (new_decl) = NULL;
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- int fcode = DECL_FUNCTION_CODE (fndecl);
+ int fcode = DECL_MD_FUNCTION_CODE (fndecl);
int icode;
rtx pat, op0;
tree arg0;
aarch64_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED, tree *args,
bool ignore ATTRIBUTE_UNUSED)
{
- int fcode = DECL_FUNCTION_CODE (fndecl);
+ int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree type = TREE_TYPE (TREE_TYPE (fndecl));
switch (fcode)
fndecl = gimple_call_fndecl (stmt);
if (fndecl)
{
- int fcode = DECL_FUNCTION_CODE (fndecl);
+ int fcode = DECL_MD_FUNCTION_CODE (fndecl);
unsigned nargs = gimple_call_num_args (stmt);
tree *args = (nargs > 0
? gimple_call_arg_ptr (stmt, 0)
if (!use_rsqrt_p (mode))
return NULL_TREE;
- return aarch64_builtin_rsqrt (DECL_FUNCTION_CODE (fndecl));
+ return aarch64_builtin_rsqrt (DECL_MD_FUNCTION_CODE (fndecl));
}
/* Emit instruction sequence to compute either the approximate square root
#define MAX_ARGS 2
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree arg;
call_expr_arg_iterator iter;
enum insn_code icode;
}
}
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case ALPHA_BUILTIN_CMPBGE:
return alpha_fold_builtin_cmpbge (opint, op_const);
{
tree arg0, arg1;
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case ALPHA_BUILTIN_UMULH:
arg0 = gimple_call_arg (stmt, 0);
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int id = DECL_FUNCTION_CODE (fndecl);
+ unsigned int id = DECL_MD_FUNCTION_CODE (fndecl);
const struct arc_builtin_description *d = &arc_bdesc[id];
int i, j, n_args = call_expr_nargs (exp);
rtx pat = NULL_RTX;
rtx op1;
rtx op2;
rtx pat;
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
size_t i;
machine_mode tmode;
machine_mode mode0;
location_t loc = (location_t) iloc;
vec<tree, va_gc> &args = * (vec<tree, va_gc>*) vargs;
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
default:
break;
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
const char *bname = IDENTIFIER_POINTER (DECL_NAME (fndecl));
- unsigned int id = DECL_FUNCTION_CODE (fndecl);
+ unsigned int id = DECL_MD_FUNCTION_CODE (fndecl);
const struct avr_builtin_description *d = &avr_bdesc[id];
tree arg0;
rtx op0;
avr_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED, tree *arg,
bool ignore ATTRIBUTE_UNUSED)
{
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree val_type = TREE_TYPE (TREE_TYPE (fndecl));
if (!optimize)
enum insn_code icode;
const struct builtin_description *d;
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree arg0, arg1, arg2;
rtx op0, op1, op2, accvec, pat, tmp1, tmp2, a0reg, a1reg;
machine_mode tmode, mode0;
size_t i;
const struct builtin_description *d;
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
if (d->code == fcode)
in place of the existing, which may be NULL. */
DECL_LANG_SPECIFIC (cfsfun) = NULL;
(*lang_hooks.dup_lang_specific_decl) (cfsfun);
- DECL_BUILT_IN_CLASS (cfsfun) = BUILT_IN_MD;
- DECL_FUNCTION_CODE (cfsfun) = darwin_builtin_cfstring;
+ set_decl_built_in_function (cfsfun, BUILT_IN_MD, darwin_builtin_cfstring);
lang_hooks.builtin_function (cfsfun);
/* extern int __CFConstantStringClassReference[]; */
darwin_fold_builtin (tree fndecl, int n_args, tree *argp,
bool ARG_UNUSED (ignore))
{
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
if (fcode == darwin_builtin_cfstring)
{
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned fcode = (unsigned)DECL_FUNCTION_CODE (fndecl);
+ unsigned fcode = DECL_MD_FUNCTION_CODE (fndecl);
unsigned i;
struct builtin_description *d;
struct gcn_builtin_description *)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case GCN_BUILTIN_FLAT_LOAD_INT32:
{
int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
struct gcn_builtin_description *d;
gcc_assert (fcode < GCN_BUILTIN_MAX);
ix86_builtin_reciprocal (tree fndecl)
{
enum ix86_builtins fn_code
- = (enum ix86_builtins) DECL_FUNCTION_CODE (fndecl);
+ = (enum ix86_builtins) DECL_MD_FUNCTION_CODE (fndecl);
switch (fn_code)
{
/* Vectorized version of sqrt to rsqrt conversion. */
fold_builtin_cpu (tree fndecl, tree *args)
{
unsigned int i;
- enum ix86_builtins fn_code = (enum ix86_builtins)
- DECL_FUNCTION_CODE (fndecl);
+ enum ix86_builtins fn_code
+ = (enum ix86_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree param_string_cst = NULL;
tree __processor_model_type = build_processor_model_struct ();
tree arg0, arg1, arg2, arg3, arg4;
rtx op0, op1, op2, op3, op4, pat, pat2, insn;
machine_mode mode0, mode1, mode2, mode3, mode4;
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
/* For CPU builtins that can be folded, fold first and expand the fold. */
switch (fcode)
tree fndecl = gimple_call_fndecl (def_stmt);
if (fndecl
&& fndecl_built_in_p (fndecl, BUILT_IN_MD))
- switch ((unsigned int) DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case IX86_BUILTIN_CMPPD:
case IX86_BUILTIN_CMPPS:
{
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
{
- enum ix86_builtins fn_code = (enum ix86_builtins)
- DECL_FUNCTION_CODE (fndecl);
+ enum ix86_builtins fn_code
+ = (enum ix86_builtins) DECL_MD_FUNCTION_CODE (fndecl);
enum rtx_code rcode;
bool is_vshift;
unsigned HOST_WIDE_INT mask;
tree fndecl = gimple_call_fndecl (stmt);
gcc_checking_assert (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_MD));
int n_args = gimple_call_num_args (stmt);
- enum ix86_builtins fn_code = (enum ix86_builtins) DECL_FUNCTION_CODE (fndecl);
+ enum ix86_builtins fn_code
+ = (enum ix86_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree decl = NULL_TREE;
tree arg0, arg1, arg2;
enum rtx_code rcode;
{
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
{
- enum ia64_builtins fn_code = (enum ia64_builtins)
- DECL_FUNCTION_CODE (fndecl);
+ enum ia64_builtins fn_code
+ = (enum ia64_builtins) DECL_MD_FUNCTION_CODE (fndecl);
switch (fn_code)
{
case IA64_BUILTIN_NANQ:
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
switch (fcode)
{
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- int fcode = DECL_FUNCTION_CODE (fndecl);
+ int fcode = DECL_MD_FUNCTION_CODE (fndecl);
enum rtx_code code [5];
code[0] = REG;
const struct mips_builtin_description *d;
fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- fcode = DECL_FUNCTION_CODE (fndecl);
+ fcode = DECL_MD_FUNCTION_CODE (fndecl);
gcc_assert (fcode < ARRAY_SIZE (mips_builtins));
d = &mips_builtins[fcode];
avail = d->avail ();
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
rtx arg1 = expand_normal (CALL_EXPR_ARG (exp, 0));
if (fcode == MSP430_BUILTIN_DELAY_CYCLES)
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
unsigned i;
struct builtin_description *d;
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
if (fcode < nios2_fpu_builtin_base)
{
machine_mode mode, int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case NVPTX_BUILTIN_SHUFFLE:
case NVPTX_BUILTIN_SHUFFLELL:
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
switch (fcode)
{
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
rtx arg1 = expand_normal (CALL_EXPR_ARG (exp, 0));
if (fcode == PRU_BUILTIN_DELAY_CYCLES)
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
const struct riscv_builtin_description *d = &riscv_builtins[fcode];
switch (d->builtin_type)
vec<tree, va_gc> *arglist = static_cast<vec<tree, va_gc> *> (passed_arglist);
unsigned int nargs = vec_safe_length (arglist);
enum rs6000_builtins fcode
- = (enum rs6000_builtins)DECL_FUNCTION_CODE (fndecl);
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree fnargs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
tree types[3], args[3];
const struct altivec_builtin_types *desc;
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
bool nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
- enum rs6000_builtins fcode = (enum rs6000_builtins) DECL_FUNCTION_CODE (fndecl);
+ enum rs6000_builtins fcode
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
const struct builtin_description *d;
size_t i;
bool *expandedp)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- enum rs6000_builtins fcode = (enum rs6000_builtins) DECL_FUNCTION_CODE (fndecl);
+ enum rs6000_builtins fcode
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree arg0, arg1, arg2;
machine_mode mode0, mode1;
rtx pat, op0, op1, op2;
rtx op0, pat;
machine_mode tmode, mode0;
enum rs6000_builtins fcode
- = (enum rs6000_builtins) DECL_FUNCTION_CODE (fndecl);
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
if (rs6000_overloaded_builtin_p (fcode))
{
tree fndecl = gimple_call_fndecl (stmt);
gcc_checking_assert (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD);
enum rs6000_builtins fn_code
- = (enum rs6000_builtins) DECL_FUNCTION_CODE (fndecl);
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree arg0, arg1, lhs, temp;
enum tree_code bcode;
gimple *g;
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
enum rs6000_builtins fcode
- = (enum rs6000_builtins)DECL_FUNCTION_CODE (fndecl);
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
size_t uns_fcode = (size_t)fcode;
const struct builtin_description *d;
size_t i;
in_n = TYPE_VECTOR_SUBPARTS (type_in);
enum rs6000_builtins fn
- = (enum rs6000_builtins) DECL_FUNCTION_CODE (fndecl);
+ = (enum rs6000_builtins) DECL_MD_FUNCTION_CODE (fndecl);
switch (fn)
{
case RS6000_BUILTIN_RSQRTF:
static tree
rs6000_builtin_reciprocal (tree fndecl)
{
- switch (DECL_FUNCTION_CODE (fndecl))
+ switch (DECL_MD_FUNCTION_CODE (fndecl))
{
case VSX_BUILTIN_XVSQRTDP:
if (!RS6000_RECIP_AUTO_RSQRTE_P (V2DFmode))
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
tree arg = call_expr_nargs (exp) >= 1 ? CALL_EXPR_ARG (exp, 0) : NULL_TREE;
rtx op = arg ? expand_normal (arg) : NULL_RTX;
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
switch (fcode)
{
vec<tree, va_gc> *arglist = static_cast<vec<tree, va_gc> *> (passed_arglist);
unsigned int in_args_num = vec_safe_length (arglist);
unsigned int ob_args_num = 0;
- unsigned int ob_fcode = DECL_FUNCTION_CODE (ob_fndecl);
+ unsigned int ob_fcode = DECL_MD_FUNCTION_CODE (ob_fndecl);
enum s390_overloaded_builtin_vars bindex;
unsigned int i;
int last_match_type = INT_MAX;
#define MAX_ARGS 6
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
enum insn_code icode;
rtx op[MAX_ARGS], pat;
int arity;
machine_mode mode ATTRIBUTE_UNUSED, int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
const struct builtin_description *d = &bdesc[fcode];
enum insn_code icode = d->icode;
int signature = d->signature;
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- enum sparc_builtins code = (enum sparc_builtins) DECL_FUNCTION_CODE (fndecl);
+ enum sparc_builtins code
+ = (enum sparc_builtins) DECL_MD_FUNCTION_CODE (fndecl);
enum insn_code icode = sparc_builtins_icode[code];
bool nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
call_expr_arg_iterator iter;
sparc_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED,
tree *args, bool ignore)
{
- enum sparc_builtins code = (enum sparc_builtins) DECL_FUNCTION_CODE (fndecl);
+ enum sparc_builtins code
+ = (enum sparc_builtins) DECL_MD_FUNCTION_CODE (fndecl);
tree rtype = TREE_TYPE (TREE_TYPE (fndecl));
tree arg0, arg1, arg2;
|| POINTER_TYPE_P (t))
vec<tree, va_gc> *fnargs = static_cast <vec<tree, va_gc> *> (passed_args);
unsigned int nargs = vec_safe_length (fnargs);
- int new_fcode, fcode = DECL_FUNCTION_CODE (fndecl);
+ int new_fcode, fcode = DECL_MD_FUNCTION_CODE (fndecl);
struct spu_builtin_description *desc;
tree match = NULL_TREE;
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
struct spu_builtin_description *d;
if (fcode < NUM_SPU_BUILTINS)
fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
argtree = TREE_OPERAND (exp, 1);
- i = DECL_FUNCTION_CODE (fndecl);
+ i = DECL_MD_FUNCTION_CODE (fndecl);
code = s16builtins[i].md_code;
for (a = 0; a < 10 && argtree; a++)
#define MAX_BUILTIN_ARGS 4
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree arg;
call_expr_arg_iterator iter;
enum insn_code icode;
#define MAX_BUILTIN_ARGS 4
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree arg;
call_expr_arg_iterator iter;
enum insn_code icode;
xtensa_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED, tree *args,
bool ignore ATTRIBUTE_UNUSED)
{
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
tree arg0, arg1;
switch (fcode)
int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+ unsigned int fcode = DECL_MD_FUNCTION_CODE (fndecl);
switch (fcode)
{
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * decl.c (duplicate_decls): Use copy_decl_built_in_function.
+ * pt.c (declare_integer_pack): Use set_decl_built_in_function.
+
2019-08-13 Marek Polacek <polacek@redhat.com>
PR c++/90473 - wrong code with nullptr in default argument.
if (fndecl_built_in_p (olddecl)
&& (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
{
- DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
- DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
+ copy_decl_built_in_function (newdecl, olddecl);
/* If we're keeping the built-in definition, keep the rtl,
regardless of declaration matches. */
COPY_DECL_RTL (olddecl, newdecl);
NULL_TREE),
NULL_TREE, ECF_CONST);
DECL_DECLARED_CONSTEXPR_P (ipfn) = true;
- DECL_BUILT_IN_CLASS (ipfn) = BUILT_IN_FRONTEND;
- DECL_FUNCTION_CODE (ipfn)
- = (enum built_in_function) (int) CP_BUILT_IN_INTEGER_PACK;
+ set_decl_built_in_function (ipfn, BUILT_IN_FRONTEND,
+ CP_BUILT_IN_INTEGER_PACK);
}
/* Set up the hash tables for template instantiations. */
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * intrinsics.cc (maybe_set_intrinsic): Use set_decl_built_in_function.
+
2019-08-11 Iain Buclaw <ibuclaw@gdcproject.org>
PR d/90601
/* If there is no function body, then the implementation is always
provided by the compiler. */
if (!decl->fbody)
- {
- DECL_BUILT_IN_CLASS (decl->csym) = BUILT_IN_FRONTEND;
- DECL_FUNCTION_CODE (decl->csym) = (built_in_function) code;
- }
+ set_decl_built_in_function (decl->csym, BUILT_IN_FRONTEND, code);
/* Infer whether the intrinsic can be used for CTFE, let the
front-end know that it can be evaluated at compile-time. */
return (TREE_CODE (arg0) == FUNCTION_DECL
&& fndecl_built_in_p (arg0) && fndecl_built_in_p (arg1)
&& DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
- && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
+ && (DECL_UNCHECKED_FUNCTION_CODE (arg0)
+ == DECL_UNCHECKED_FUNCTION_CODE (arg1)));
case tcc_exceptional:
if (TREE_CODE (arg0) == CONSTRUCTOR)
/* When signature changes, we need to clear builtin info. */
if (fndecl_built_in_p (fndecl))
- {
- DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
- DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
- }
+ set_decl_built_in_function (fndecl, NOT_BUILT_IN, 0);
TREE_TYPE (fndecl) = new_type;
DECL_VIRTUAL_P (fndecl) = 0;
changes. For partial inlining we however cannot expect the part
of builtin implementation to have same semantic as the whole. */
if (fndecl_built_in_p (node->decl))
- {
- DECL_BUILT_IN_CLASS (node->decl) = NOT_BUILT_IN;
- DECL_FUNCTION_CODE (node->decl) = (enum built_in_function) 0;
- }
+ set_decl_built_in_function (node->decl, NOT_BUILT_IN, 0);
/* If return_bb contains any clobbers that refer to SSA_NAMEs
set in the split part, remove them. Also reset debug stmts that
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * jit-playback.c (new_function): Use set_decl_built_in_function.
+
2019-07-22 Andrea Corallo <andrea.corallo@arm.com>
* jit-recording.c (unary_op_reproducer_strings): Make it extern.
if (builtin_id)
{
- DECL_FUNCTION_CODE (fndecl) = builtin_id;
gcc_assert (loc == NULL);
DECL_SOURCE_LOCATION (fndecl) = BUILTINS_LOCATION;
- DECL_BUILT_IN_CLASS (fndecl) =
- builtins_manager::get_class (builtin_id);
+ built_in_class fclass = builtins_manager::get_class (builtin_id);
+ set_decl_built_in_function (fndecl, fclass, builtin_id);
set_builtin_decl (builtin_id, fndecl,
builtins_manager::implicit_p (builtin_id));
TREE_PUBLIC (decl) = 1;
DECL_EXTERNAL (decl) = 1;
- DECL_BUILT_IN_CLASS (decl) = cl;
- DECL_FUNCTION_CODE (decl) = (enum built_in_function) function_code;
-
- /* DECL_FUNCTION_CODE is a bitfield; verify that the value fits. */
- gcc_assert (DECL_FUNCTION_CODE (decl) == function_code);
+ set_decl_built_in_function (decl, cl, function_code);
if (library_name)
{
hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t));
hstate.commit_flag ();
if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
- hstate.add_int (DECL_FUNCTION_CODE (t));
+ hstate.add_int (DECL_UNCHECKED_FUNCTION_CODE (t));
}
if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
+2019-08-13 Richard Sandiford <richard.sandiford@arm.com>
+
+ PR middle-end/91421
+ * lto-common.c (compare_tree_sccs_1): Use DECL_UNCHECKED_FUNCTION_CODE
+ instead of DECL_FUNCTION_CODE.
+ * lto-symtab.c (lto_symtab_merge_p): Likewise.
+
2019-08-01 Bernd Edlinger <bernd.edlinger@hotmail.de>
* Make-lang.in (lto.install-common): Remove unnecessary slash
compare_values (DECL_CXX_CONSTRUCTOR_P);
compare_values (DECL_CXX_DESTRUCTOR_P);
if (DECL_BUILT_IN_CLASS (t1) != NOT_BUILT_IN)
- compare_values (DECL_FUNCTION_CODE);
+ compare_values (DECL_UNCHECKED_FUNCTION_CODE);
}
if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
}
if (fndecl_built_in_p (prevailing)
&& (DECL_BUILT_IN_CLASS (prevailing) != DECL_BUILT_IN_CLASS (decl)
- || DECL_FUNCTION_CODE (prevailing) != DECL_FUNCTION_CODE (decl)))
+ || (DECL_UNCHECKED_FUNCTION_CODE (prevailing)
+ != DECL_UNCHECKED_FUNCTION_CODE (decl))))
{
if (dump_file)
fprintf (dump_file, "Not merging decls; "
if (new_node == NULL)
return new_node;
- DECL_BUILT_IN_CLASS (new_node->decl) = NOT_BUILT_IN;
- DECL_FUNCTION_CODE (new_node->decl) = (enum built_in_function) 0;
+ set_decl_built_in_function (new_node->decl, NOT_BUILT_IN, 0);
TREE_PUBLIC (new_node->decl) = TREE_PUBLIC (old_node->decl);
DECL_COMDAT (new_node->decl) = DECL_COMDAT (old_node->decl);
DECL_WEAK (new_node->decl) = DECL_WEAK (old_node->decl);
if (code == FUNCTION_DECL && fndecl_built_in_p (node))
{
if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
- fprintf (file, " built-in: BUILT_IN_MD:%d", DECL_FUNCTION_CODE (node));
+ fprintf (file, " built-in: BUILT_IN_MD:%d",
+ DECL_MD_FUNCTION_CODE (node));
+ else if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_FRONTEND)
+ fprintf (file, " built-in: BUILT_IN_FRONTEND:%d",
+ DECL_FE_FUNCTION_CODE (node));
else
fprintf (file, " built-in: %s:%s",
built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
/* Index within a virtual table. */
tree vindex;
- /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
- DECL_FUNCTION_CODE. Otherwise unused. */
- enum built_in_function function_code;
+ /* In a FUNCTION_DECL this is DECL_UNCHECKED_FUNCTION_CODE. */
+ unsigned int function_code;
ENUM_BITFIELD(built_in_class) built_in_class : 2;
unsigned static_ctor_flag : 1;
static void
unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
{
- DECL_BUILT_IN_CLASS (expr) = bp_unpack_enum (bp, built_in_class,
- BUILT_IN_LAST);
+ built_in_class cl = bp_unpack_enum (bp, built_in_class, BUILT_IN_LAST);
DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
- if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
+ unsigned int fcode = 0;
+ if (cl != NOT_BUILT_IN)
{
- DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp,
- 12);
- if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (expr) >= END_BUILTINS)
+ fcode = bp_unpack_value (bp, 32);
+ if (cl == BUILT_IN_NORMAL && fcode >= END_BUILTINS)
fatal_error (input_location,
"machine independent builtin code out of range");
- else if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD)
+ else if (cl == BUILT_IN_MD)
{
- tree result = targetm.builtin_decl (DECL_FUNCTION_CODE (expr), true);
+ tree result = targetm.builtin_decl (fcode, true);
if (!result || result == error_mark_node)
fatal_error (input_location,
"target specific builtin not available");
}
}
+ set_decl_built_in_function (expr, cl, fcode);
}
bp_pack_value (bp, DECL_PURE_P (expr), 1);
bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
- bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 12);
+ bp_pack_value (bp, DECL_UNCHECKED_FUNCTION_CODE (expr), 32);
}
(DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))
/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
- operation it is. Note, however, that this field is overloaded, with
- DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be
- checked before any access to the former. */
-#define DECL_FUNCTION_CODE(NODE) \
+ operation it is. This is only intended for low-level accesses;
+ normally DECL_FUNCTION_CODE, DECL_FE_FUNCTION_CODE or DECL_MD_FUNCTION
+ should be used instead. */
+#define DECL_UNCHECKED_FUNCTION_CODE(NODE) \
(FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
/* Test if FCODE is a function code for an alloca operation. */
#define DECL_STRUCT_FUNCTION(NODE) \
(FUNCTION_DECL_CHECK (NODE)->function_decl.f)
-
/* For a builtin function, identify which part of the compiler defined it. */
#define DECL_BUILT_IN_CLASS(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
+ ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
/* In FUNCTION_DECL, a chain of ..._DECL nodes. */
#define DECL_ARGUMENTS(NODE) \
return true;
}
+/* Return the built-in function that DECL represents, given that it is known
+ to be a FUNCTION_DECL with built-in class BUILT_IN_NORMAL. */
+inline built_in_function
+DECL_FUNCTION_CODE (const_tree decl)
+{
+ const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
+ gcc_checking_assert (fndecl.built_in_class == BUILT_IN_NORMAL);
+ return (built_in_function) fndecl.function_code;
+}
+
+/* Return the target-specific built-in function that DECL represents,
+ given that it is known to be a FUNCTION_DECL with built-in class
+ BUILT_IN_MD. */
+inline int
+DECL_MD_FUNCTION_CODE (const_tree decl)
+{
+ const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
+ gcc_checking_assert (fndecl.built_in_class == BUILT_IN_MD);
+ return fndecl.function_code;
+}
+
+/* Return the frontend-specific built-in function that DECL represents,
+ given that it is known to be a FUNCTION_DECL with built-in class
+ BUILT_IN_FRONTEND. */
+inline int
+DECL_FE_FUNCTION_CODE (const_tree decl)
+{
+ const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
+ gcc_checking_assert (fndecl.built_in_class == BUILT_IN_FRONTEND);
+ return fndecl.function_code;
+}
+
+/* Record that FUNCTION_DECL DECL represents built-in function FCODE of
+ class FCLASS. */
+inline void
+set_decl_built_in_function (tree decl, built_in_class fclass,
+ unsigned int fcode)
+{
+ tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
+ fndecl.built_in_class = fclass;
+ fndecl.function_code = fcode;
+}
+
+/* Record that FUNCTION_DECL NEWDECL represents the same built-in function
+ as OLDDECL (or none, if OLDDECL doesn't represent a built-in function). */
+inline void
+copy_decl_built_in_function (tree newdecl, const_tree olddecl)
+{
+ tree_function_decl &newfndecl = FUNCTION_DECL_CHECK (newdecl)->function_decl;
+ const tree_function_decl &oldfndecl
+ = FUNCTION_DECL_CHECK (olddecl)->function_decl;
+ newfndecl.built_in_class = oldfndecl.built_in_class;
+ newfndecl.function_code = oldfndecl.function_code;
+}
+
/* In NON_LVALUE_EXPR and VIEW_CONVERT_EXPR, set when this node is merely a
wrapper added to express a location_t on behalf of the node's child
(e.g. by maybe_wrap_with_location). */
of class KLASS with name equal to NAME. */
inline bool
-fndecl_built_in_p (const_tree node, int name, built_in_class klass)
+fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
{
- return (fndecl_built_in_p (node, klass) && DECL_FUNCTION_CODE (node) == name);
+ return (fndecl_built_in_p (node, klass)
+ && DECL_UNCHECKED_FUNCTION_CODE (node) == name);
}
/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
projects / thirdparty / gcc.git / commitdiff
