LCOV - code coverage report
Current view: top level - gcc/config/i386 - i386-c.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 429 584 73.5 %
Date: 2020-03-28 11:57:23 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Subroutines used for macro/preprocessor support on the ia-32.
       2                 :            :    Copyright (C) 2008-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #define IN_TARGET_CODE 1
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "target.h"
      26                 :            : #include "c-family/c-common.h"
      27                 :            : #include "memmodel.h"
      28                 :            : #include "tm_p.h"
      29                 :            : #include "c-family/c-pragma.h"
      30                 :            : 
      31                 :            : static bool ix86_pragma_target_parse (tree, tree);
      32                 :            : static void ix86_target_macros_internal
      33                 :            :   (HOST_WIDE_INT, HOST_WIDE_INT, enum processor_type, enum processor_type, enum fpmath_unit,
      34                 :            :    void (*def_or_undef) (cpp_reader *, const char *));
      35                 :            : 
      36                 :            : /* Internal function to either define or undef the appropriate system
      37                 :            :    macros.  */
      38                 :            : static void
      39                 :    1245290 : ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
      40                 :            :                              HOST_WIDE_INT isa_flag2,
      41                 :            :                              enum processor_type arch,
      42                 :            :                              enum processor_type tune,
      43                 :            :                              enum fpmath_unit fpmath,
      44                 :            :                              void (*def_or_undef) (cpp_reader *,
      45                 :            :                                                    const char *))
      46                 :            : {
      47                 :            :   /* For some of the k6/pentium varients there weren't separate ISA bits to
      48                 :            :      identify which tune/arch flag was passed, so figure it out here.  */
      49                 :    1245290 :   size_t arch_len = strlen (ix86_arch_string);
      50                 :    1245290 :   size_t tune_len = strlen (ix86_tune_string);
      51                 :    1245290 :   int last_arch_char = ix86_arch_string[arch_len - 1];
      52                 :    1245290 :   int last_tune_char = ix86_tune_string[tune_len - 1];
      53                 :            : 
      54                 :            :   /* Built-ins based on -march=.  */
      55                 :    1245290 :   switch (arch)
      56                 :            :     {
      57                 :            :     case PROCESSOR_I386:
      58                 :            :       break;
      59                 :        297 :     case PROCESSOR_I486:
      60                 :        297 :       def_or_undef (parse_in, "__i486");
      61                 :        297 :       def_or_undef (parse_in, "__i486__");
      62                 :        297 :       break;
      63                 :         22 :     case PROCESSOR_LAKEMONT:
      64                 :            :       /* Intel MCU is based on Intel Pentium CPU.  */
      65                 :         22 :     case PROCESSOR_PENTIUM:
      66                 :         22 :       def_or_undef (parse_in, "__i586");
      67                 :         22 :       def_or_undef (parse_in, "__i586__");
      68                 :         22 :       def_or_undef (parse_in, "__pentium");
      69                 :         22 :       def_or_undef (parse_in, "__pentium__");
      70                 :         22 :       if (isa_flag & OPTION_MASK_ISA_MMX)
      71                 :          0 :         def_or_undef (parse_in, "__pentium_mmx__");
      72                 :            :       break;
      73                 :          0 :     case PROCESSOR_PENTIUMPRO:
      74                 :          0 :       def_or_undef (parse_in, "__i686");
      75                 :          0 :       def_or_undef (parse_in, "__i686__");
      76                 :          0 :       def_or_undef (parse_in, "__pentiumpro");
      77                 :          0 :       def_or_undef (parse_in, "__pentiumpro__");
      78                 :          0 :       break;
      79                 :          0 :     case PROCESSOR_GEODE:
      80                 :          0 :       def_or_undef (parse_in, "__geode");
      81                 :          0 :       def_or_undef (parse_in, "__geode__");
      82                 :          0 :       break;
      83                 :          0 :     case PROCESSOR_K6:
      84                 :          0 :       def_or_undef (parse_in, "__k6");
      85                 :          0 :       def_or_undef (parse_in, "__k6__");
      86                 :          0 :       if (last_arch_char == '2')
      87                 :          0 :         def_or_undef (parse_in, "__k6_2__");
      88                 :          0 :       else if (last_arch_char == '3')
      89                 :          0 :         def_or_undef (parse_in, "__k6_3__");
      90                 :          0 :       else if (isa_flag & OPTION_MASK_ISA_3DNOW)
      91                 :          0 :         def_or_undef (parse_in, "__k6_3__");
      92                 :            :       break;
      93                 :          0 :     case PROCESSOR_ATHLON:
      94                 :          0 :       def_or_undef (parse_in, "__athlon");
      95                 :          0 :       def_or_undef (parse_in, "__athlon__");
      96                 :          0 :       if (isa_flag & OPTION_MASK_ISA_SSE)
      97                 :          0 :         def_or_undef (parse_in, "__athlon_sse__");
      98                 :            :       break;
      99                 :     156109 :     case PROCESSOR_K8:
     100                 :     156109 :       def_or_undef (parse_in, "__k8");
     101                 :     156109 :       def_or_undef (parse_in, "__k8__");
     102                 :     156109 :       break;
     103                 :         39 :     case PROCESSOR_AMDFAM10:
     104                 :         39 :       def_or_undef (parse_in, "__amdfam10");
     105                 :         39 :       def_or_undef (parse_in, "__amdfam10__");
     106                 :         39 :       break;
     107                 :          5 :     case PROCESSOR_BDVER1:
     108                 :          5 :       def_or_undef (parse_in, "__bdver1");
     109                 :          5 :       def_or_undef (parse_in, "__bdver1__");
     110                 :          5 :       break;
     111                 :          1 :     case PROCESSOR_BDVER2:
     112                 :          1 :       def_or_undef (parse_in, "__bdver2");
     113                 :          1 :       def_or_undef (parse_in, "__bdver2__");
     114                 :          1 :       break;
     115                 :          0 :     case PROCESSOR_BDVER3:
     116                 :          0 :       def_or_undef (parse_in, "__bdver3");
     117                 :          0 :       def_or_undef (parse_in, "__bdver3__");
     118                 :          0 :       break;
     119                 :         16 :     case PROCESSOR_BDVER4:
     120                 :         16 :       def_or_undef (parse_in, "__bdver4");
     121                 :         16 :       def_or_undef (parse_in, "__bdver4__");
     122                 :         16 :       break;
     123                 :          2 :     case PROCESSOR_ZNVER1:
     124                 :          2 :       def_or_undef (parse_in, "__znver1");
     125                 :          2 :       def_or_undef (parse_in, "__znver1__");
     126                 :          2 :       break;
     127                 :          0 :     case PROCESSOR_ZNVER2:
     128                 :          0 :       def_or_undef (parse_in, "__znver2");
     129                 :          0 :       def_or_undef (parse_in, "__znver2__");
     130                 :          0 :       break;
     131                 :          0 :     case PROCESSOR_BTVER1:
     132                 :          0 :       def_or_undef (parse_in, "__btver1");
     133                 :          0 :       def_or_undef (parse_in, "__btver1__");
     134                 :          0 :       break;
     135                 :          0 :     case PROCESSOR_BTVER2:
     136                 :          0 :       def_or_undef (parse_in, "__btver2");
     137                 :          0 :       def_or_undef (parse_in, "__btver2__");
     138                 :          0 :       break;
     139                 :          0 :     case PROCESSOR_PENTIUM4:
     140                 :          0 :       def_or_undef (parse_in, "__pentium4");
     141                 :          0 :       def_or_undef (parse_in, "__pentium4__");
     142                 :          0 :       break;
     143                 :          8 :     case PROCESSOR_NOCONA:
     144                 :          8 :       def_or_undef (parse_in, "__nocona");
     145                 :          8 :       def_or_undef (parse_in, "__nocona__");
     146                 :          8 :       break;
     147                 :         17 :     case PROCESSOR_CORE2:
     148                 :         17 :       def_or_undef (parse_in, "__core2");
     149                 :         17 :       def_or_undef (parse_in, "__core2__");
     150                 :         17 :       break;
     151                 :          7 :     case PROCESSOR_NEHALEM:
     152                 :          7 :       def_or_undef (parse_in, "__corei7");
     153                 :          7 :       def_or_undef (parse_in, "__corei7__");
     154                 :          7 :       def_or_undef (parse_in, "__nehalem");
     155                 :          7 :       def_or_undef (parse_in, "__nehalem__");
     156                 :          7 :       break;
     157                 :          2 :     case PROCESSOR_SANDYBRIDGE:
     158                 :          2 :       def_or_undef (parse_in, "__corei7_avx");
     159                 :          2 :       def_or_undef (parse_in, "__corei7_avx__");
     160                 :          2 :       def_or_undef (parse_in, "__sandybridge");
     161                 :          2 :       def_or_undef (parse_in, "__sandybridge__");
     162                 :          2 :       break;
     163                 :         59 :     case PROCESSOR_HASWELL:
     164                 :         59 :       def_or_undef (parse_in, "__core_avx2");
     165                 :         59 :       def_or_undef (parse_in, "__core_avx2__");
     166                 :         59 :       def_or_undef (parse_in, "__haswell");
     167                 :         59 :       def_or_undef (parse_in, "__haswell__");
     168                 :         59 :       break;
     169                 :         19 :     case PROCESSOR_BONNELL:
     170                 :         19 :       def_or_undef (parse_in, "__atom");
     171                 :         19 :       def_or_undef (parse_in, "__atom__");
     172                 :         19 :       def_or_undef (parse_in, "__bonnell");
     173                 :         19 :       def_or_undef (parse_in, "__bonnell__");
     174                 :         19 :       break;
     175                 :          5 :     case PROCESSOR_SILVERMONT:
     176                 :          5 :       def_or_undef (parse_in, "__slm");
     177                 :          5 :       def_or_undef (parse_in, "__slm__");
     178                 :          5 :       def_or_undef (parse_in, "__silvermont");
     179                 :          5 :       def_or_undef (parse_in, "__silvermont__");
     180                 :          5 :       break;
     181                 :          0 :     case PROCESSOR_GOLDMONT:
     182                 :          0 :       def_or_undef (parse_in, "__goldmont");
     183                 :          0 :       def_or_undef (parse_in, "__goldmont__");
     184                 :          0 :       break;
     185                 :          0 :     case PROCESSOR_GOLDMONT_PLUS:
     186                 :          0 :       def_or_undef (parse_in, "__goldmont_plus");
     187                 :          0 :       def_or_undef (parse_in, "__goldmont_plus__");
     188                 :          0 :       break;
     189                 :          0 :     case PROCESSOR_TREMONT:
     190                 :          0 :       def_or_undef (parse_in, "__tremont");
     191                 :          0 :       def_or_undef (parse_in, "__tremont__");
     192                 :          0 :       break;
     193                 :         13 :     case PROCESSOR_KNL:
     194                 :         13 :       def_or_undef (parse_in, "__knl");
     195                 :         13 :       def_or_undef (parse_in, "__knl__");
     196                 :         13 :       break;
     197                 :          0 :     case PROCESSOR_KNM:
     198                 :          0 :       def_or_undef (parse_in, "__knm");
     199                 :          0 :       def_or_undef (parse_in, "__knm__");
     200                 :          0 :       break;
     201                 :         14 :     case PROCESSOR_SKYLAKE:
     202                 :         14 :       def_or_undef (parse_in, "__skylake");
     203                 :         14 :       def_or_undef (parse_in, "__skylake__");
     204                 :         14 :       break;
     205                 :         50 :     case PROCESSOR_SKYLAKE_AVX512:
     206                 :         50 :       def_or_undef (parse_in, "__skylake_avx512");
     207                 :         50 :       def_or_undef (parse_in, "__skylake_avx512__");
     208                 :         50 :       break;
     209                 :          1 :     case PROCESSOR_CANNONLAKE:
     210                 :          1 :       def_or_undef (parse_in, "__cannonlake");
     211                 :          1 :       def_or_undef (parse_in, "__cannonlake__");
     212                 :          1 :       break;
     213                 :          0 :     case PROCESSOR_ICELAKE_CLIENT:
     214                 :          0 :       def_or_undef (parse_in, "__icelake_client");
     215                 :          0 :       def_or_undef (parse_in, "__icelake_client__");
     216                 :          0 :       break;
     217                 :          1 :     case PROCESSOR_ICELAKE_SERVER:
     218                 :          1 :       def_or_undef (parse_in, "__icelake_server");
     219                 :          1 :       def_or_undef (parse_in, "__icelake_server__");
     220                 :          1 :       break;
     221                 :          0 :     case PROCESSOR_CASCADELAKE:
     222                 :          0 :       def_or_undef (parse_in, "__cascadelake");
     223                 :          0 :       def_or_undef (parse_in, "__cascadelake__");
     224                 :          0 :       break;
     225                 :          0 :     case PROCESSOR_TIGERLAKE:
     226                 :          0 :       def_or_undef (parse_in, "__tigerlake");
     227                 :          0 :       def_or_undef (parse_in, "__tigerlake__");
     228                 :          0 :       break;
     229                 :          0 :     case PROCESSOR_COOPERLAKE:
     230                 :          0 :       def_or_undef (parse_in, "__cooperlake");
     231                 :          0 :       def_or_undef (parse_in, "__cooperlake__");
     232                 :            :     /* use PROCESSOR_max to not set/unset the arch macro.  */
     233                 :            :     case PROCESSOR_max:
     234                 :            :       break;
     235                 :          0 :     case PROCESSOR_INTEL:
     236                 :          0 :     case PROCESSOR_GENERIC:
     237                 :          0 :       gcc_unreachable ();
     238                 :            :     }
     239                 :            : 
     240                 :            :   /* Built-ins based on -mtune=.  */
     241                 :    1245290 :   switch (tune)
     242                 :            :     {
     243                 :          0 :     case PROCESSOR_I386:
     244                 :          0 :       def_or_undef (parse_in, "__tune_i386__");
     245                 :          0 :       break;
     246                 :          0 :     case PROCESSOR_I486:
     247                 :          0 :       def_or_undef (parse_in, "__tune_i486__");
     248                 :          0 :       break;
     249                 :          0 :     case PROCESSOR_PENTIUM:
     250                 :          0 :       def_or_undef (parse_in, "__tune_i586__");
     251                 :          0 :       def_or_undef (parse_in, "__tune_pentium__");
     252                 :          0 :       if (last_tune_char == 'x')
     253                 :          0 :         def_or_undef (parse_in, "__tune_pentium_mmx__");
     254                 :            :       break;
     255                 :          0 :     case PROCESSOR_PENTIUMPRO:
     256                 :          0 :       def_or_undef (parse_in, "__tune_i686__");
     257                 :          0 :       def_or_undef (parse_in, "__tune_pentiumpro__");
     258                 :          0 :       switch (last_tune_char)
     259                 :            :         {
     260                 :          0 :         case '3':
     261                 :          0 :           def_or_undef (parse_in, "__tune_pentium3__");
     262                 :            :           /* FALLTHRU */
     263                 :          0 :         case '2':
     264                 :          0 :           def_or_undef (parse_in, "__tune_pentium2__");
     265                 :          0 :           break;
     266                 :            :         }
     267                 :            :       break;
     268                 :          0 :     case PROCESSOR_GEODE:
     269                 :          0 :       def_or_undef (parse_in, "__tune_geode__");
     270                 :          0 :       break;
     271                 :          0 :     case PROCESSOR_K6:
     272                 :          0 :       def_or_undef (parse_in, "__tune_k6__");
     273                 :          0 :       if (last_tune_char == '2')
     274                 :          0 :         def_or_undef (parse_in, "__tune_k6_2__");
     275                 :          0 :       else if (last_tune_char == '3')
     276                 :          0 :         def_or_undef (parse_in, "__tune_k6_3__");
     277                 :          0 :       else if (isa_flag & OPTION_MASK_ISA_3DNOW)
     278                 :          0 :         def_or_undef (parse_in, "__tune_k6_3__");
     279                 :            :       break;
     280                 :          0 :     case PROCESSOR_ATHLON:
     281                 :          0 :       def_or_undef (parse_in, "__tune_athlon__");
     282                 :          0 :       if (isa_flag & OPTION_MASK_ISA_SSE)
     283                 :          0 :         def_or_undef (parse_in, "__tune_athlon_sse__");
     284                 :            :       break;
     285                 :         83 :     case PROCESSOR_K8:
     286                 :         83 :       def_or_undef (parse_in, "__tune_k8__");
     287                 :         83 :       break;
     288                 :         49 :     case PROCESSOR_AMDFAM10:
     289                 :         49 :       def_or_undef (parse_in, "__tune_amdfam10__");
     290                 :         49 :       break;
     291                 :          7 :     case PROCESSOR_BDVER1:
     292                 :          7 :       def_or_undef (parse_in, "__tune_bdver1__");
     293                 :          7 :       break;
     294                 :          1 :     case PROCESSOR_BDVER2:
     295                 :          1 :       def_or_undef (parse_in, "__tune_bdver2__");
     296                 :          1 :       break;
     297                 :          0 :     case PROCESSOR_BDVER3:
     298                 :          0 :       def_or_undef (parse_in, "__tune_bdver3__");
     299                 :          0 :       break;
     300                 :         17 :     case PROCESSOR_BDVER4:
     301                 :         17 :       def_or_undef (parse_in, "__tune_bdver4__");
     302                 :         17 :       break;
     303                 :          3 :     case PROCESSOR_ZNVER1:
     304                 :          3 :       def_or_undef (parse_in, "__tune_znver1__");
     305                 :          3 :       break;
     306                 :          0 :     case PROCESSOR_ZNVER2:
     307                 :          0 :       def_or_undef (parse_in, "__tune_znver2__");
     308                 :          0 :       break;
     309                 :          0 :     case PROCESSOR_BTVER1:
     310                 :          0 :       def_or_undef (parse_in, "__tune_btver1__");
     311                 :          0 :       break;
     312                 :          1 :     case PROCESSOR_BTVER2:
     313                 :          1 :       def_or_undef (parse_in, "__tune_btver2__");
     314                 :          1 :        break;
     315                 :          0 :     case PROCESSOR_PENTIUM4:
     316                 :          0 :       def_or_undef (parse_in, "__tune_pentium4__");
     317                 :          0 :       break;
     318                 :         10 :     case PROCESSOR_NOCONA:
     319                 :         10 :       def_or_undef (parse_in, "__tune_nocona__");
     320                 :         10 :       break;
     321                 :         56 :     case PROCESSOR_CORE2:
     322                 :         56 :       def_or_undef (parse_in, "__tune_core2__");
     323                 :         56 :       break;
     324                 :         15 :     case PROCESSOR_NEHALEM:
     325                 :         15 :       def_or_undef (parse_in, "__tune_corei7__");
     326                 :         15 :       def_or_undef (parse_in, "__tune_nehalem__");
     327                 :         15 :       break;
     328                 :          5 :     case PROCESSOR_SANDYBRIDGE:
     329                 :          5 :       def_or_undef (parse_in, "__tune_corei7_avx__");
     330                 :          5 :       def_or_undef (parse_in, "__tune_sandybridge__");
     331                 :          5 :       break;
     332                 :         62 :     case PROCESSOR_HASWELL:
     333                 :         62 :       def_or_undef (parse_in, "__tune_core_avx2__");
     334                 :         62 :       def_or_undef (parse_in, "__tune_haswell__");
     335                 :         62 :       break;
     336                 :         35 :     case PROCESSOR_BONNELL:
     337                 :         35 :       def_or_undef (parse_in, "__tune_atom__");
     338                 :         35 :       def_or_undef (parse_in, "__tune_bonnell__");
     339                 :         35 :       break;
     340                 :         15 :     case PROCESSOR_SILVERMONT:
     341                 :         15 :       def_or_undef (parse_in, "__tune_slm__");
     342                 :         15 :       def_or_undef (parse_in, "__tune_silvermont__");
     343                 :         15 :       break;
     344                 :          0 :     case PROCESSOR_GOLDMONT:
     345                 :          0 :       def_or_undef (parse_in, "__tune_goldmont__");
     346                 :          0 :       break;
     347                 :          0 :     case PROCESSOR_GOLDMONT_PLUS:
     348                 :          0 :       def_or_undef (parse_in, "__tune_goldmont_plus__");
     349                 :          0 :       break;
     350                 :          0 :     case PROCESSOR_TREMONT:
     351                 :          0 :       def_or_undef (parse_in, "__tune_tremont__");
     352                 :          0 :       break;
     353                 :         25 :     case PROCESSOR_KNL:
     354                 :         25 :       def_or_undef (parse_in, "__tune_knl__");
     355                 :         25 :       break;
     356                 :          0 :     case PROCESSOR_KNM:
     357                 :          0 :       def_or_undef (parse_in, "__tune_knm__");
     358                 :          0 :       break;
     359                 :         21 :     case PROCESSOR_SKYLAKE:
     360                 :         21 :       def_or_undef (parse_in, "__tune_skylake__");
     361                 :         21 :       break;
     362                 :         78 :     case PROCESSOR_SKYLAKE_AVX512:
     363                 :         78 :       def_or_undef (parse_in, "__tune_skylake_avx512__");
     364                 :         78 :       break;
     365                 :          1 :     case PROCESSOR_CANNONLAKE:
     366                 :          1 :       def_or_undef (parse_in, "__tune_cannonlake__");
     367                 :          1 :       break;
     368                 :          0 :     case PROCESSOR_ICELAKE_CLIENT:
     369                 :          0 :       def_or_undef (parse_in, "__tune_icelake_client__");
     370                 :          0 :       break;
     371                 :          1 :     case PROCESSOR_ICELAKE_SERVER:
     372                 :          1 :       def_or_undef (parse_in, "__tune_icelake_server__");
     373                 :          1 :       break;
     374                 :          0 :     case PROCESSOR_LAKEMONT:
     375                 :          0 :       def_or_undef (parse_in, "__tune_lakemont__");
     376                 :          0 :       break;
     377                 :          0 :     case PROCESSOR_CASCADELAKE:
     378                 :          0 :       def_or_undef (parse_in, "__tune_cascadelake__");
     379                 :          0 :       break;
     380                 :          0 :     case PROCESSOR_TIGERLAKE:
     381                 :          0 :       def_or_undef (parse_in, "__tune_tigerlake__");
     382                 :          0 :       break;
     383                 :          0 :     case PROCESSOR_COOPERLAKE:
     384                 :          0 :       def_or_undef (parse_in, "__tune_cooperlake__");
     385                 :          0 :       break;
     386                 :            :     case PROCESSOR_INTEL:
     387                 :            :     case PROCESSOR_GENERIC:
     388                 :            :       break;
     389                 :            :     /* use PROCESSOR_max to not set/unset the tune macro.  */
     390                 :            :     case PROCESSOR_max:
     391                 :            :       break;
     392                 :            :     }
     393                 :            : 
     394                 :    1245290 :   switch (ix86_cmodel)
     395                 :            :     {
     396                 :    1223850 :     case CM_SMALL:
     397                 :    1223850 :     case CM_SMALL_PIC:
     398                 :    1223850 :       def_or_undef (parse_in, "__code_model_small__");
     399                 :    1223850 :       break;
     400                 :        586 :     case CM_MEDIUM:
     401                 :        586 :     case CM_MEDIUM_PIC:
     402                 :        586 :       def_or_undef (parse_in, "__code_model_medium__");
     403                 :        586 :       break;
     404                 :         30 :     case CM_LARGE:
     405                 :         30 :     case CM_LARGE_PIC:
     406                 :         30 :       def_or_undef (parse_in, "__code_model_large__");
     407                 :         30 :       break;
     408                 :      20825 :     case CM_32:
     409                 :      20825 :       def_or_undef (parse_in, "__code_model_32__");
     410                 :      20825 :       break;
     411                 :          1 :     case CM_KERNEL:
     412                 :          1 :       def_or_undef (parse_in, "__code_model_kernel__");
     413                 :          1 :       break;
     414                 :    1245290 :     default:
     415                 :    1245290 :       ;
     416                 :            :     }
     417                 :            : 
     418                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_WBNOINVD)
     419                 :       7494 :     def_or_undef (parse_in, "__WBNOINVD__");
     420                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_AVX512VP2INTERSECT)
     421                 :      14957 :     def_or_undef (parse_in, "__AVX512VP2INTERSECT__");
     422                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_MMX)
     423                 :     159432 :     def_or_undef (parse_in, "__MMX__");
     424                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_3DNOW)
     425                 :       1882 :     def_or_undef (parse_in, "__3dNOW__");
     426                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_3DNOW_A)
     427                 :        999 :     def_or_undef (parse_in, "__3dNOW_A__");
     428                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE)
     429                 :     160609 :     def_or_undef (parse_in, "__SSE__");
     430                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE2)
     431                 :     160759 :     def_or_undef (parse_in, "__SSE2__");
     432                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE3)
     433                 :      33373 :     def_or_undef (parse_in, "__SSE3__");
     434                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSSE3)
     435                 :      32348 :     def_or_undef (parse_in, "__SSSE3__");
     436                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE4_1)
     437                 :      31993 :     def_or_undef (parse_in, "__SSE4_1__");
     438                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE4_2)
     439                 :      32212 :     def_or_undef (parse_in, "__SSE4_2__");
     440                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AES)
     441                 :       7597 :     def_or_undef (parse_in, "__AES__");
     442                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SHA)
     443                 :       7484 :     def_or_undef (parse_in, "__SHA__");
     444                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_PCLMUL)
     445                 :       7643 :     def_or_undef (parse_in, "__PCLMUL__");
     446                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX)
     447                 :      30253 :     def_or_undef (parse_in, "__AVX__");
     448                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX2)
     449                 :      74189 :     def_or_undef (parse_in, "__AVX2__");
     450                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512F)
     451                 :     104533 :     def_or_undef (parse_in, "__AVX512F__");
     452                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512ER)
     453                 :       7476 :     def_or_undef (parse_in, "__AVX512ER__");
     454                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512CD)
     455                 :      14941 :     def_or_undef (parse_in, "__AVX512CD__");
     456                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512PF)
     457                 :       7487 :     def_or_undef (parse_in, "__AVX512PF__");
     458                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512DQ)
     459                 :      14487 :     def_or_undef (parse_in, "__AVX512DQ__");
     460                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512BW)
     461                 :      78221 :     def_or_undef (parse_in, "__AVX512BW__");
     462                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512VL)
     463                 :      84703 :     def_or_undef (parse_in, "__AVX512VL__");
     464                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512VBMI)
     465                 :      14942 :     def_or_undef (parse_in, "__AVX512VBMI__");
     466                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512IFMA)
     467                 :      14959 :     def_or_undef (parse_in, "__AVX512IFMA__");
     468                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_AVX5124VNNIW)
     469                 :       7489 :     def_or_undef (parse_in, "__AVX5124VNNIW__");
     470                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512VBMI2)
     471                 :      29599 :     def_or_undef (parse_in, "__AVX512VBMI2__");
     472                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512VNNI)
     473                 :      14993 :     def_or_undef (parse_in, "__AVX512VNNI__");
     474                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_PCONFIG)
     475                 :       7494 :     def_or_undef (parse_in, "__PCONFIG__");
     476                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_SGX)
     477                 :       7544 :     def_or_undef (parse_in, "__SGX__");
     478                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_AVX5124FMAPS)
     479                 :       7487 :     def_or_undef (parse_in, "__AVX5124FMAPS__");
     480                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512BITALG)
     481                 :      29839 :     def_or_undef (parse_in, "__AVX512BITALG__");
     482                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_AVX512VPOPCNTDQ)
     483                 :      14948 :     def_or_undef (parse_in, "__AVX512VPOPCNTDQ__");
     484                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_FMA)
     485                 :       7666 :     def_or_undef (parse_in, "__FMA__");
     486                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_RTM)
     487                 :      14718 :     def_or_undef (parse_in, "__RTM__");
     488                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_SSE4A)
     489                 :       2626 :     def_or_undef (parse_in, "__SSE4A__");
     490                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_FMA4)
     491                 :       1757 :     def_or_undef (parse_in, "__FMA4__");
     492                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_XOP)
     493                 :        928 :     def_or_undef (parse_in, "__XOP__");
     494                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_LWP)
     495                 :        919 :     def_or_undef (parse_in, "__LWP__");
     496                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_ABM)
     497                 :         80 :     def_or_undef (parse_in, "__ABM__");
     498                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_BMI)
     499                 :       7584 :     def_or_undef (parse_in, "__BMI__");
     500                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_BMI2)
     501                 :       7617 :     def_or_undef (parse_in, "__BMI2__");
     502                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_LZCNT)
     503                 :       7647 :     def_or_undef (parse_in, "__LZCNT__");
     504                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_TBM)
     505                 :        909 :     def_or_undef (parse_in, "__TBM__");
     506                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_POPCNT)
     507                 :      32954 :     def_or_undef (parse_in, "__POPCNT__");
     508                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_FSGSBASE)
     509                 :       7507 :     def_or_undef (parse_in, "__FSGSBASE__");
     510                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_RDRND)
     511                 :      14936 :     def_or_undef (parse_in, "__RDRND__");
     512                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_F16C)
     513                 :       7589 :     def_or_undef (parse_in, "__F16C__");
     514                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_RDSEED)
     515                 :       7553 :     def_or_undef (parse_in, "__RDSEED__");
     516                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_PRFCHW)
     517                 :        159 :     def_or_undef (parse_in, "__PRFCHW__");
     518                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_ADX)
     519                 :        103 :     def_or_undef (parse_in, "__ADX__");
     520                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_FXSR)
     521                 :     156453 :     def_or_undef (parse_in, "__FXSR__");
     522                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_XSAVE)
     523                 :      31565 :     def_or_undef (parse_in, "__XSAVE__");
     524                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_XSAVEOPT)
     525                 :       7606 :     def_or_undef (parse_in, "__XSAVEOPT__");
     526                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_PREFETCHWT1)
     527                 :         16 :     def_or_undef (parse_in, "__PREFETCHWT1__");
     528                 :    1245290 :   if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE))
     529                 :     152072 :     def_or_undef (parse_in, "__SSE_MATH__");
     530                 :    1245290 :   if ((fpmath & FPMATH_SSE) && (isa_flag & OPTION_MASK_ISA_SSE2))
     531                 :     151992 :     def_or_undef (parse_in, "__SSE2_MATH__");
     532                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_CLFLUSHOPT)
     533                 :       7546 :     def_or_undef (parse_in, "__CLFLUSHOPT__");
     534                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_CLZERO)
     535                 :        897 :     def_or_undef (parse_in, "__CLZERO__");
     536                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_XSAVEC)
     537                 :       7545 :     def_or_undef (parse_in, "__XSAVEC__");
     538                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_XSAVES)
     539                 :       7545 :     def_or_undef (parse_in, "__XSAVES__");
     540                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_CLWB)
     541                 :       7529 :     def_or_undef (parse_in, "__CLWB__");
     542                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_MWAITX)
     543                 :        913 :     def_or_undef (parse_in, "__MWAITX__");
     544                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_PKU)
     545                 :       7529 :     def_or_undef (parse_in, "__PKU__");
     546                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_RDPID)
     547                 :       7495 :     def_or_undef (parse_in, "__RDPID__");
     548                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_GFNI)
     549                 :      37301 :     def_or_undef (parse_in, "__GFNI__");
     550                 :    1245290 :   if ((isa_flag & OPTION_MASK_ISA_SHSTK))
     551                 :       7501 :     def_or_undef (parse_in, "__SHSTK__");
     552                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_VAES)
     553                 :      15016 :     def_or_undef (parse_in, "__VAES__");
     554                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_VPCLMULQDQ)
     555                 :      14998 :     def_or_undef (parse_in, "__VPCLMULQDQ__");
     556                 :    1245290 :   if (isa_flag & OPTION_MASK_ISA_MOVDIRI)
     557                 :       7507 :     def_or_undef (parse_in, "__MOVDIRI__");
     558                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_MOVDIR64B)
     559                 :       7509 :     def_or_undef (parse_in, "__MOVDIR64B__");
     560                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_WAITPKG)
     561                 :       7506 :     def_or_undef (parse_in, "__WAITPKG__");
     562                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_CLDEMOTE)
     563                 :       7507 :     def_or_undef (parse_in, "__CLDEMOTE__");
     564                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_PTWRITE)
     565                 :       7509 :     def_or_undef (parse_in, "__PTWRITE__");
     566                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_AVX512BF16)
     567                 :      14947 :     def_or_undef (parse_in, "__AVX512BF16__");
     568                 :    1245290 :   if (TARGET_MMX_WITH_SSE)
     569                 :    1224120 :     def_or_undef (parse_in, "__MMX_WITH_SSE__");
     570                 :    1245290 :   if (isa_flag2 & OPTION_MASK_ISA2_ENQCMD)
     571                 :       7492 :     def_or_undef (parse_in, "__ENQCMD__");
     572                 :    1245290 :   if (TARGET_IAMCU)
     573                 :            :     {
     574                 :          0 :       def_or_undef (parse_in, "__iamcu");
     575                 :          0 :       def_or_undef (parse_in, "__iamcu__");
     576                 :            :     }
     577                 :    1245290 : }
     578                 :            : 
     579                 :            : 
     580                 :            : /* Hook to validate the current #pragma GCC target and set the state, and
     581                 :            :    update the macros based on what was changed.  If ARGS is NULL, then
     582                 :            :    POP_TARGET is used to reset the options.  */
     583                 :            : 
     584                 :            : static bool
     585                 :     544421 : ix86_pragma_target_parse (tree args, tree pop_target)
     586                 :            : {
     587                 :     544421 :   tree prev_tree = build_target_option_node (&global_options);
     588                 :     544421 :   tree cur_tree;
     589                 :     544421 :   struct cl_target_option *prev_opt;
     590                 :     544421 :   struct cl_target_option *cur_opt;
     591                 :     544421 :   HOST_WIDE_INT prev_isa;
     592                 :     544421 :   HOST_WIDE_INT cur_isa;
     593                 :     544421 :   HOST_WIDE_INT diff_isa;
     594                 :     544421 :   HOST_WIDE_INT prev_isa2;
     595                 :     544421 :   HOST_WIDE_INT cur_isa2;
     596                 :     544421 :   HOST_WIDE_INT diff_isa2;
     597                 :     544421 :   enum processor_type prev_arch;
     598                 :     544421 :   enum processor_type prev_tune;
     599                 :     544421 :   enum processor_type cur_arch;
     600                 :     544421 :   enum processor_type cur_tune;
     601                 :            : 
     602                 :     544421 :   if (! args)
     603                 :            :     {
     604                 :     272136 :       cur_tree = (pop_target ? pop_target : target_option_default_node);
     605                 :     272136 :       cl_target_option_restore (&global_options,
     606                 :     272136 :                                 TREE_TARGET_OPTION (cur_tree));
     607                 :            :     }
     608                 :            :   else
     609                 :            :     {
     610                 :     272285 :       cur_tree = ix86_valid_target_attribute_tree (NULL_TREE, args,
     611                 :            :                                                    &global_options,
     612                 :            :                                                    &global_options_set, 0);
     613                 :     272285 :       if (!cur_tree || cur_tree == error_mark_node)
     614                 :            :        {
     615                 :        119 :          cl_target_option_restore (&global_options,
     616                 :        119 :                                    TREE_TARGET_OPTION (prev_tree));
     617                 :        119 :          return false;
     618                 :            :        }
     619                 :            :     }
     620                 :            : 
     621                 :     544302 :   target_option_current_node = cur_tree;
     622                 :     544302 :   ix86_reset_previous_fndecl ();
     623                 :            : 
     624                 :            :   /* Figure out the previous/current isa, arch, tune and the differences.  */
     625                 :     544302 :   prev_opt  = TREE_TARGET_OPTION (prev_tree);
     626                 :     544302 :   cur_opt   = TREE_TARGET_OPTION (cur_tree);
     627                 :     544302 :   prev_isa  = prev_opt->x_ix86_isa_flags;
     628                 :     544302 :   cur_isa   = cur_opt->x_ix86_isa_flags;
     629                 :     544302 :   diff_isa  = (prev_isa ^ cur_isa);
     630                 :     544302 :   prev_isa2  = prev_opt->x_ix86_isa_flags2;
     631                 :     544302 :   cur_isa2   = cur_opt->x_ix86_isa_flags2;
     632                 :     544302 :   diff_isa2  = (prev_isa2 ^ cur_isa2);
     633                 :     544302 :   prev_arch = (enum processor_type) prev_opt->arch;
     634                 :     544302 :   prev_tune = (enum processor_type) prev_opt->tune;
     635                 :     544302 :   cur_arch  = (enum processor_type) cur_opt->arch;
     636                 :     544302 :   cur_tune  = (enum processor_type) cur_opt->tune;
     637                 :            : 
     638                 :            :   /* If the same processor is used for both previous and current options, don't
     639                 :            :      change the macros.  */
     640                 :     544302 :   if (cur_arch == prev_arch)
     641                 :     544302 :     cur_arch = prev_arch = PROCESSOR_max;
     642                 :            : 
     643                 :     544302 :   if (cur_tune == prev_tune)
     644                 :     544302 :     cur_tune = prev_tune = PROCESSOR_max;
     645                 :            : 
     646                 :            :   /* Undef all of the macros for that are no longer current.  */
     647                 :     544302 :   ix86_target_macros_internal (prev_isa & diff_isa,
     648                 :            :                                prev_isa2 & diff_isa2,
     649                 :            :                                prev_arch,
     650                 :            :                                prev_tune,
     651                 :     544302 :                                (enum fpmath_unit) prev_opt->x_ix86_fpmath,
     652                 :            :                                cpp_undef);
     653                 :            : 
     654                 :            :   /* For the definitions, ensure all newly defined macros are considered
     655                 :            :      as used for -Wunused-macros.  There is no point warning about the
     656                 :            :      compiler predefined macros.  */
     657                 :     544302 :   cpp_options *cpp_opts = cpp_get_options (parse_in);
     658                 :     544302 :   unsigned char saved_warn_unused_macros = cpp_opts->warn_unused_macros;
     659                 :     544302 :   cpp_opts->warn_unused_macros = 0;
     660                 :            : 
     661                 :            :   /* Define all of the macros for new options that were just turned on.  */
     662                 :     544302 :   ix86_target_macros_internal (cur_isa & diff_isa,
     663                 :            :                                cur_isa2 & diff_isa2,
     664                 :            :                                cur_arch,
     665                 :            :                                cur_tune,
     666                 :     544302 :                                (enum fpmath_unit) cur_opt->x_ix86_fpmath,
     667                 :            :                                cpp_define);
     668                 :            : 
     669                 :     544302 :   cpp_opts->warn_unused_macros = saved_warn_unused_macros;
     670                 :            : 
     671                 :     544302 :   return true;
     672                 :            : }
     673                 :            : 
     674                 :            : /* Function to tell the preprocessor about the defines for the current target.  */
     675                 :            : 
     676                 :            : void
     677                 :     156687 : ix86_target_macros (void)
     678                 :            : {
     679                 :            :   /* 32/64-bit won't change with target specific options, so do the assert and
     680                 :            :      builtin_define_std calls here.  */
     681                 :     156687 :   if (TARGET_64BIT)
     682                 :            :     {
     683                 :     152282 :       cpp_assert (parse_in, "cpu=x86_64");
     684                 :     152282 :       cpp_assert (parse_in, "machine=x86_64");
     685                 :     152282 :       cpp_define (parse_in, "__amd64");
     686                 :     152282 :       cpp_define (parse_in, "__amd64__");
     687                 :     152282 :       cpp_define (parse_in, "__x86_64");
     688                 :     152282 :       cpp_define (parse_in, "__x86_64__");
     689                 :     152282 :       if (TARGET_X32)
     690                 :            :         {
     691                 :         68 :           cpp_define (parse_in, "_ILP32");
     692                 :         68 :           cpp_define (parse_in, "__ILP32__");
     693                 :            :         }
     694                 :            :     }
     695                 :            :   else
     696                 :            :     {
     697                 :       4405 :       cpp_assert (parse_in, "cpu=i386");
     698                 :       4405 :       cpp_assert (parse_in, "machine=i386");
     699                 :       4405 :       builtin_define_std ("i386");
     700                 :            :     }
     701                 :            : 
     702                 :     156687 :   if (!TARGET_80387)
     703                 :        139 :     cpp_define (parse_in, "_SOFT_FLOAT");
     704                 :            : 
     705                 :     156687 :   if (TARGET_LONG_DOUBLE_64)
     706                 :         13 :     cpp_define (parse_in, "__LONG_DOUBLE_64__");
     707                 :            : 
     708                 :     156687 :   if (TARGET_LONG_DOUBLE_128)
     709                 :          6 :     cpp_define (parse_in, "__LONG_DOUBLE_128__");
     710                 :            : 
     711                 :     156687 :   if (TARGET_128BIT_LONG_DOUBLE)
     712                 :     152281 :     cpp_define (parse_in, "__SIZEOF_FLOAT80__=16");
     713                 :            :   else
     714                 :       4406 :     cpp_define (parse_in, "__SIZEOF_FLOAT80__=12");
     715                 :            : 
     716                 :     156687 :   cpp_define (parse_in, "__SIZEOF_FLOAT128__=16");
     717                 :            : 
     718                 :     156687 :   cpp_define_formatted (parse_in, "__ATOMIC_HLE_ACQUIRE=%d", IX86_HLE_ACQUIRE);
     719                 :     156687 :   cpp_define_formatted (parse_in, "__ATOMIC_HLE_RELEASE=%d", IX86_HLE_RELEASE);
     720                 :            : 
     721                 :     156687 :   cpp_define (parse_in, "__GCC_ASM_FLAG_OUTPUTS__");
     722                 :            : 
     723                 :     156687 :   ix86_target_macros_internal (ix86_isa_flags,
     724                 :            :                                ix86_isa_flags2,
     725                 :            :                                ix86_arch,
     726                 :            :                                ix86_tune,
     727                 :            :                                ix86_fpmath,
     728                 :            :                                cpp_define);
     729                 :            : 
     730                 :     156687 :   cpp_define (parse_in, "__SEG_FS");
     731                 :     156687 :   cpp_define (parse_in, "__SEG_GS");
     732                 :            : 
     733                 :     156687 :   if (flag_cf_protection != CF_NONE)
     734                 :        142 :     cpp_define_formatted (parse_in, "__CET__=%d",
     735                 :        142 :                           flag_cf_protection & ~CF_SET);
     736                 :     156687 : }
     737                 :            : 
     738                 :            : 
     739                 :            : /* Register target pragmas.  We need to add the hook for parsing #pragma GCC
     740                 :            :    option here rather than in i386.c since it will pull in various preprocessor
     741                 :            :    functions, and those are not present in languages like fortran without a
     742                 :            :    preprocessor.  */
     743                 :            : 
     744                 :            : void
     745                 :     156836 : ix86_register_pragmas (void)
     746                 :            : {
     747                 :            :   /* Update pragma hook to allow parsing #pragma GCC target.  */
     748                 :     156836 :   targetm.target_option.pragma_parse = ix86_pragma_target_parse;
     749                 :            : 
     750                 :     156836 :   c_register_addr_space ("__seg_fs", ADDR_SPACE_SEG_FS);
     751                 :     156836 :   c_register_addr_space ("__seg_gs", ADDR_SPACE_SEG_GS);
     752                 :            : 
     753                 :            : #ifdef REGISTER_SUBTARGET_PRAGMAS
     754                 :            :   REGISTER_SUBTARGET_PRAGMAS ();
     755                 :            : #endif
     756                 :     156836 : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.