1 /* Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
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)
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
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/>. */
19 #include "coretypes.h"
29 #include "langhooks.h"
30 #include "insn-config.h"
31 #include "insn-codes.h"
36 /* Keep the vector keywords handy for fast comparisons. */
37 static GTY(()) tree __vector_keyword;
38 static GTY(()) tree vector_keyword;
41 spu_categorize_keyword (const cpp_token *tok)
43 if (tok->type == CPP_NAME)
45 cpp_hashnode *ident = tok->val.node.node;
47 if (ident == C_CPP_HASHNODE (vector_keyword)
48 || ident == C_CPP_HASHNODE (__vector_keyword))
49 return C_CPP_HASHNODE (__vector_keyword);
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. */
61 spu_macro_to_expand (cpp_reader *pfile, const cpp_token *tok)
63 cpp_hashnode *expand_this = tok->val.node.node;
66 ident = spu_categorize_keyword (tok);
67 if (ident == C_CPP_HASHNODE (__vector_keyword))
69 tok = cpp_peek_token (pfile, 0);
70 ident = spu_categorize_keyword (tok);
74 enum rid rid_code = (enum rid)(ident->rid_code);
75 if (ident->type == NT_MACRO)
77 (void) cpp_get_token (pfile);
78 tok = cpp_peek_token (pfile, 0);
79 ident = spu_categorize_keyword (tok);
81 rid_code = (enum rid)(ident->rid_code);
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);
94 /* target hook for resolve_overloaded_builtin(). Returns a function call
95 RTX if we can resolve the overloaded builtin */
97 spu_resolve_overloaded_builtin (location_t loc, tree fndecl, void *passed_args)
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;
108 /* The vector types are not available if the backend is not initialized. */
109 gcc_assert (!flag_preprocess_only);
111 desc = &spu_builtins[fcode];
112 if (desc->type != B_OVERLOAD)
115 /* Compare the signature of each internal builtin function with the
116 function arguments until a match is found. */
118 for (new_fcode = fcode + 1; spu_builtins[new_fcode].type == B_INTERNAL;
121 tree decl = spu_builtins[new_fcode].fndecl;
122 tree params = TYPE_ARG_TYPES (TREE_TYPE (decl));
127 /* Check whether all parameters are scalar. */
129 for (param = params; param != void_list_node; param = TREE_CHAIN (param))
130 if (!SCALAR_TYPE_P (TREE_VALUE (param)))
133 for (param = params, p = 0;
134 param != void_list_node;
135 param = TREE_CHAIN (param), p++)
137 tree var, arg_type, param_type = TREE_VALUE (param);
141 error ("insufficient arguments to overloaded function %s",
143 return error_mark_node;
146 var = VEC_index (tree, fnargs, p);
148 if (TREE_CODE (var) == NON_LVALUE_EXPR)
149 var = TREE_OPERAND (var, 0);
151 if (TREE_CODE (var) == ERROR_MARK)
152 return NULL_TREE; /* Let somebody else deal with the problem. */
154 arg_type = TREE_TYPE (var);
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
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))
168 if (param == void_list_node)
172 error ("too many arguments to overloaded function %s",
174 return error_mark_node;
182 if (match == NULL_TREE)
184 error ("parameter list does not match a valid signature for %s()",
186 return error_mark_node;
189 return build_function_call_vec (loc, match, fnargs, NULL);
195 spu_cpu_cpp_builtins (struct cpp_reader *pfile)
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)
206 builtin_define_std ("__EA32__");
209 builtin_define_std ("__EA64__");
217 /* Define this when supporting context-sensitive keywords. */
218 cpp_define (pfile, "__VECTOR_KEYWORD_SUPPORTED__");
219 cpp_define (pfile, "vector=vector");
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;
227 /* Enable context-sensitive macros. */
228 cpp_get_callbacks (pfile)->macro_to_expand = spu_macro_to_expand;
233 spu_c_common_override_options (void)
235 if (!TARGET_STD_MAIN)
237 /* Don't give warnings about the main() function. */