OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [spu/] [spu-c.c] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn
/* 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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.