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 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 } 241