-/* Copyright (C) 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
- Software Foundation; either version 2 of the License, or (at your option)
+ Software Foundation; either version 3 of the License, or (at your option)
any later version.
This file is distributed in the hope that it will be useful, but WITHOUT
for more details.
You should have received a copy of the GNU General Public License
- along with this file; see the file COPYING. If not, write to the Free
- Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with GCC; see the file COPYING3. If not see
+ <http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "function.h"
#include "rtl.h"
#include "expr.h"
-#include "errors.h"
#include "tm_p.h"
#include "langhooks.h"
#include "insn-config.h"
#include "insn-codes.h"
#include "recog.h"
#include "optabs.h"
-#include "spu-builtins.h"
-
-static rtx spu_expand_builtin_1 (struct spu_builtin_description *d,
- tree arglist, rtx target);
-static void spu_check_builtin_parm (struct spu_builtin_description *, rtx,
- int);
-static void expand_builtin_args (struct spu_builtin_description *, tree, rtx,
- rtx[]);
-static rtx spu_force_reg (enum machine_mode mode, rtx op);
-
-/* Builtin types, data and prototypes. */
-struct spu_builtin_range
-{
- int low, high;
-};
-
-static struct spu_builtin_range spu_builtin_range[] = {
- {-0x40ll, 0x7fll}, /* SPU_BTI_7 */
- {-0x40ll, 0x3fll}, /* SPU_BTI_S7 */
- {0ll, 0x7fll}, /* SPU_BTI_U7 */
- {-0x200ll, 0x1ffll}, /* SPU_BTI_S10 */
- {-0x2000ll, 0x1fffll}, /* SPU_BTI_S10_4 */
- {0ll, 0x3fffll}, /* SPU_BTI_U14 */
- {-0x8000ll, 0xffffll}, /* SPU_BTI_16 */
- {-0x8000ll, 0x7fffll}, /* SPU_BTI_S16 */
- {-0x20000ll, 0x1ffffll}, /* SPU_BTI_S16_2 */
- {0ll, 0xffffll}, /* SPU_BTI_U16 */
- {0ll, 0x3ffffll}, /* SPU_BTI_U16_2 */
- {0ll, 0x3ffffll}, /* SPU_BTI_U18 */
-};
\f
-/* Helper for spu_resolve_overloaded_builtin. */
-static tree
-spu_build_overload_builtin (tree fndecl, tree fnargs)
+/* Keep the vector keywords handy for fast comparisons. */
+static GTY(()) tree __vector_keyword;
+static GTY(()) tree vector_keyword;
+
+static cpp_hashnode *
+spu_categorize_keyword (const cpp_token *tok)
{
- tree param, param_type;
- tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
- tree arg, arglist = NULL_TREE;
- tree val;
-
- for (param = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), arg = fnargs;
- param != void_list_node;
- param = TREE_CHAIN (param), arg = TREE_CHAIN (arg))
+ if (tok->type == CPP_NAME)
{
- gcc_assert (arg != NULL_TREE);
- param_type = TREE_VALUE (param);
- val = default_conversion (TREE_VALUE (arg));
- val = fold_convert (param_type, val);
+ cpp_hashnode *ident = tok->val.node.node;
- arglist = tree_cons (NULL_TREE, val, arglist);
+ if (ident == C_CPP_HASHNODE (vector_keyword)
+ || ident == C_CPP_HASHNODE (__vector_keyword))
+ return C_CPP_HASHNODE (__vector_keyword);
+ else
+ return ident;
}
- gcc_assert (arg == NULL_TREE);
- arglist = nreverse (arglist);
+ return 0;
+}
+
+/* Called to decide whether a conditional macro should be expanded.
+ Since we have exactly one such macro (i.e, 'vector'), we do not
+ need to examine the 'tok' parameter. */
- return fold_convert (ret_type, build_function_call_expr (fndecl, arglist));
+static cpp_hashnode *
+spu_macro_to_expand (cpp_reader *pfile, const cpp_token *tok)
+{
+ cpp_hashnode *expand_this = tok->val.node.node;
+ cpp_hashnode *ident;
+
+ ident = spu_categorize_keyword (tok);
+ if (ident == C_CPP_HASHNODE (__vector_keyword))
+ {
+ tok = cpp_peek_token (pfile, 0);
+ ident = spu_categorize_keyword (tok);
+
+ if (ident)
+ {
+ enum rid rid_code = (enum rid)(ident->rid_code);
+ if (ident->type == NT_MACRO)
+ {
+ (void) cpp_get_token (pfile);
+ tok = cpp_peek_token (pfile, 0);
+ ident = spu_categorize_keyword (tok);
+ if (ident)
+ rid_code = (enum rid)(ident->rid_code);
+ }
+
+ if (rid_code == RID_UNSIGNED || rid_code == RID_LONG
+ || rid_code == RID_SHORT || rid_code == RID_SIGNED
+ || rid_code == RID_INT || rid_code == RID_CHAR
+ || rid_code == RID_FLOAT || rid_code == RID_DOUBLE)
+ expand_this = C_CPP_HASHNODE (__vector_keyword);
+ }
+ }
+ return expand_this;
}
/* target hook for resolve_overloaded_builtin(). Returns a function call
RTX if we can resolve the overloaded builtin */
tree
-spu_resolve_overloaded_builtin (tree fndecl, tree fnargs)
+spu_resolve_overloaded_builtin (location_t loc, tree fndecl, void *passed_args)
{
- spu_function_code new_fcode, fcode =
- DECL_FUNCTION_CODE (fndecl) - END_BUILTINS;
+#define SCALAR_TYPE_P(t) (INTEGRAL_TYPE_P (t) \
+ || SCALAR_FLOAT_TYPE_P (t) \
+ || POINTER_TYPE_P (t))
+ VEC(tree,gc) *fnargs = (VEC(tree,gc) *) passed_args;
+ unsigned int nargs = VEC_length (tree, fnargs);
+ int new_fcode, fcode = DECL_FUNCTION_CODE (fndecl) - END_BUILTINS;
struct spu_builtin_description *desc;
tree match = NULL_TREE;
- /* The vector types are not available if the backend is not initalized */
+ /* The vector types are not available if the backend is not initialized. */
gcc_assert (!flag_preprocess_only);
desc = &spu_builtins[fcode];
{
tree decl = spu_builtins[new_fcode].fndecl;
tree params = TYPE_ARG_TYPES (TREE_TYPE (decl));
- tree arg, param;
- int p;
+ tree param;
+ bool all_scalar;
+ unsigned int p;
+
+ /* Check whether all parameters are scalar. */
+ all_scalar = true;
+ for (param = params; param != void_list_node; param = TREE_CHAIN (param))
+ if (!SCALAR_TYPE_P (TREE_VALUE (param)))
+ all_scalar = false;
- for (param = params, arg = fnargs, p = 0;
+ for (param = params, p = 0;
param != void_list_node;
- param = TREE_CHAIN (param), arg = TREE_CHAIN (arg), p++)
+ param = TREE_CHAIN (param), p++)
{
tree var, arg_type, param_type = TREE_VALUE (param);
- if (!arg)
+ if (p >= nargs)
{
error ("insufficient arguments to overloaded function %s",
desc->name);
return error_mark_node;
}
- var = TREE_VALUE (arg);
+ var = VEC_index (tree, fnargs, p);
if (TREE_CODE (var) == NON_LVALUE_EXPR)
var = TREE_OPERAND (var, 0);
checking/promotions for scalar arguments, except for the
first argument of intrinsics which don't have a vector
parameter. */
- if ((TREE_CODE (param_type) == VECTOR_TYPE
- || ((fcode == SPU_SPLATS || fcode == SPU_PROMOTE
- || fcode == SPU_HCMPEQ || fcode == SPU_HCMPGT
- || fcode == SPU_MASKB || fcode == SPU_MASKH
- || fcode == SPU_MASKW) && p == 0))
- && !comptypes (TYPE_MAIN_VARIANT (param_type),
- TYPE_MAIN_VARIANT (arg_type)))
+ if ((!SCALAR_TYPE_P (param_type)
+ || !SCALAR_TYPE_P (arg_type)
+ || (all_scalar && p == 0))
+ && !lang_hooks.types_compatible_p (param_type, arg_type))
break;
}
if (param == void_list_node)
{
- if (arg)
+ if (p != nargs)
{
error ("too many arguments to overloaded function %s",
desc->name);
return error_mark_node;
}
- return spu_build_overload_builtin (match, fnargs);
+ return build_function_call_vec (loc, match, fnargs, NULL);
+#undef SCALAR_TYPE_P
}
-static void
-spu_check_builtin_parm (struct spu_builtin_description *d, rtx op, int p)
-{
- HOST_WIDE_INT v = 0;
- int lsbits;
- /* Check the range of immediate operands. */
- if (p >= SPU_BTI_7 && p <= SPU_BTI_U18)
- {
- int range = p - SPU_BTI_7;
- if (!CONSTANT_P (op)
- || (GET_CODE (op) == CONST_INT
- && (INTVAL (op) < spu_builtin_range[range].low
- || INTVAL (op) > spu_builtin_range[range].high)))
- error ("%s expects an integer literal in the range [%d, %d].",
- d->name,
- spu_builtin_range[range].low, spu_builtin_range[range].high);
-
- if (GET_CODE (op) == CONST
- && (GET_CODE (XEXP (op, 0)) == PLUS
- || GET_CODE (XEXP (op, 0)) == MINUS))
- {
- v = INTVAL (XEXP (XEXP (op, 0), 1));
- op = XEXP (XEXP (op, 0), 0);
- }
- else if (GET_CODE (op) == CONST_INT)
- v = INTVAL (op);
- switch (p)
- {
- case SPU_BTI_S10_4:
- lsbits = 4;
- break;
- case SPU_BTI_U16_2:
- /* This is only used in lqa, and stqa. Even though the insns
- encode 16 bits of the address (all but the 2 least
- significant), only 14 bits are used because it is masked to
- be 16 byte aligned. */
- lsbits = 4;
- break;
- case SPU_BTI_S16_2:
- /* This is used for lqr and stqr. */
- lsbits = 2;
- break;
- default:
- lsbits = 0;
- }
-
- if (GET_CODE (op) == LABEL_REF
- || (GET_CODE (op) == SYMBOL_REF
- && SYMBOL_REF_FUNCTION_P (op))
- || (INTVAL (op) & ((1 << lsbits) - 1)) != 0)
- warning (0, "%d least significant bits of %s are ignored.", lsbits,
- d->name);
- }
-}
-
-static void
-expand_builtin_args (struct spu_builtin_description *d, tree arglist,
- rtx target, rtx ops[])
+void
+spu_cpu_cpp_builtins (struct cpp_reader *pfile)
{
- enum insn_code icode = d->icode;
- int i = 0;
-
- /* Expand the arguments into rtl. */
-
- if (d->parm[0] != SPU_BTI_VOID)
- ops[i++] = target;
-
- for (; i < insn_data[icode].n_operands; i++)
- {
- tree arg = TREE_VALUE (arglist);
- if (arg == 0)
- abort ();
- ops[i] = expand_expr (arg, NULL_RTX, VOIDmode, 0);
- arglist = TREE_CHAIN (arglist);
- }
-}
-
-static rtx
-spu_expand_builtin_1 (struct spu_builtin_description *d,
- tree arglist, rtx target)
-{
- rtx pat;
- rtx ops[8];
- enum insn_code icode = d->icode;
- enum machine_mode mode, tmode;
- int i, p;
- tree return_type;
-
- /* Set up ops[] with values from arglist. */
- expand_builtin_args (d, arglist, target, ops);
-
- /* Handle the target operand which must be operand 0. */
- i = 0;
- if (d->parm[0] != SPU_BTI_VOID)
- {
-
- /* We prefer the mode specified for the match_operand otherwise
- use the mode from the builtin function prototype. */
- tmode = insn_data[d->icode].operand[0].mode;
- if (tmode == VOIDmode)
- tmode = TYPE_MODE (spu_builtin_types[d->parm[0]]);
-
- /* Try to use target because not using it can lead to extra copies
- and when we are using all of the registers extra copies leads
- to extra spills. */
- if (target && GET_CODE (target) == REG && GET_MODE (target) == tmode)
- ops[0] = target;
- else
- target = ops[0] = gen_reg_rtx (tmode);
-
- if (!(*insn_data[icode].operand[0].predicate) (ops[0], tmode))
- abort ();
-
- i++;
- }
-
- /* Ignore align_hint, but still expand it's args in case they have
- side effects. */
- if (icode == CODE_FOR_spu_align_hint)
- return 0;
-
- /* Handle the rest of the operands. */
- for (p = 1; i < insn_data[icode].n_operands; i++, p++)
- {
- if (insn_data[d->icode].operand[i].mode != VOIDmode)
- mode = insn_data[d->icode].operand[i].mode;
- else
- mode = TYPE_MODE (spu_builtin_types[d->parm[i]]);
-
- /* mode can be VOIDmode here for labels */
-
- /* For specific intrinsics with an immediate operand, e.g.,
- si_ai(), we sometimes need to convert the scalar argument to a
- vector argument by splatting the scalar. */
- if (VECTOR_MODE_P (mode)
- && (GET_CODE (ops[i]) == CONST_INT
- || GET_MODE_CLASS (GET_MODE (ops[i])) == MODE_INT
- || GET_MODE_CLASS (GET_MODE (ops[i])) == MODE_FLOAT))
- {
- if (GET_CODE (ops[i]) == CONST_INT)
- ops[i] = spu_const (mode, INTVAL (ops[i]));
- else
- {
- rtx reg = gen_reg_rtx (mode);
- enum machine_mode imode = GET_MODE_INNER (mode);
- if (!spu_nonmem_operand (ops[i], GET_MODE (ops[i])))
- ops[i] = force_reg (GET_MODE (ops[i]), ops[i]);
- if (imode != GET_MODE (ops[i]))
- ops[i] = convert_to_mode (imode, ops[i],
- TYPE_UNSIGNED (spu_builtin_types
- [d->parm[i]]));
- emit_insn (gen_spu_splats (reg, ops[i]));
- ops[i] = reg;
- }
- }
-
- if (!(*insn_data[icode].operand[i].predicate) (ops[i], mode))
- ops[i] = spu_force_reg (mode, ops[i]);
-
- spu_check_builtin_parm (d, ops[i], d->parm[p]);
- }
-
- switch (insn_data[icode].n_operands)
+ builtin_define_std ("__SPU__");
+ cpp_assert (pfile, "cpu=spu");
+ cpp_assert (pfile, "machine=spu");
+ if (spu_arch == PROCESSOR_CELLEDP)
+ builtin_define_std ("__SPU_EDP__");
+ builtin_define_std ("__vector=__attribute__((__spu_vector__))");
+ switch (spu_ea_model)
{
- case 0:
- pat = GEN_FCN (icode) (0);
- break;
- case 1:
- pat = GEN_FCN (icode) (ops[0]);
- break;
- case 2:
- pat = GEN_FCN (icode) (ops[0], ops[1]);
- break;
- case 3:
- pat = GEN_FCN (icode) (ops[0], ops[1], ops[2]);
+ case 32:
+ builtin_define_std ("__EA32__");
break;
- case 4:
- pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3]);
- break;
- case 5:
- pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3], ops[4]);
- break;
- case 6:
- pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3], ops[4], ops[5]);
+ case 64:
+ builtin_define_std ("__EA64__");
break;
default:
- abort ();
- }
-
- if (!pat)
- abort ();
-
- if (d->type == B_CALL || d->type == B_BISLED)
- emit_call_insn (pat);
- else if (d->type == B_JUMP)
- {
- emit_jump_insn (pat);
- emit_barrier ();
+ gcc_unreachable ();
}
- else
- emit_insn (pat);
- return_type = spu_builtin_types[d->parm[0]];
- if (d->parm[0] != SPU_BTI_VOID
- && GET_MODE (target) != TYPE_MODE (return_type))
+ if (!flag_iso)
{
- /* target is the return value. It should always be the mode of
- the builtin function prototype. */
- target = spu_force_reg (TYPE_MODE (return_type), target);
+ /* Define this when supporting context-sensitive keywords. */
+ cpp_define (pfile, "__VECTOR_KEYWORD_SUPPORTED__");
+ cpp_define (pfile, "vector=vector");
+
+ /* Initialize vector keywords. */
+ __vector_keyword = get_identifier ("__vector");
+ C_CPP_HASHNODE (__vector_keyword)->flags |= NODE_CONDITIONAL;
+ vector_keyword = get_identifier ("vector");
+ C_CPP_HASHNODE (vector_keyword)->flags |= NODE_CONDITIONAL;
+
+ /* Enable context-sensitive macros. */
+ cpp_get_callbacks (pfile)->macro_to_expand = spu_macro_to_expand;
}
-
- return target;
}
-rtx
-spu_expand_builtin (tree exp,
- rtx target,
- rtx subtarget ATTRIBUTE_UNUSED,
- enum machine_mode mode ATTRIBUTE_UNUSED,
- int ignore ATTRIBUTE_UNUSED)
-{
- tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
- unsigned int fcode = DECL_FUNCTION_CODE (fndecl) - END_BUILTINS;
- tree arglist = TREE_OPERAND (exp, 1);
- struct spu_builtin_description *d;
-
- if (fcode < NUM_SPU_BUILTINS)
+void
+spu_c_common_override_options (void)
+{
+ if (!TARGET_STD_MAIN)
{
- d = &spu_builtins[fcode];
-
- return spu_expand_builtin_1 (d, arglist, target);
+ /* Don't give warnings about the main() function. */
+ warn_main = 0;
}
- abort ();
-}
-
-static rtx
-spu_force_reg (enum machine_mode mode, rtx op)
-{
- rtx x, r;
- if (GET_MODE (op) == VOIDmode || GET_MODE (op) == BLKmode)
- {
- if ((SCALAR_INT_MODE_P (mode) && GET_CODE (op) == CONST_INT)
- || GET_MODE (op) == BLKmode)
- return force_reg (mode, convert_to_mode (mode, op, 0));
- abort ();
- }
-
- r = force_reg (GET_MODE (op), op);
- if (GET_MODE_SIZE (GET_MODE (op)) == GET_MODE_SIZE (mode))
- {
- x = simplify_gen_subreg (mode, r, GET_MODE (op), 0);
- if (x)
- return x;
- }
-
- x = gen_reg_rtx (mode);
- emit_insn (gen_spu_convert (x, r));
- return x;
}
OSDN Git Service
