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/] [i386/] [i386-c.c] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 jeremybenn
/* Subroutines used for macro/preprocessor support on the ia-32.
2
   Copyright (C) 2008, 2009
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 3, or (at your option)
10
any later version.
11
 
12
GCC is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "tm.h"
25
#include "rtl.h"
26
#include "tree.h"
27
#include "tm_p.h"
28
#include "flags.h"
29
#include "c-common.h"
30
#include "ggc.h"
31
#include "target.h"
32
#include "target-def.h"
33
#include "cpplib.h"
34
#include "c-pragma.h"
35
 
36
static bool ix86_pragma_target_parse (tree, tree);
37
static void ix86_target_macros_internal
38
  (int, enum processor_type, enum processor_type, enum fpmath_unit,
39
   void (*def_or_undef) (cpp_reader *, const char *));
40
 
41
 
42
/* Internal function to either define or undef the appropriate system
43
   macros.  */
44
static void
45
ix86_target_macros_internal (int isa_flag,
46
                             enum processor_type arch,
47
                             enum processor_type tune,
48
                             enum fpmath_unit fpmath,
49
                             void (*def_or_undef) (cpp_reader *,
50
                                                   const char *))
51
{
52
  /* For some of the k6/pentium varients there weren't seperate ISA bits to
53
     identify which tune/arch flag was passed, so figure it out here.  */
54
  size_t arch_len = strlen (ix86_arch_string);
55
  size_t tune_len = strlen (ix86_tune_string);
56
  int last_arch_char = ix86_arch_string[arch_len - 1];
57
  int last_tune_char = ix86_tune_string[tune_len - 1];
58
 
59
  /* Built-ins based on -march=.  */
60
  switch (arch)
61
    {
62
    case PROCESSOR_I386:
63
      break;
64
    case PROCESSOR_I486:
65
      def_or_undef (parse_in, "__i486");
66
      def_or_undef (parse_in, "__i486__");
67
      break;
68
    case PROCESSOR_PENTIUM:
69
      def_or_undef (parse_in, "__i586");
70
      def_or_undef (parse_in, "__i586__");
71
      def_or_undef (parse_in, "__pentium");
72
      def_or_undef (parse_in, "__pentium__");
73
      if (isa_flag & OPTION_MASK_ISA_MMX)
74
        def_or_undef (parse_in, "__pentium_mmx__");
75
      break;
76
    case PROCESSOR_PENTIUMPRO:
77
      def_or_undef (parse_in, "__i686");
78
      def_or_undef (parse_in, "__i686__");
79
      def_or_undef (parse_in, "__pentiumpro");
80
      def_or_undef (parse_in, "__pentiumpro__");
81
      break;
82
    case PROCESSOR_GEODE:
83
      def_or_undef (parse_in, "__geode");
84
      def_or_undef (parse_in, "__geode__");
85
      break;
86
    case PROCESSOR_K6:
87
      def_or_undef (parse_in, "__k6");
88
      def_or_undef (parse_in, "__k6__");
89
      if (last_arch_char == '2')
90
        def_or_undef (parse_in, "__k6_2__");
91
      else if (last_arch_char == '3')
92
        def_or_undef (parse_in, "__k6_3__");
93
      else if (isa_flag & OPTION_MASK_ISA_3DNOW)
94
        def_or_undef (parse_in, "__k6_3__");
95
      break;
96
    case PROCESSOR_ATHLON:
97
      def_or_undef (parse_in, "__athlon");
98
      def_or_undef (parse_in, "__athlon__");
99
      if (isa_flag & OPTION_MASK_ISA_SSE)
100
        def_or_undef (parse_in, "__athlon_sse__");
101
      break;
102
    case PROCESSOR_K8:
103
      def_or_undef (parse_in, "__k8");
104
      def_or_undef (parse_in, "__k8__");
105
      break;
106
    case PROCESSOR_AMDFAM10:
107
      def_or_undef (parse_in, "__amdfam10");
108
      def_or_undef (parse_in, "__amdfam10__");
109
      break;
110
    case PROCESSOR_PENTIUM4:
111
      def_or_undef (parse_in, "__pentium4");
112
      def_or_undef (parse_in, "__pentium4__");
113
      break;
114
    case PROCESSOR_NOCONA:
115
      def_or_undef (parse_in, "__nocona");
116
      def_or_undef (parse_in, "__nocona__");
117
      break;
118
    case PROCESSOR_CORE2:
119
      def_or_undef (parse_in, "__core2");
120
      def_or_undef (parse_in, "__core2__");
121
      break;
122
    case PROCESSOR_ATOM:
123
      def_or_undef (parse_in, "__atom");
124
      def_or_undef (parse_in, "__atom__");
125
      break;
126
    /* use PROCESSOR_max to not set/unset the arch macro.  */
127
    case PROCESSOR_max:
128
      break;
129
    case PROCESSOR_GENERIC32:
130
    case PROCESSOR_GENERIC64:
131
      gcc_unreachable ();
132
    }
133
 
134
  /* Built-ins based on -mtune=.  */
135
  switch (tune)
136
    {
137
    case PROCESSOR_I386:
138
      def_or_undef (parse_in, "__tune_i386__");
139
      break;
140
    case PROCESSOR_I486:
141
      def_or_undef (parse_in, "__tune_i486__");
142
      break;
143
    case PROCESSOR_PENTIUM:
144
      def_or_undef (parse_in, "__tune_i586__");
145
      def_or_undef (parse_in, "__tune_pentium__");
146
      if (last_tune_char == 'x')
147
        def_or_undef (parse_in, "__tune_pentium_mmx__");
148
      break;
149
    case PROCESSOR_PENTIUMPRO:
150
      def_or_undef (parse_in, "__tune_i686__");
151
      def_or_undef (parse_in, "__tune_pentiumpro__");
152
      switch (last_tune_char)
153
        {
154
        case '3':
155
          def_or_undef (parse_in, "__tune_pentium3__");
156
          /* FALLTHRU */
157
        case '2':
158
          def_or_undef (parse_in, "__tune_pentium2__");
159
          break;
160
        }
161
      break;
162
    case PROCESSOR_GEODE:
163
      def_or_undef (parse_in, "__tune_geode__");
164
      break;
165
    case PROCESSOR_K6:
166
      def_or_undef (parse_in, "__tune_k6__");
167
      if (last_tune_char == '2')
168
        def_or_undef (parse_in, "__tune_k6_2__");
169
      else if (last_tune_char == '3')
170
        def_or_undef (parse_in, "__tune_k6_3__");
171
      else if (isa_flag & OPTION_MASK_ISA_3DNOW)
172
        def_or_undef (parse_in, "__tune_k6_3__");
173
      break;
174
    case PROCESSOR_ATHLON:
175
      def_or_undef (parse_in, "__tune_athlon__");
176
      if (isa_flag & OPTION_MASK_ISA_SSE)
177
        def_or_undef (parse_in, "__tune_athlon_sse__");
178
      break;
179
    case PROCESSOR_K8:
180
      def_or_undef (parse_in, "__tune_k8__");
181
      break;
182
    case PROCESSOR_AMDFAM10:
183
      def_or_undef (parse_in, "__tune_amdfam10__");
184
      break;
185
    case PROCESSOR_PENTIUM4:
186
      def_or_undef (parse_in, "__tune_pentium4__");
187
      break;
188
    case PROCESSOR_NOCONA:
189
      def_or_undef (parse_in, "__tune_nocona__");
190
      break;
191
    case PROCESSOR_CORE2:
192
      def_or_undef (parse_in, "__tune_core2__");
193
      break;
194
    case PROCESSOR_ATOM:
195
      def_or_undef (parse_in, "__tune_atom__");
196
      break;
197
    case PROCESSOR_GENERIC32:
198
    case PROCESSOR_GENERIC64:
199
      break;
200
    /* use PROCESSOR_max to not set/unset the tune macro.  */
201
    case PROCESSOR_max:
202
      break;
203
    }
204
 
205
  if (isa_flag & OPTION_MASK_ISA_MMX)
206
    def_or_undef (parse_in, "__MMX__");
207
  if (isa_flag & OPTION_MASK_ISA_3DNOW)
208
    def_or_undef (parse_in, "__3dNOW__");
209
  if (isa_flag & OPTION_MASK_ISA_3DNOW_A)
210
    def_or_undef (parse_in, "__3dNOW_A__");
211
  if (isa_flag & OPTION_MASK_ISA_SSE)
212
    def_or_undef (parse_in, "__SSE__");
213
  if (isa_flag & OPTION_MASK_ISA_SSE2)
214
    def_or_undef (parse_in, "__SSE2__");
215
  if (isa_flag & OPTION_MASK_ISA_SSE3)
216
    def_or_undef (parse_in, "__SSE3__");
217
  if (isa_flag & OPTION_MASK_ISA_SSSE3)
218
    def_or_undef (parse_in, "__SSSE3__");
219
  if (isa_flag & OPTION_MASK_ISA_SSE4_1)
220
    def_or_undef (parse_in, "__SSE4_1__");
221
  if (isa_flag & OPTION_MASK_ISA_SSE4_2)
222
    def_or_undef (parse_in, "__SSE4_2__");
223
  if (isa_flag & OPTION_MASK_ISA_AES)
224
    def_or_undef (parse_in, "__AES__");
225
  if (isa_flag & OPTION_MASK_ISA_PCLMUL)
226
    def_or_undef (parse_in, "__PCLMUL__");
227
  if (isa_flag & OPTION_MASK_ISA_AVX)
228
    def_or_undef (parse_in, "__AVX__");
229
  if (isa_flag & OPTION_MASK_ISA_FMA)
230
    def_or_undef (parse_in, "__FMA__");
231
  if (isa_flag & OPTION_MASK_ISA_SSE4A)
232
    def_or_undef (parse_in, "__SSE4A__");
233
  if (isa_flag & OPTION_MASK_ISA_FMA4)
234
    def_or_undef (parse_in, "__FMA4__");
235
  if (isa_flag & OPTION_MASK_ISA_XOP)
236
    def_or_undef (parse_in, "__XOP__");
237
  if (isa_flag & OPTION_MASK_ISA_LWP)
238
    def_or_undef (parse_in, "__LWP__");
239
  if (isa_flag & OPTION_MASK_ISA_ABM)
240
    def_or_undef (parse_in, "__ABM__");
241
  if (isa_flag & OPTION_MASK_ISA_POPCNT)
242
    def_or_undef (parse_in, "__POPCNT__");
243
  if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE))
244
    def_or_undef (parse_in, "__SSE_MATH__");
245
  if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE2))
246
    def_or_undef (parse_in, "__SSE2_MATH__");
247
}
248
 
249
 
250
/* Hook to validate the current #pragma GCC target and set the state, and
251
   update the macros based on what was changed.  If ARGS is NULL, then
252
   POP_TARGET is used to reset the options.  */
253
 
254
static bool
255
ix86_pragma_target_parse (tree args, tree pop_target)
256
{
257
  tree prev_tree = build_target_option_node ();
258
  tree cur_tree;
259
  struct cl_target_option *prev_opt;
260
  struct cl_target_option *cur_opt;
261
  int prev_isa;
262
  int cur_isa;
263
  int diff_isa;
264
  enum processor_type prev_arch;
265
  enum processor_type prev_tune;
266
  enum processor_type cur_arch;
267
  enum processor_type cur_tune;
268
 
269
  if (! args)
270
    {
271
      cur_tree = ((pop_target)
272
                  ? pop_target
273
                  : target_option_default_node);
274
      cl_target_option_restore (TREE_TARGET_OPTION (cur_tree));
275
    }
276
  else
277
    {
278
      cur_tree = ix86_valid_target_attribute_tree (args);
279
      if (!cur_tree)
280
        return false;
281
    }
282
 
283
  target_option_current_node = cur_tree;
284
 
285
  /* Figure out the previous/current isa, arch, tune and the differences.  */
286
  prev_opt  = TREE_TARGET_OPTION (prev_tree);
287
  cur_opt   = TREE_TARGET_OPTION (cur_tree);
288
  prev_isa  = prev_opt->ix86_isa_flags;
289
  cur_isa   = cur_opt->ix86_isa_flags;
290
  diff_isa  = (prev_isa ^ cur_isa);
291
  prev_arch = (enum processor_type) prev_opt->arch;
292
  prev_tune = (enum processor_type) prev_opt->tune;
293
  cur_arch  = (enum processor_type) cur_opt->arch;
294
  cur_tune  = (enum processor_type) cur_opt->tune;
295
 
296
  /* If the same processor is used for both previous and current options, don't
297
     change the macros.  */
298
  if (cur_arch == prev_arch)
299
    cur_arch = prev_arch = PROCESSOR_max;
300
 
301
  if (cur_tune == prev_tune)
302
    cur_tune = prev_tune = PROCESSOR_max;
303
 
304
  /* Undef all of the macros for that are no longer current.  */
305
  ix86_target_macros_internal (prev_isa & diff_isa,
306
                               prev_arch,
307
                               prev_tune,
308
                               (enum fpmath_unit) prev_opt->fpmath,
309
                               cpp_undef);
310
 
311
  /* Define all of the macros for new options that were just turned on.  */
312
  ix86_target_macros_internal (cur_isa & diff_isa,
313
                               cur_arch,
314
                               cur_tune,
315
                               (enum fpmath_unit) cur_opt->fpmath,
316
                               cpp_define);
317
 
318
  return true;
319
}
320
 
321
/* Function to tell the preprocessor about the defines for the current target.  */
322
 
323
void
324
ix86_target_macros (void)
325
{
326
  /* 32/64-bit won't change with target specific options, so do the assert and
327
     builtin_define_std calls here.  */
328
  if (TARGET_64BIT)
329
    {
330
      cpp_assert (parse_in, "cpu=x86_64");
331
      cpp_assert (parse_in, "machine=x86_64");
332
      cpp_define (parse_in, "__amd64");
333
      cpp_define (parse_in, "__amd64__");
334
      cpp_define (parse_in, "__x86_64");
335
      cpp_define (parse_in, "__x86_64__");
336
    }
337
  else
338
    {
339
      cpp_assert (parse_in, "cpu=i386");
340
      cpp_assert (parse_in, "machine=i386");
341
      builtin_define_std ("i386");
342
    }
343
 
344
  ix86_target_macros_internal (ix86_isa_flags,
345
                               ix86_arch,
346
                               ix86_tune,
347
                               ix86_fpmath,
348
                               cpp_define);
349
}
350
 
351
 
352
/* Register target pragmas.  We need to add the hook for parsing #pragma GCC
353
   option here rather than in i386.c since it will pull in various preprocessor
354
   functions, and those are not present in languages like fortran without a
355
   preprocessor.  */
356
 
357
void
358
ix86_register_pragmas (void)
359
{
360
  /* Update pragma hook to allow parsing #pragma GCC target.  */
361
  targetm.target_option.pragma_parse = ix86_pragma_target_parse;
362
 
363
#ifdef REGISTER_SUBTARGET_PRAGMAS
364
  REGISTER_SUBTARGET_PRAGMAS ();
365
#endif
366
}

powered by: WebSVN 2.1.0

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