1 /* 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 if (TARGET_X32) 385 { 386 cpp_define (parse_in, "_ILP32"); 387 cpp_define (parse_in, "__ILP32__"); 388 } 389 } 390 else 391 { 392 cpp_assert (parse_in, "cpu=i386"); 393 cpp_assert (parse_in, "machine=i386"); 394 builtin_define_std ("i386"); 395 } 396 397 ix86_target_macros_internal (ix86_isa_flags, 398 ix86_arch, 399 ix86_tune, 400 ix86_fpmath, 401 cpp_define); 402 } 403 404 405 /* Register target pragmas. We need to add the hook for parsing #pragma GCC 406 option here rather than in i386.c since it will pull in various preprocessor 407 functions, and those are not present in languages like fortran without a 408 preprocessor. */ 409 410 void 411 ix86_register_pragmas (void) 412 { 413 /* Update pragma hook to allow parsing #pragma GCC target. */ 414 targetm.target_option.pragma_parse = ix86_pragma_target_parse; 415 416 #ifdef REGISTER_SUBTARGET_PRAGMAS 417 REGISTER_SUBTARGET_PRAGMAS (); 418 #endif 419 } 420