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 750

Go to most recent revision | 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.