]>
Commit | Line | Data |
---|---|---|
46f8e3b0 | 1 | /* Subroutines used for macro/preprocessor support on the ia-32. |
2 | Copyright (C) 2008 | |
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 | ||
24470055 | 36 | static bool ix86_pragma_target_parse (tree, tree); |
46f8e3b0 | 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 | \f | |
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 | /* use PROCESSOR_max to not set/unset the arch macro. */ | |
123 | case PROCESSOR_max: | |
124 | break; | |
125 | case PROCESSOR_GENERIC32: | |
126 | case PROCESSOR_GENERIC64: | |
127 | gcc_unreachable (); | |
128 | } | |
129 | ||
130 | /* Built-ins based on -mtune=. */ | |
131 | switch (tune) | |
132 | { | |
133 | case PROCESSOR_I386: | |
134 | def_or_undef (parse_in, "__tune_i386__"); | |
135 | break; | |
136 | case PROCESSOR_I486: | |
137 | def_or_undef (parse_in, "__tune_i486__"); | |
138 | break; | |
139 | case PROCESSOR_PENTIUM: | |
140 | def_or_undef (parse_in, "__tune_i586__"); | |
141 | def_or_undef (parse_in, "__tune_pentium__"); | |
142 | if (last_tune_char == 'x') | |
143 | def_or_undef (parse_in, "__tune_pentium_mmx__"); | |
144 | break; | |
145 | case PROCESSOR_PENTIUMPRO: | |
146 | def_or_undef (parse_in, "__tune_i686__"); | |
147 | def_or_undef (parse_in, "__tune_pentiumpro__"); | |
148 | switch (last_tune_char) | |
149 | { | |
150 | case '3': | |
151 | def_or_undef (parse_in, "__tune_pentium3__"); | |
152 | /* FALLTHRU */ | |
153 | case '2': | |
154 | def_or_undef (parse_in, "__tune_pentium2__"); | |
155 | break; | |
156 | } | |
157 | break; | |
158 | case PROCESSOR_GEODE: | |
159 | def_or_undef (parse_in, "__tune_geode__"); | |
160 | break; | |
161 | case PROCESSOR_K6: | |
162 | def_or_undef (parse_in, "__tune_k6__"); | |
163 | if (last_tune_char == '2') | |
164 | def_or_undef (parse_in, "__tune_k6_2__"); | |
165 | else if (last_tune_char == '3') | |
166 | def_or_undef (parse_in, "__tune_k6_3__"); | |
167 | else if (isa_flag & OPTION_MASK_ISA_3DNOW) | |
168 | def_or_undef (parse_in, "__tune_k6_3__"); | |
169 | break; | |
170 | case PROCESSOR_ATHLON: | |
171 | def_or_undef (parse_in, "__tune_athlon__"); | |
172 | if (isa_flag & OPTION_MASK_ISA_SSE) | |
173 | def_or_undef (parse_in, "__tune_athlon_sse__"); | |
174 | break; | |
175 | case PROCESSOR_K8: | |
176 | def_or_undef (parse_in, "__tune_k8__"); | |
177 | break; | |
178 | case PROCESSOR_AMDFAM10: | |
179 | def_or_undef (parse_in, "__tune_amdfam10__"); | |
180 | break; | |
181 | case PROCESSOR_PENTIUM4: | |
182 | def_or_undef (parse_in, "__tune_pentium4__"); | |
183 | break; | |
184 | case PROCESSOR_NOCONA: | |
185 | def_or_undef (parse_in, "__tune_nocona__"); | |
186 | break; | |
187 | case PROCESSOR_CORE2: | |
188 | def_or_undef (parse_in, "__tune_core2__"); | |
189 | break; | |
190 | case PROCESSOR_GENERIC32: | |
191 | case PROCESSOR_GENERIC64: | |
192 | break; | |
193 | /* use PROCESSOR_max to not set/unset the tune macro. */ | |
194 | case PROCESSOR_max: | |
195 | break; | |
196 | } | |
197 | ||
198 | if (isa_flag & OPTION_MASK_ISA_MMX) | |
199 | def_or_undef (parse_in, "__MMX__"); | |
200 | if (isa_flag & OPTION_MASK_ISA_3DNOW) | |
201 | def_or_undef (parse_in, "__3dNOW__"); | |
202 | if (isa_flag & OPTION_MASK_ISA_3DNOW_A) | |
203 | def_or_undef (parse_in, "__3dNOW_A__"); | |
204 | if (isa_flag & OPTION_MASK_ISA_SSE) | |
205 | def_or_undef (parse_in, "__SSE__"); | |
206 | if (isa_flag & OPTION_MASK_ISA_SSE2) | |
207 | def_or_undef (parse_in, "__SSE2__"); | |
208 | if (isa_flag & OPTION_MASK_ISA_SSE3) | |
209 | def_or_undef (parse_in, "__SSE3__"); | |
210 | if (isa_flag & OPTION_MASK_ISA_SSSE3) | |
211 | def_or_undef (parse_in, "__SSSE3__"); | |
212 | if (isa_flag & OPTION_MASK_ISA_SSE4_1) | |
213 | def_or_undef (parse_in, "__SSE4_1__"); | |
214 | if (isa_flag & OPTION_MASK_ISA_SSE4_2) | |
215 | def_or_undef (parse_in, "__SSE4_2__"); | |
216 | if (isa_flag & OPTION_MASK_ISA_AES) | |
217 | def_or_undef (parse_in, "__AES__"); | |
218 | if (isa_flag & OPTION_MASK_ISA_PCLMUL) | |
219 | def_or_undef (parse_in, "__PCLMUL__"); | |
ed30e0a6 | 220 | if (isa_flag & OPTION_MASK_ISA_AVX) |
221 | def_or_undef (parse_in, "__AVX__"); | |
222 | if (isa_flag & OPTION_MASK_ISA_FMA) | |
223 | def_or_undef (parse_in, "__FMA__"); | |
46f8e3b0 | 224 | if (isa_flag & OPTION_MASK_ISA_SSE4A) |
225 | def_or_undef (parse_in, "__SSE4A__"); | |
226 | if (isa_flag & OPTION_MASK_ISA_SSE5) | |
227 | def_or_undef (parse_in, "__SSE5__"); | |
228 | if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE)) | |
229 | def_or_undef (parse_in, "__SSE_MATH__"); | |
230 | if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE2)) | |
231 | def_or_undef (parse_in, "__SSE2_MATH__"); | |
232 | } | |
233 | ||
234 | \f | |
24470055 | 235 | /* Hook to validate the current #pragma GCC target and set the state, and |
236 | update the macros based on what was changed. If ARGS is NULL, then | |
237 | POP_TARGET is used to reset the options. */ | |
46f8e3b0 | 238 | |
239 | static bool | |
24470055 | 240 | ix86_pragma_target_parse (tree args, tree pop_target) |
46f8e3b0 | 241 | { |
242 | tree prev_tree = build_target_option_node (); | |
243 | tree cur_tree; | |
244 | struct cl_target_option *prev_opt; | |
245 | struct cl_target_option *cur_opt; | |
246 | int prev_isa; | |
247 | int cur_isa; | |
248 | int diff_isa; | |
249 | enum processor_type prev_arch; | |
250 | enum processor_type prev_tune; | |
251 | enum processor_type cur_arch; | |
252 | enum processor_type cur_tune; | |
253 | ||
254 | if (! args) | |
255 | { | |
24470055 | 256 | cur_tree = ((pop_target) |
257 | ? pop_target | |
258 | : target_option_default_node); | |
46f8e3b0 | 259 | cl_target_option_restore (TREE_TARGET_OPTION (cur_tree)); |
260 | } | |
261 | else | |
262 | { | |
24470055 | 263 | cur_tree = ix86_valid_target_attribute_tree (args); |
46f8e3b0 | 264 | if (!cur_tree) |
265 | return false; | |
266 | } | |
267 | ||
268 | target_option_current_node = cur_tree; | |
269 | ||
270 | /* Figure out the previous/current isa, arch, tune and the differences. */ | |
271 | prev_opt = TREE_TARGET_OPTION (prev_tree); | |
272 | cur_opt = TREE_TARGET_OPTION (cur_tree); | |
273 | prev_isa = prev_opt->ix86_isa_flags; | |
274 | cur_isa = cur_opt->ix86_isa_flags; | |
275 | diff_isa = (prev_isa ^ cur_isa); | |
276 | prev_arch = prev_opt->arch; | |
277 | prev_tune = prev_opt->tune; | |
278 | cur_arch = cur_opt->arch; | |
279 | cur_tune = cur_opt->tune; | |
280 | ||
281 | /* If the same processor is used for both previous and current options, don't | |
282 | change the macros. */ | |
283 | if (cur_arch == prev_arch) | |
284 | cur_arch = prev_arch = PROCESSOR_max; | |
285 | ||
286 | if (cur_tune == prev_tune) | |
287 | cur_tune = prev_tune = PROCESSOR_max; | |
288 | ||
289 | /* Undef all of the macros for that are no longer current. */ | |
290 | ix86_target_macros_internal (prev_isa & diff_isa, | |
291 | prev_arch, | |
292 | prev_tune, | |
293 | prev_opt->fpmath, | |
294 | cpp_undef); | |
295 | ||
296 | /* Define all of the macros for new options that were just turned on. */ | |
297 | ix86_target_macros_internal (cur_isa & diff_isa, | |
298 | cur_arch, | |
299 | cur_tune, | |
300 | cur_opt->fpmath, | |
301 | cpp_define); | |
302 | ||
303 | return true; | |
304 | } | |
305 | \f | |
306 | /* Function to tell the preprocessor about the defines for the current target. */ | |
307 | ||
308 | void | |
309 | ix86_target_macros (void) | |
310 | { | |
311 | /* 32/64-bit won't change with target specific options, so do the assert and | |
312 | builtin_define_std calls here. */ | |
313 | if (TARGET_64BIT) | |
314 | { | |
315 | cpp_assert (parse_in, "cpu=x86_64"); | |
316 | cpp_assert (parse_in, "machine=x86_64"); | |
317 | cpp_define (parse_in, "__amd64"); | |
318 | cpp_define (parse_in, "__amd64__"); | |
319 | cpp_define (parse_in, "__x86_64"); | |
320 | cpp_define (parse_in, "__x86_64__"); | |
321 | } | |
322 | else | |
323 | { | |
324 | cpp_assert (parse_in, "cpu=i386"); | |
325 | cpp_assert (parse_in, "machine=i386"); | |
326 | builtin_define_std ("i386"); | |
327 | } | |
328 | ||
329 | ix86_target_macros_internal (ix86_isa_flags, | |
330 | ix86_arch, | |
331 | ix86_tune, | |
332 | ix86_fpmath, | |
333 | cpp_define); | |
334 | } | |
335 | ||
336 | \f | |
337 | /* Register target pragmas. We need to add the hook for parsing #pragma GCC | |
338 | option here rather than in i386.c since it will pull in various preprocessor | |
339 | functions, and those are not present in languages like fortran without a | |
340 | preprocessor. */ | |
341 | ||
342 | void | |
343 | ix86_register_pragmas (void) | |
344 | { | |
24470055 | 345 | /* Update pragma hook to allow parsing #pragma GCC target. */ |
346 | targetm.target_option.pragma_parse = ix86_pragma_target_parse; | |
46f8e3b0 | 347 | |
348 | #ifdef REGISTER_SUBTARGET_PRAGMAS | |
349 | REGISTER_SUBTARGET_PRAGMAS (); | |
350 | #endif | |
351 | } |