gcc/config/spu/spu-c.c

   1 /* Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   2
   3    This file is free software; you can redistribute it and/or modify it under
   4    the terms of the GNU General Public License as published by the Free
   5    Software Foundation; either version 3 of the License, or (at your option)
   6    any later version.
   7
   8    This file is distributed in the hope that it will be useful, but WITHOUT
   9    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11    for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with GCC; see the file COPYING3.  If not see
  15    <http://www.gnu.org/licenses/>.  */
  16
  17 #include "config.h"
  18 #include "system.h"
  19 #include "coretypes.h"
  20 #include "tm.h"
  21 #include "cpplib.h"
  22 #include "tree.h"
  23 #include "c-tree.h"
  24 #include "c-pragma.h"
  25 #include "function.h"
  26 #include "rtl.h"
  27 #include "expr.h"
  28 #include "tm_p.h"
  29 #include "langhooks.h"
  30 #include "insn-config.h"
  31 #include "insn-codes.h"
  32 #include "recog.h"
  33 #include "optabs.h"
  34 \f
  35
  36 /* Keep the vector keywords handy for fast comparisons.  */
  37 static GTY(()) tree __vector_keyword;
  38 static GTY(()) tree vector_keyword;
  39
  40 static cpp_hashnode *
  41 spu_categorize_keyword (const cpp_token *tok)
  42 {
  43   if (tok->type == CPP_NAME)
  44     {
  45       cpp_hashnode *ident = tok->val.node.node;
  46
  47       if (ident == C_CPP_HASHNODE (vector_keyword)
  48           || ident == C_CPP_HASHNODE (__vector_keyword))
  49         return C_CPP_HASHNODE (__vector_keyword);
  50       else
  51         return ident;
  52     }
  53   return 0;
  54 }
  55
  56 /* Called to decide whether a conditional macro should be expanded.
  57    Since we have exactly one such macro (i.e, 'vector'), we do not
  58    need to examine the 'tok' parameter.  */
  59
  60 static cpp_hashnode *
  61 spu_macro_to_expand (cpp_reader *pfile, const cpp_token *tok)
  62 {
  63   cpp_hashnode *expand_this = tok->val.node.node;
  64   cpp_hashnode *ident;
  65
  66   ident = spu_categorize_keyword (tok);
  67   if (ident == C_CPP_HASHNODE (__vector_keyword))
  68     {
  69       tok = cpp_peek_token (pfile, 0);
  70       ident = spu_categorize_keyword (tok);
  71
  72       if (ident)
  73         {
  74           enum rid rid_code = (enum rid)(ident->rid_code);
  75           if (ident->type == NT_MACRO)
  76             {
  77               (void) cpp_get_token (pfile);
  78               tok = cpp_peek_token (pfile, 0);
  79               ident = spu_categorize_keyword (tok);
  80               if (ident)
  81                 rid_code = (enum rid)(ident->rid_code);
  82             }
  83
  84           if (rid_code == RID_UNSIGNED || rid_code == RID_LONG
  85               || rid_code == RID_SHORT || rid_code == RID_SIGNED
  86               || rid_code == RID_INT || rid_code == RID_CHAR
  87               || rid_code == RID_FLOAT || rid_code == RID_DOUBLE)
  88             expand_this = C_CPP_HASHNODE (__vector_keyword);
  89         }
  90     }
  91   return expand_this;
  92 }
  93
  94 /* target hook for resolve_overloaded_builtin(). Returns a function call
  95    RTX if we can resolve the overloaded builtin */
  96 tree
  97 spu_resolve_overloaded_builtin (location_t loc, tree fndecl, void *passed_args)
  98 {
  99 #define SCALAR_TYPE_P(t) (INTEGRAL_TYPE_P (t) \
 100                           || SCALAR_FLOAT_TYPE_P (t) \
 101                           || POINTER_TYPE_P (t))
 102   VEC(tree,gc) *fnargs = (VEC(tree,gc) *) passed_args;
 103   unsigned int nargs = VEC_length (tree, fnargs);
 104   int new_fcode, fcode = DECL_FUNCTION_CODE (fndecl) - END_BUILTINS;
 105   struct spu_builtin_description *desc;
 106   tree match = NULL_TREE;
 107
 108   /* The vector types are not available if the backend is not initialized.  */
 109   gcc_assert (!flag_preprocess_only);
 110
 111   desc = &spu_builtins[fcode];
 112   if (desc->type != B_OVERLOAD)
 113     return NULL_TREE;
 114
 115   /* Compare the signature of each internal builtin function with the
 116      function arguments until a match is found. */
 117
 118   for (new_fcode = fcode + 1; spu_builtins[new_fcode].type == B_INTERNAL;
 119        new_fcode++)
 120     {
 121       tree decl = spu_builtins[new_fcode].fndecl;
 122       tree params = TYPE_ARG_TYPES (TREE_TYPE (decl));
 123       tree param;
 124       bool all_scalar;
 125       unsigned int p;
 126
 127       /* Check whether all parameters are scalar.  */
 128       all_scalar = true;
 129       for (param = params; param != void_list_node; param = TREE_CHAIN (param))
 130       if (!SCALAR_TYPE_P (TREE_VALUE (param)))
 131         all_scalar = false;
 132
 133       for (param = params, p = 0;
 134            param != void_list_node;
 135            param = TREE_CHAIN (param), p++)
 136         {
 137           tree var, arg_type, param_type = TREE_VALUE (param);
 138
 139           if (p >= nargs)
 140             {
 141               error ("insufficient arguments to overloaded function %s",
 142                      desc->name);
 143               return error_mark_node;
 144             }
 145
 146           var = VEC_index (tree, fnargs, p);
 147
 148           if (TREE_CODE (var) == NON_LVALUE_EXPR)
 149             var = TREE_OPERAND (var, 0);
 150
 151           if (TREE_CODE (var) == ERROR_MARK)
 152             return NULL_TREE;   /* Let somebody else deal with the problem. */
 153
 154           arg_type = TREE_TYPE (var);
 155
 156           /* The intrinsics spec does not specify precisely how to
 157              resolve generic intrinsics.  We require an exact match
 158              for vector types and let C do it's usual parameter type
 159              checking/promotions for scalar arguments, except for the
 160              first argument of intrinsics which don't have a vector
 161              parameter. */
 162           if ((!SCALAR_TYPE_P (param_type)
 163                || !SCALAR_TYPE_P (arg_type)
 164                || (all_scalar && p == 0))
 165               && !lang_hooks.types_compatible_p (param_type, arg_type))
 166             break;
 167         }
 168       if (param == void_list_node)
 169         {
 170           if (p != nargs)
 171             {
 172               error ("too many arguments to overloaded function %s",
 173                      desc->name);
 174               return error_mark_node;
 175             }
 176
 177           match = decl;
 178           break;
 179         }
 180     }
 181
 182   if (match == NULL_TREE)
 183     {
 184       error ("parameter list does not match a valid signature for %s()",
 185              desc->name);
 186       return error_mark_node;
 187     }
 188
 189   return build_function_call_vec (loc, match, fnargs, NULL);
 190 #undef SCALAR_TYPE_P
 191 }
 192
 193
 194 void
 195 spu_cpu_cpp_builtins (struct cpp_reader *pfile)
 196 {
 197   builtin_define_std ("__SPU__");
 198   cpp_assert (pfile, "cpu=spu");
 199   cpp_assert (pfile, "machine=spu");
 200   if (spu_arch == PROCESSOR_CELLEDP)
 201     builtin_define_std ("__SPU_EDP__");
 202   builtin_define_std ("__vector=__attribute__((__spu_vector__))");
 203   switch (spu_ea_model)
 204     {
 205     case 32:
 206       builtin_define_std ("__EA32__");
 207       break;
 208     case 64:
 209       builtin_define_std ("__EA64__");
 210       break;
 211     default:
 212        gcc_unreachable ();
 213     }
 214
 215   if (!flag_iso)
 216     {
 217       /* Define this when supporting context-sensitive keywords.  */
 218       cpp_define (pfile, "__VECTOR_KEYWORD_SUPPORTED__");
 219       cpp_define (pfile, "vector=vector");
 220
 221       /* Initialize vector keywords.  */
 222       __vector_keyword = get_identifier ("__vector");
 223       C_CPP_HASHNODE (__vector_keyword)->flags |= NODE_CONDITIONAL;
 224       vector_keyword = get_identifier ("vector");
 225       C_CPP_HASHNODE (vector_keyword)->flags |= NODE_CONDITIONAL;
 226
 227       /* Enable context-sensitive macros.  */
 228       cpp_get_callbacks (pfile)->macro_to_expand = spu_macro_to_expand;
 229     }
 230 }
 231
 232 void
 233 spu_c_common_override_options (void)
 234 {
 235   if (!TARGET_STD_MAIN)
 236     {
 237       /* Don't give warnings about the main() function.  */
 238       warn_main = 0;
 239     }
 240 }