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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [i386/] [i386-c.c] - Blame information for rev 709

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn
/* Subroutines used for macro/preprocessor support on the ia-32.
2
   Copyright (C) 2008, 2009, 2010
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 "tree.h"
26
#include "tm_p.h"
27
#include "flags.h"
28
#include "c-family/c-common.h"
29
#include "ggc.h"
30
#include "target.h"
31
#include "target-def.h"
32
#include "cpplib.h"
33
#include "c-family/c-pragma.h"
34
 
35
static bool ix86_pragma_target_parse (tree, tree);
36
static void ix86_target_macros_internal
37
  (HOST_WIDE_INT, enum processor_type, enum processor_type, enum fpmath_unit,
38
   void (*def_or_undef) (cpp_reader *, const char *));
39
 
40
 
41
/* Internal function to either define or undef the appropriate system
42
   macros.  */
43
static void
44
ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
45
                             enum processor_type arch,
46
                             enum processor_type tune,
47
                             enum fpmath_unit fpmath,
48
                             void (*def_or_undef) (cpp_reader *,
49
                                                   const char *))
50
{
51
  /* For some of the k6/pentium varients there weren't seperate ISA bits to
52
     identify which tune/arch flag was passed, so figure it out here.  */
53
  size_t arch_len = strlen (ix86_arch_string);
54
  size_t tune_len = strlen (ix86_tune_string);
55
  int last_arch_char = ix86_arch_string[arch_len - 1];
56
  int last_tune_char = ix86_tune_string[tune_len - 1];
57
 
58
  /* Built-ins based on -march=.  */
59
  switch (arch)
60
    {
61
    case PROCESSOR_I386:
62
      break;
63
    case PROCESSOR_I486:
64
      def_or_undef (parse_in, "__i486");
65
      def_or_undef (parse_in, "__i486__");
66
      break;
67
    case PROCESSOR_PENTIUM:
68
      def_or_undef (parse_in, "__i586");
69
      def_or_undef (parse_in, "__i586__");
70
      def_or_undef (parse_in, "__pentium");
71
      def_or_undef (parse_in, "__pentium__");
72
      if (isa_flag & OPTION_MASK_ISA_MMX)
73
        def_or_undef (parse_in, "__pentium_mmx__");
74
      break;
75
    case PROCESSOR_PENTIUMPRO:
76
      def_or_undef (parse_in, "__i686");
77
      def_or_undef (parse_in, "__i686__");
78
      def_or_undef (parse_in, "__pentiumpro");
79
      def_or_undef (parse_in, "__pentiumpro__");
80
      break;
81
    case PROCESSOR_GEODE:
82
      def_or_undef (parse_in, "__geode");
83
      def_or_undef (parse_in, "__geode__");
84
      break;
85
    case PROCESSOR_K6:
86
      def_or_undef (parse_in, "__k6");
87
      def_or_undef (parse_in, "__k6__");
88
      if (last_arch_char == '2')
89
        def_or_undef (parse_in, "__k6_2__");
90
      else if (last_arch_char == '3')
91
        def_or_undef (parse_in, "__k6_3__");
92
      else if (isa_flag & OPTION_MASK_ISA_3DNOW)
93
        def_or_undef (parse_in, "__k6_3__");
94
      break;
95
    case PROCESSOR_ATHLON:
96
      def_or_undef (parse_in, "__athlon");
97
      def_or_undef (parse_in, "__athlon__");
98
      if (isa_flag & OPTION_MASK_ISA_SSE)
99
        def_or_undef (parse_in, "__athlon_sse__");
100
      break;
101
    case PROCESSOR_K8:
102
      def_or_undef (parse_in, "__k8");
103
      def_or_undef (parse_in, "__k8__");
104
      break;
105
    case PROCESSOR_AMDFAM10:
106
      def_or_undef (parse_in, "__amdfam10");
107
      def_or_undef (parse_in, "__amdfam10__");
108
      break;
109
    case PROCESSOR_BDVER1:
110
      def_or_undef (parse_in, "__bdver1");
111
      def_or_undef (parse_in, "__bdver1__");
112
      break;
113
    case PROCESSOR_BDVER2:
114
      def_or_undef (parse_in, "__bdver2");
115
      def_or_undef (parse_in, "__bdver2__");
116
      break;
117
    case PROCESSOR_BTVER1:
118
      def_or_undef (parse_in, "__btver1");
119
      def_or_undef (parse_in, "__btver1__");
120
      break;
121
    case PROCESSOR_PENTIUM4:
122
      def_or_undef (parse_in, "__pentium4");
123
      def_or_undef (parse_in, "__pentium4__");
124
      break;
125
    case PROCESSOR_NOCONA:
126
      def_or_undef (parse_in, "__nocona");
127
      def_or_undef (parse_in, "__nocona__");
128
      break;
129
    case PROCESSOR_CORE2_32:
130
    case PROCESSOR_CORE2_64:
131
      def_or_undef (parse_in, "__core2");
132
      def_or_undef (parse_in, "__core2__");
133
      break;
134
    case PROCESSOR_COREI7_32:
135
    case PROCESSOR_COREI7_64:
136
      def_or_undef (parse_in, "__corei7");
137
      def_or_undef (parse_in, "__corei7__");
138
      break;
139
    case PROCESSOR_ATOM:
140
      def_or_undef (parse_in, "__atom");
141
      def_or_undef (parse_in, "__atom__");
142
      break;
143
    /* use PROCESSOR_max to not set/unset the arch macro.  */
144
    case PROCESSOR_max:
145
      break;
146
    case PROCESSOR_GENERIC32:
147
    case PROCESSOR_GENERIC64:
148
      gcc_unreachable ();
149
    }
150
 
151
  /* Built-ins based on -mtune=.  */
152
  switch (tune)
153
    {
154
    case PROCESSOR_I386:
155
      def_or_undef (parse_in, "__tune_i386__");
156
      break;
157
    case PROCESSOR_I486:
158
      def_or_undef (parse_in, "__tune_i486__");
159
      break;
160
    case PROCESSOR_PENTIUM:
161
      def_or_undef (parse_in, "__tune_i586__");
162
      def_or_undef (parse_in, "__tune_pentium__");
163
      if (last_tune_char == 'x')
164
        def_or_undef (parse_in, "__tune_pentium_mmx__");
165
      break;
166
    case PROCESSOR_PENTIUMPRO:
167
      def_or_undef (parse_in, "__tune_i686__");
168
      def_or_undef (parse_in, "__tune_pentiumpro__");
169
      switch (last_tune_char)
170
        {
171
        case '3':
172
          def_or_undef (parse_in, "__tune_pentium3__");
173
          /* FALLTHRU */
174
        case '2':
175
          def_or_undef (parse_in, "__tune_pentium2__");
176
          break;
177
        }
178
      break;
179
    case PROCESSOR_GEODE:
180
      def_or_undef (parse_in, "__tune_geode__");
181
      break;
182
    case PROCESSOR_K6:
183
      def_or_undef (parse_in, "__tune_k6__");
184
      if (last_tune_char == '2')
185
        def_or_undef (parse_in, "__tune_k6_2__");
186
      else if (last_tune_char == '3')
187
        def_or_undef (parse_in, "__tune_k6_3__");
188
      else if (isa_flag & OPTION_MASK_ISA_3DNOW)
189
        def_or_undef (parse_in, "__tune_k6_3__");
190
      break;
191
    case PROCESSOR_ATHLON:
192
      def_or_undef (parse_in, "__tune_athlon__");
193
      if (isa_flag & OPTION_MASK_ISA_SSE)
194
        def_or_undef (parse_in, "__tune_athlon_sse__");
195
      break;
196
    case PROCESSOR_K8:
197
      def_or_undef (parse_in, "__tune_k8__");
198
      break;
199
    case PROCESSOR_AMDFAM10:
200
      def_or_undef (parse_in, "__tune_amdfam10__");
201
      break;
202
    case PROCESSOR_BDVER1:
203
      def_or_undef (parse_in, "__tune_bdver1__");
204
      break;
205
    case PROCESSOR_BDVER2:
206
      def_or_undef (parse_in, "__tune_bdver2__");
207
      break;
208
   case PROCESSOR_BTVER1:
209
      def_or_undef (parse_in, "__tune_btver1__");
210
      break;
211
    case PROCESSOR_PENTIUM4:
212
      def_or_undef (parse_in, "__tune_pentium4__");
213
      break;
214
    case PROCESSOR_NOCONA:
215
      def_or_undef (parse_in, "__tune_nocona__");
216
      break;
217
    case PROCESSOR_CORE2_32:
218
    case PROCESSOR_CORE2_64:
219
      def_or_undef (parse_in, "__tune_core2__");
220
      break;
221
    case PROCESSOR_COREI7_32:
222
    case PROCESSOR_COREI7_64:
223
      def_or_undef (parse_in, "__tune_corei7__");
224
      break;
225
    case PROCESSOR_ATOM:
226
      def_or_undef (parse_in, "__tune_atom__");
227
      break;
228
    case PROCESSOR_GENERIC32:
229
    case PROCESSOR_GENERIC64:
230
      break;
231
    /* use PROCESSOR_max to not set/unset the tune macro.  */
232
    case PROCESSOR_max:
233
      break;
234
    }
235
 
236
  if (isa_flag & OPTION_MASK_ISA_MMX)
237
    def_or_undef (parse_in, "__MMX__");
238
  if (isa_flag & OPTION_MASK_ISA_3DNOW)
239
    def_or_undef (parse_in, "__3dNOW__");
240
  if (isa_flag & OPTION_MASK_ISA_3DNOW_A)
241
    def_or_undef (parse_in, "__3dNOW_A__");
242
  if (isa_flag & OPTION_MASK_ISA_SSE)
243
    def_or_undef (parse_in, "__SSE__");
244
  if (isa_flag & OPTION_MASK_ISA_SSE2)
245
    def_or_undef (parse_in, "__SSE2__");
246
  if (isa_flag & OPTION_MASK_ISA_SSE3)
247
    def_or_undef (parse_in, "__SSE3__");
248
  if (isa_flag & OPTION_MASK_ISA_SSSE3)
249
    def_or_undef (parse_in, "__SSSE3__");
250
  if (isa_flag & OPTION_MASK_ISA_SSE4_1)
251
    def_or_undef (parse_in, "__SSE4_1__");
252
  if (isa_flag & OPTION_MASK_ISA_SSE4_2)
253
    def_or_undef (parse_in, "__SSE4_2__");
254
  if (isa_flag & OPTION_MASK_ISA_AES)
255
    def_or_undef (parse_in, "__AES__");
256
  if (isa_flag & OPTION_MASK_ISA_PCLMUL)
257
    def_or_undef (parse_in, "__PCLMUL__");
258
  if (isa_flag & OPTION_MASK_ISA_AVX)
259
    def_or_undef (parse_in, "__AVX__");
260
  if (isa_flag & OPTION_MASK_ISA_AVX2)
261
    def_or_undef (parse_in, "__AVX2__");
262
  if (isa_flag & OPTION_MASK_ISA_FMA)
263
    def_or_undef (parse_in, "__FMA__");
264
  if (isa_flag & OPTION_MASK_ISA_SSE4A)
265
    def_or_undef (parse_in, "__SSE4A__");
266
  if (isa_flag & OPTION_MASK_ISA_FMA4)
267
    def_or_undef (parse_in, "__FMA4__");
268
  if (isa_flag & OPTION_MASK_ISA_XOP)
269
    def_or_undef (parse_in, "__XOP__");
270
  if (isa_flag & OPTION_MASK_ISA_LWP)
271
    def_or_undef (parse_in, "__LWP__");
272
  if (isa_flag & OPTION_MASK_ISA_ABM)
273
    def_or_undef (parse_in, "__ABM__");
274
  if (isa_flag & OPTION_MASK_ISA_BMI)
275
    def_or_undef (parse_in, "__BMI__");
276
  if (isa_flag & OPTION_MASK_ISA_BMI2)
277
    def_or_undef (parse_in, "__BMI2__");
278
  if (isa_flag & OPTION_MASK_ISA_LZCNT)
279
    def_or_undef (parse_in, "__LZCNT__");
280
  if (isa_flag & OPTION_MASK_ISA_TBM)
281
    def_or_undef (parse_in, "__TBM__");
282
  if (isa_flag & OPTION_MASK_ISA_POPCNT)
283
    def_or_undef (parse_in, "__POPCNT__");
284
  if (isa_flag & OPTION_MASK_ISA_FSGSBASE)
285
    def_or_undef (parse_in, "__FSGSBASE__");
286
  if (isa_flag & OPTION_MASK_ISA_RDRND)
287
    def_or_undef (parse_in, "__RDRND__");
288
  if (isa_flag & OPTION_MASK_ISA_F16C)
289
    def_or_undef (parse_in, "__F16C__");
290
  if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE))
291
    def_or_undef (parse_in, "__SSE_MATH__");
292
  if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE2))
293
    def_or_undef (parse_in, "__SSE2_MATH__");
294
}
295
 
296
 
297
/* Hook to validate the current #pragma GCC target and set the state, and
298
   update the macros based on what was changed.  If ARGS is NULL, then
299
   POP_TARGET is used to reset the options.  */
300
 
301
static bool
302
ix86_pragma_target_parse (tree args, tree pop_target)
303
{
304
  tree prev_tree = build_target_option_node ();
305
  tree cur_tree;
306
  struct cl_target_option *prev_opt;
307
  struct cl_target_option *cur_opt;
308
  HOST_WIDE_INT prev_isa;
309
  HOST_WIDE_INT cur_isa;
310
  HOST_WIDE_INT diff_isa;
311
  enum processor_type prev_arch;
312
  enum processor_type prev_tune;
313
  enum processor_type cur_arch;
314
  enum processor_type cur_tune;
315
 
316
  if (! args)
317
    {
318
      cur_tree = ((pop_target)
319
                  ? pop_target
320
                  : target_option_default_node);
321
      cl_target_option_restore (&global_options,
322
                                TREE_TARGET_OPTION (cur_tree));
323
    }
324
  else
325
    {
326
      cur_tree = ix86_valid_target_attribute_tree (args);
327
      if (!cur_tree)
328
        return false;
329
    }
330
 
331
  target_option_current_node = cur_tree;
332
 
333
  /* Figure out the previous/current isa, arch, tune and the differences.  */
334
  prev_opt  = TREE_TARGET_OPTION (prev_tree);
335
  cur_opt   = TREE_TARGET_OPTION (cur_tree);
336
  prev_isa  = prev_opt->x_ix86_isa_flags;
337
  cur_isa   = cur_opt->x_ix86_isa_flags;
338
  diff_isa  = (prev_isa ^ cur_isa);
339
  prev_arch = (enum processor_type) prev_opt->arch;
340
  prev_tune = (enum processor_type) prev_opt->tune;
341
  cur_arch  = (enum processor_type) cur_opt->arch;
342
  cur_tune  = (enum processor_type) cur_opt->tune;
343
 
344
  /* If the same processor is used for both previous and current options, don't
345
     change the macros.  */
346
  if (cur_arch == prev_arch)
347
    cur_arch = prev_arch = PROCESSOR_max;
348
 
349
  if (cur_tune == prev_tune)
350
    cur_tune = prev_tune = PROCESSOR_max;
351
 
352
  /* Undef all of the macros for that are no longer current.  */
353
  ix86_target_macros_internal (prev_isa & diff_isa,
354
                               prev_arch,
355
                               prev_tune,
356
                               (enum fpmath_unit) prev_opt->x_ix86_fpmath,
357
                               cpp_undef);
358
 
359
  /* Define all of the macros for new options that were just turned on.  */
360
  ix86_target_macros_internal (cur_isa & diff_isa,
361
                               cur_arch,
362
                               cur_tune,
363
                               (enum fpmath_unit) cur_opt->x_ix86_fpmath,
364
                               cpp_define);
365
 
366
  return true;
367
}
368
 
369
/* Function to tell the preprocessor about the defines for the current target.  */
370
 
371
void
372
ix86_target_macros (void)
373
{
374
  /* 32/64-bit won't change with target specific options, so do the assert and
375
     builtin_define_std calls here.  */
376
  if (TARGET_64BIT)
377
    {
378
      cpp_assert (parse_in, "cpu=x86_64");
379
      cpp_assert (parse_in, "machine=x86_64");
380
      cpp_define (parse_in, "__amd64");
381
      cpp_define (parse_in, "__amd64__");
382
      cpp_define (parse_in, "__x86_64");
383
      cpp_define (parse_in, "__x86_64__");
384
    }
385
  else
386
    {
387
      cpp_assert (parse_in, "cpu=i386");
388
      cpp_assert (parse_in, "machine=i386");
389
      builtin_define_std ("i386");
390
    }
391
 
392
  ix86_target_macros_internal (ix86_isa_flags,
393
                               ix86_arch,
394
                               ix86_tune,
395
                               ix86_fpmath,
396
                               cpp_define);
397
}
398
 
399
 
400
/* Register target pragmas.  We need to add the hook for parsing #pragma GCC
401
   option here rather than in i386.c since it will pull in various preprocessor
402
   functions, and those are not present in languages like fortran without a
403
   preprocessor.  */
404
 
405
void
406
ix86_register_pragmas (void)
407
{
408
  /* Update pragma hook to allow parsing #pragma GCC target.  */
409
  targetm.target_option.pragma_parse = ix86_pragma_target_parse;
410
 
411
#ifdef REGISTER_SUBTARGET_PRAGMAS
412
  REGISTER_SUBTARGET_PRAGMAS ();
413
#endif
414
}

powered by: WebSVN 2.1.0

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