LCOV - code coverage report
Current view: top level - gcc/config/i386 - i386-options.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 79.9 % 1672 1336
Test Date: 2024-11-30 13:30:02 Functions: 87.2 % 39 34
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Copyright (C) 1988-2024 Free Software Foundation, Inc.
       2                 :             : 
       3                 :             : This file is part of GCC.
       4                 :             : 
       5                 :             : GCC is free software; you can redistribute it and/or modify
       6                 :             : it under the terms of the GNU General Public License as published by
       7                 :             : the Free Software Foundation; either version 3, or (at your option)
       8                 :             : any later version.
       9                 :             : 
      10                 :             : GCC is distributed in the hope that it will be useful,
      11                 :             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      12                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13                 :             : GNU General Public License for more details.
      14                 :             : 
      15                 :             : You should have received a copy of the GNU General Public License
      16                 :             : along with GCC; see the file COPYING3.  If not see
      17                 :             : <http://www.gnu.org/licenses/>.  */
      18                 :             : 
      19                 :             : #define IN_TARGET_CODE 1
      20                 :             : 
      21                 :             : #include "config.h"
      22                 :             : #include "system.h"
      23                 :             : #include "coretypes.h"
      24                 :             : #include "backend.h"
      25                 :             : #include "rtl.h"
      26                 :             : #include "tree.h"
      27                 :             : #include "memmodel.h"
      28                 :             : #include "gimple.h"
      29                 :             : #include "cfghooks.h"
      30                 :             : #include "cfgloop.h"
      31                 :             : #include "df.h"
      32                 :             : #include "tm_p.h"
      33                 :             : #include "stringpool.h"
      34                 :             : #include "expmed.h"
      35                 :             : #include "optabs.h"
      36                 :             : #include "regs.h"
      37                 :             : #include "emit-rtl.h"
      38                 :             : #include "recog.h"
      39                 :             : #include "cgraph.h"
      40                 :             : #include "diagnostic.h"
      41                 :             : #include "cfgbuild.h"
      42                 :             : #include "alias.h"
      43                 :             : #include "fold-const.h"
      44                 :             : #include "attribs.h"
      45                 :             : #include "calls.h"
      46                 :             : #include "stor-layout.h"
      47                 :             : #include "varasm.h"
      48                 :             : #include "output.h"
      49                 :             : #include "insn-attr.h"
      50                 :             : #include "flags.h"
      51                 :             : #include "except.h"
      52                 :             : #include "explow.h"
      53                 :             : #include "expr.h"
      54                 :             : #include "cfgrtl.h"
      55                 :             : #include "common/common-target.h"
      56                 :             : #include "langhooks.h"
      57                 :             : #include "reload.h"
      58                 :             : #include "gimplify.h"
      59                 :             : #include "dwarf2.h"
      60                 :             : #include "tm-constrs.h"
      61                 :             : #include "cselib.h"
      62                 :             : #include "sched-int.h"
      63                 :             : #include "opts.h"
      64                 :             : #include "tree-pass.h"
      65                 :             : #include "context.h"
      66                 :             : #include "pass_manager.h"
      67                 :             : #include "target-globals.h"
      68                 :             : #include "gimple-iterator.h"
      69                 :             : #include "shrink-wrap.h"
      70                 :             : #include "builtins.h"
      71                 :             : #include "rtl-iter.h"
      72                 :             : #include "tree-iterator.h"
      73                 :             : #include "dbgcnt.h"
      74                 :             : #include "case-cfn-macros.h"
      75                 :             : #include "dojump.h"
      76                 :             : #include "fold-const-call.h"
      77                 :             : #include "tree-vrp.h"
      78                 :             : #include "tree-ssanames.h"
      79                 :             : #include "selftest.h"
      80                 :             : #include "selftest-rtl.h"
      81                 :             : #include "print-rtl.h"
      82                 :             : #include "intl.h"
      83                 :             : #include "ifcvt.h"
      84                 :             : #include "symbol-summary.h"
      85                 :             : #include "sreal.h"
      86                 :             : #include "ipa-cp.h"
      87                 :             : #include "ipa-prop.h"
      88                 :             : #include "ipa-fnsummary.h"
      89                 :             : #include "wide-int-bitmask.h"
      90                 :             : #include "tree-vector-builder.h"
      91                 :             : #include "debug.h"
      92                 :             : #include "dwarf2out.h"
      93                 :             : #include "i386-options.h"
      94                 :             : 
      95                 :             : #include "x86-tune-costs.h"
      96                 :             : 
      97                 :             : #ifndef SUBTARGET32_DEFAULT_CPU
      98                 :             : #define SUBTARGET32_DEFAULT_CPU "i386"
      99                 :             : #endif
     100                 :             : 
     101                 :             : /* Processor feature/optimization bitmasks.  */
     102                 :             : #define m_NONE HOST_WIDE_INT_0U
     103                 :             : #define m_ALL (~HOST_WIDE_INT_0U)
     104                 :             : #define m_386 (HOST_WIDE_INT_1U<<PROCESSOR_I386)
     105                 :             : #define m_486 (HOST_WIDE_INT_1U<<PROCESSOR_I486)
     106                 :             : #define m_PENT (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUM)
     107                 :             : #define m_LAKEMONT (HOST_WIDE_INT_1U<<PROCESSOR_LAKEMONT)
     108                 :             : #define m_PPRO (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUMPRO)
     109                 :             : #define m_PENT4 (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUM4)
     110                 :             : #define m_NOCONA (HOST_WIDE_INT_1U<<PROCESSOR_NOCONA)
     111                 :             : #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
     112                 :             : #define m_CORE2 (HOST_WIDE_INT_1U<<PROCESSOR_CORE2)
     113                 :             : #define m_NEHALEM (HOST_WIDE_INT_1U<<PROCESSOR_NEHALEM)
     114                 :             : #define m_SANDYBRIDGE (HOST_WIDE_INT_1U<<PROCESSOR_SANDYBRIDGE)
     115                 :             : #define m_HASWELL (HOST_WIDE_INT_1U<<PROCESSOR_HASWELL)
     116                 :             : #define m_BONNELL (HOST_WIDE_INT_1U<<PROCESSOR_BONNELL)
     117                 :             : #define m_SILVERMONT (HOST_WIDE_INT_1U<<PROCESSOR_SILVERMONT)
     118                 :             : #define m_SKYLAKE (HOST_WIDE_INT_1U<<PROCESSOR_SKYLAKE)
     119                 :             : #define m_SKYLAKE_AVX512 (HOST_WIDE_INT_1U<<PROCESSOR_SKYLAKE_AVX512)
     120                 :             : #define m_CANNONLAKE (HOST_WIDE_INT_1U<<PROCESSOR_CANNONLAKE)
     121                 :             : #define m_ICELAKE_CLIENT (HOST_WIDE_INT_1U<<PROCESSOR_ICELAKE_CLIENT)
     122                 :             : #define m_ICELAKE_SERVER (HOST_WIDE_INT_1U<<PROCESSOR_ICELAKE_SERVER)
     123                 :             : #define m_CASCADELAKE (HOST_WIDE_INT_1U<<PROCESSOR_CASCADELAKE)
     124                 :             : #define m_TIGERLAKE (HOST_WIDE_INT_1U<<PROCESSOR_TIGERLAKE)
     125                 :             : #define m_COOPERLAKE (HOST_WIDE_INT_1U<<PROCESSOR_COOPERLAKE)
     126                 :             : #define m_SAPPHIRERAPIDS (HOST_WIDE_INT_1U<<PROCESSOR_SAPPHIRERAPIDS)
     127                 :             : #define m_ALDERLAKE (HOST_WIDE_INT_1U<<PROCESSOR_ALDERLAKE)
     128                 :             : #define m_ROCKETLAKE (HOST_WIDE_INT_1U<<PROCESSOR_ROCKETLAKE)
     129                 :             : #define m_GRANITERAPIDS (HOST_WIDE_INT_1U<<PROCESSOR_GRANITERAPIDS)
     130                 :             : #define m_GRANITERAPIDS_D (HOST_WIDE_INT_1U<<PROCESSOR_GRANITERAPIDS_D)
     131                 :             : #define m_ARROWLAKE (HOST_WIDE_INT_1U<<PROCESSOR_ARROWLAKE)
     132                 :             : #define m_ARROWLAKE_S (HOST_WIDE_INT_1U<<PROCESSOR_ARROWLAKE_S)
     133                 :             : #define m_PANTHERLAKE (HOST_WIDE_INT_1U<<PROCESSOR_PANTHERLAKE)
     134                 :             : #define m_DIAMONDRAPIDS (HOST_WIDE_INT_1U<<PROCESSOR_DIAMONDRAPIDS)
     135                 :             : #define m_CORE_AVX512 (m_SKYLAKE_AVX512 | m_CANNONLAKE \
     136                 :             :                        | m_ICELAKE_CLIENT | m_ICELAKE_SERVER | m_CASCADELAKE \
     137                 :             :                        | m_TIGERLAKE | m_COOPERLAKE | m_SAPPHIRERAPIDS \
     138                 :             :                        | m_ROCKETLAKE | m_GRANITERAPIDS | m_GRANITERAPIDS_D \
     139                 :             :                        | m_DIAMONDRAPIDS)
     140                 :             : #define m_CORE_AVX2 (m_HASWELL | m_SKYLAKE | m_CORE_AVX512)
     141                 :             : #define m_CORE_ALL (m_CORE2 | m_NEHALEM  | m_SANDYBRIDGE | m_CORE_AVX2)
     142                 :             : #define m_CORE_HYBRID (m_ALDERLAKE | m_ARROWLAKE | m_ARROWLAKE_S \
     143                 :             :                        | m_PANTHERLAKE)
     144                 :             : #define m_GOLDMONT (HOST_WIDE_INT_1U<<PROCESSOR_GOLDMONT)
     145                 :             : #define m_GOLDMONT_PLUS (HOST_WIDE_INT_1U<<PROCESSOR_GOLDMONT_PLUS)
     146                 :             : #define m_TREMONT (HOST_WIDE_INT_1U<<PROCESSOR_TREMONT)
     147                 :             : #define m_SIERRAFOREST (HOST_WIDE_INT_1U<<PROCESSOR_SIERRAFOREST)
     148                 :             : #define m_GRANDRIDGE (HOST_WIDE_INT_1U<<PROCESSOR_GRANDRIDGE)
     149                 :             : #define m_CLEARWATERFOREST (HOST_WIDE_INT_1U<<PROCESSOR_CLEARWATERFOREST)
     150                 :             : #define m_CORE_ATOM (m_SIERRAFOREST | m_GRANDRIDGE | m_CLEARWATERFOREST)
     151                 :             : #define m_INTEL (HOST_WIDE_INT_1U<<PROCESSOR_INTEL)
     152                 :             : /* Gather Data Sampling / CVE-2022-40982 / INTEL-SA-00828.
     153                 :             :    Software mitigation.  */
     154                 :             : #define m_GDS (m_SKYLAKE | m_SKYLAKE_AVX512 | m_CANNONLAKE \
     155                 :             :                | m_ICELAKE_CLIENT | m_ICELAKE_SERVER | m_CASCADELAKE \
     156                 :             :                | m_TIGERLAKE | m_COOPERLAKE | m_ROCKETLAKE)
     157                 :             : 
     158                 :             : #define m_LUJIAZUI (HOST_WIDE_INT_1U<<PROCESSOR_LUJIAZUI)
     159                 :             : #define m_YONGFENG (HOST_WIDE_INT_1U<<PROCESSOR_YONGFENG)
     160                 :             : #define m_SHIJIDADAO (HOST_WIDE_INT_1U<<PROCESSOR_SHIJIDADAO)
     161                 :             : #define m_ZHAOXIN  (m_LUJIAZUI | m_YONGFENG | m_SHIJIDADAO)
     162                 :             : 
     163                 :             : #define m_GEODE (HOST_WIDE_INT_1U<<PROCESSOR_GEODE)
     164                 :             : #define m_K6 (HOST_WIDE_INT_1U<<PROCESSOR_K6)
     165                 :             : #define m_K6_GEODE (m_K6 | m_GEODE)
     166                 :             : #define m_K8 (HOST_WIDE_INT_1U<<PROCESSOR_K8)
     167                 :             : #define m_ATHLON (HOST_WIDE_INT_1U<<PROCESSOR_ATHLON)
     168                 :             : #define m_ATHLON_K8 (m_K8 | m_ATHLON)
     169                 :             : #define m_AMDFAM10 (HOST_WIDE_INT_1U<<PROCESSOR_AMDFAM10)
     170                 :             : #define m_BDVER1 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER1)
     171                 :             : #define m_BDVER2 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER2)
     172                 :             : #define m_BDVER3 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER3)
     173                 :             : #define m_BDVER4 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER4)
     174                 :             : #define m_ZNVER1 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER1)
     175                 :             : #define m_ZNVER2 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER2)
     176                 :             : #define m_ZNVER3 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER3)
     177                 :             : #define m_ZNVER4 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER4)
     178                 :             : #define m_ZNVER5 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER5)
     179                 :             : #define m_BTVER1 (HOST_WIDE_INT_1U<<PROCESSOR_BTVER1)
     180                 :             : #define m_BTVER2 (HOST_WIDE_INT_1U<<PROCESSOR_BTVER2)
     181                 :             : #define m_BDVER (m_BDVER1 | m_BDVER2 | m_BDVER3 | m_BDVER4)
     182                 :             : #define m_BTVER (m_BTVER1 | m_BTVER2)
     183                 :             : #define m_ZNVER (m_ZNVER1 | m_ZNVER2 | m_ZNVER3 | m_ZNVER4 | m_ZNVER5)
     184                 :             : #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER \
     185                 :             :                         | m_ZNVER)
     186                 :             : 
     187                 :             : #define m_GENERIC (HOST_WIDE_INT_1U<<PROCESSOR_GENERIC)
     188                 :             : 
     189                 :             : const char* ix86_tune_feature_names[X86_TUNE_LAST] = {
     190                 :             : #undef DEF_TUNE
     191                 :             : #define DEF_TUNE(tune, name, selector) name,
     192                 :             : #include "x86-tune.def"
     193                 :             : #undef DEF_TUNE
     194                 :             : };
     195                 :             : 
     196                 :             : /* Feature tests against the various tunings.  */
     197                 :             : unsigned char ix86_tune_features[X86_TUNE_LAST];
     198                 :             : 
     199                 :             : /* Feature tests against the various tunings used to create ix86_tune_features
     200                 :             :    based on the processor mask.  */
     201                 :             : static unsigned HOST_WIDE_INT initial_ix86_tune_features[X86_TUNE_LAST] = {
     202                 :             : #undef DEF_TUNE
     203                 :             : #define DEF_TUNE(tune, name, selector) selector,
     204                 :             : #include "x86-tune.def"
     205                 :             : #undef DEF_TUNE
     206                 :             : };
     207                 :             : 
     208                 :             : /* Feature tests against the various architecture variations.  */
     209                 :             : unsigned char ix86_arch_features[X86_ARCH_LAST];
     210                 :             : 
     211                 :             : struct ix86_target_opts
     212                 :             : {
     213                 :             :   const char *option;           /* option string */
     214                 :             :   HOST_WIDE_INT mask;           /* isa mask options */
     215                 :             : };
     216                 :             : 
     217                 :             : /* This table is ordered so that options like -msse4.2 that imply other
     218                 :             :    ISAs come first.  Target string will be displayed in the same order.  */
     219                 :             : static struct ix86_target_opts isa2_opts[] =
     220                 :             : {
     221                 :             :   { "-mcx16",         OPTION_MASK_ISA2_CX16 },
     222                 :             :   { "-mvaes",         OPTION_MASK_ISA2_VAES },
     223                 :             :   { "-mrdpid",                OPTION_MASK_ISA2_RDPID },
     224                 :             :   { "-mpconfig",      OPTION_MASK_ISA2_PCONFIG },
     225                 :             :   { "-mwbnoinvd",     OPTION_MASK_ISA2_WBNOINVD },
     226                 :             :   { "-mavx512vp2intersect", OPTION_MASK_ISA2_AVX512VP2INTERSECT },
     227                 :             :   { "-msgx",          OPTION_MASK_ISA2_SGX },
     228                 :             :   { "-mhle",          OPTION_MASK_ISA2_HLE },
     229                 :             :   { "-mmovbe",                OPTION_MASK_ISA2_MOVBE },
     230                 :             :   { "-mclzero",               OPTION_MASK_ISA2_CLZERO },
     231                 :             :   { "-mmwaitx",               OPTION_MASK_ISA2_MWAITX },
     232                 :             :   { "-mmwait",                OPTION_MASK_ISA2_MWAIT },
     233                 :             :   { "-mmovdir64b",    OPTION_MASK_ISA2_MOVDIR64B },
     234                 :             :   { "-mwaitpkg",      OPTION_MASK_ISA2_WAITPKG },
     235                 :             :   { "-mcldemote",     OPTION_MASK_ISA2_CLDEMOTE },
     236                 :             :   { "-mptwrite",      OPTION_MASK_ISA2_PTWRITE },
     237                 :             :   { "-mavx512bf16",   OPTION_MASK_ISA2_AVX512BF16 },
     238                 :             :   { "-menqcmd",               OPTION_MASK_ISA2_ENQCMD },
     239                 :             :   { "-mserialize",    OPTION_MASK_ISA2_SERIALIZE },
     240                 :             :   { "-mtsxldtrk",     OPTION_MASK_ISA2_TSXLDTRK },
     241                 :             :   { "-mamx-tile",     OPTION_MASK_ISA2_AMX_TILE },
     242                 :             :   { "-mamx-int8",     OPTION_MASK_ISA2_AMX_INT8 },
     243                 :             :   { "-mamx-bf16",     OPTION_MASK_ISA2_AMX_BF16 },
     244                 :             :   { "-muintr",                OPTION_MASK_ISA2_UINTR },
     245                 :             :   { "-mhreset",               OPTION_MASK_ISA2_HRESET },
     246                 :             :   { "-mkl",           OPTION_MASK_ISA2_KL },
     247                 :             :   { "-mwidekl",       OPTION_MASK_ISA2_WIDEKL },
     248                 :             :   { "-mavxvnni",      OPTION_MASK_ISA2_AVXVNNI },
     249                 :             :   { "-mavx512fp16",   OPTION_MASK_ISA2_AVX512FP16 },
     250                 :             :   { "-mavxifma",      OPTION_MASK_ISA2_AVXIFMA },
     251                 :             :   { "-mavxvnniint8",  OPTION_MASK_ISA2_AVXVNNIINT8 },
     252                 :             :   { "-mavxneconvert",   OPTION_MASK_ISA2_AVXNECONVERT },
     253                 :             :   { "-mcmpccxadd",      OPTION_MASK_ISA2_CMPCCXADD },
     254                 :             :   { "-mamx-fp16",       OPTION_MASK_ISA2_AMX_FP16 },
     255                 :             :   { "-mprefetchi",      OPTION_MASK_ISA2_PREFETCHI },
     256                 :             :   { "-mraoint",       OPTION_MASK_ISA2_RAOINT },
     257                 :             :   { "-mamx-complex",  OPTION_MASK_ISA2_AMX_COMPLEX },
     258                 :             :   { "-mavxvnniint16", OPTION_MASK_ISA2_AVXVNNIINT16 },
     259                 :             :   { "-msm3",          OPTION_MASK_ISA2_SM3 },
     260                 :             :   { "-msha512",               OPTION_MASK_ISA2_SHA512 },
     261                 :             :   { "-msm4",            OPTION_MASK_ISA2_SM4 },
     262                 :             :   { "-mevex512",      OPTION_MASK_ISA2_EVEX512 },
     263                 :             :   { "-musermsr",      OPTION_MASK_ISA2_USER_MSR },
     264                 :             :   { "-mavx10.1-256",  OPTION_MASK_ISA2_AVX10_1_256 },
     265                 :             :   { "-mavx10.1-512",  OPTION_MASK_ISA2_AVX10_1_512 },
     266                 :             :   { "-mavx10.2-256",  OPTION_MASK_ISA2_AVX10_2_256 },
     267                 :             :   { "-mavx10.2-512",  OPTION_MASK_ISA2_AVX10_2_512 },
     268                 :             :   { "-mamx-avx512",   OPTION_MASK_ISA2_AMX_AVX512 },
     269                 :             :   { "-mamx-tf32",     OPTION_MASK_ISA2_AMX_TF32 },
     270                 :             :   { "-mamx-transpose",        OPTION_MASK_ISA2_AMX_TRANSPOSE },
     271                 :             :   { "-mamx-fp8",      OPTION_MASK_ISA2_AMX_FP8 },
     272                 :             :   { "-mmovrs",                OPTION_MASK_ISA2_MOVRS },
     273                 :             :   { "-mamx-movrs",    OPTION_MASK_ISA2_AMX_MOVRS }
     274                 :             : };
     275                 :             : static struct ix86_target_opts isa_opts[] =
     276                 :             : {
     277                 :             :   { "-mavx512vpopcntdq", OPTION_MASK_ISA_AVX512VPOPCNTDQ },
     278                 :             :   { "-mavx512bitalg", OPTION_MASK_ISA_AVX512BITALG },
     279                 :             :   { "-mvpclmulqdq",   OPTION_MASK_ISA_VPCLMULQDQ },
     280                 :             :   { "-mgfni",         OPTION_MASK_ISA_GFNI },
     281                 :             :   { "-mavx512vnni",   OPTION_MASK_ISA_AVX512VNNI },
     282                 :             :   { "-mavx512vbmi2",  OPTION_MASK_ISA_AVX512VBMI2 },
     283                 :             :   { "-mavx512vbmi",   OPTION_MASK_ISA_AVX512VBMI },
     284                 :             :   { "-mavx512ifma",   OPTION_MASK_ISA_AVX512IFMA },
     285                 :             :   { "-mavx512vl",     OPTION_MASK_ISA_AVX512VL },
     286                 :             :   { "-mavx512bw",     OPTION_MASK_ISA_AVX512BW },
     287                 :             :   { "-mavx512dq",     OPTION_MASK_ISA_AVX512DQ },
     288                 :             :   { "-mavx512cd",     OPTION_MASK_ISA_AVX512CD },
     289                 :             :   { "-mavx512f",      OPTION_MASK_ISA_AVX512F },
     290                 :             :   { "-mavx2",         OPTION_MASK_ISA_AVX2 },
     291                 :             :   { "-mfma",          OPTION_MASK_ISA_FMA },
     292                 :             :   { "-mxop",          OPTION_MASK_ISA_XOP },
     293                 :             :   { "-mfma4",         OPTION_MASK_ISA_FMA4 },
     294                 :             :   { "-mf16c",         OPTION_MASK_ISA_F16C },
     295                 :             :   { "-mavx",          OPTION_MASK_ISA_AVX },
     296                 :             : /*{ "-msse4"          OPTION_MASK_ISA_SSE4 }, */
     297                 :             :   { "-msse4.2",               OPTION_MASK_ISA_SSE4_2 },
     298                 :             :   { "-msse4.1",               OPTION_MASK_ISA_SSE4_1 },
     299                 :             :   { "-msse4a",                OPTION_MASK_ISA_SSE4A },
     300                 :             :   { "-mssse3",                OPTION_MASK_ISA_SSSE3 },
     301                 :             :   { "-msse3",         OPTION_MASK_ISA_SSE3 },
     302                 :             :   { "-maes",          OPTION_MASK_ISA_AES },
     303                 :             :   { "-msha",          OPTION_MASK_ISA_SHA },
     304                 :             :   { "-mpclmul",               OPTION_MASK_ISA_PCLMUL },
     305                 :             :   { "-msse2",         OPTION_MASK_ISA_SSE2 },
     306                 :             :   { "-msse",          OPTION_MASK_ISA_SSE },
     307                 :             :   { "-m3dnowa",               OPTION_MASK_ISA_3DNOW_A },
     308                 :             :   { "-m3dnow",                OPTION_MASK_ISA_3DNOW },
     309                 :             :   { "-mmmx",          OPTION_MASK_ISA_MMX },
     310                 :             :   { "-mrtm",          OPTION_MASK_ISA_RTM },
     311                 :             :   { "-mprfchw",               OPTION_MASK_ISA_PRFCHW },
     312                 :             :   { "-mrdseed",               OPTION_MASK_ISA_RDSEED },
     313                 :             :   { "-madx",          OPTION_MASK_ISA_ADX },
     314                 :             :   { "-mclflushopt",   OPTION_MASK_ISA_CLFLUSHOPT },
     315                 :             :   { "-mxsaves",               OPTION_MASK_ISA_XSAVES },
     316                 :             :   { "-mxsavec",               OPTION_MASK_ISA_XSAVEC },
     317                 :             :   { "-mxsaveopt",     OPTION_MASK_ISA_XSAVEOPT },
     318                 :             :   { "-mxsave",                OPTION_MASK_ISA_XSAVE },
     319                 :             :   { "-mabm",          OPTION_MASK_ISA_ABM },
     320                 :             :   { "-mbmi",          OPTION_MASK_ISA_BMI },
     321                 :             :   { "-mbmi2",         OPTION_MASK_ISA_BMI2 },
     322                 :             :   { "-mlzcnt",                OPTION_MASK_ISA_LZCNT },
     323                 :             :   { "-mtbm",          OPTION_MASK_ISA_TBM },
     324                 :             :   { "-mpopcnt",               OPTION_MASK_ISA_POPCNT },
     325                 :             :   { "-msahf",         OPTION_MASK_ISA_SAHF },
     326                 :             :   { "-mcrc32",                OPTION_MASK_ISA_CRC32 },
     327                 :             :   { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
     328                 :             :   { "-mrdrnd",                OPTION_MASK_ISA_RDRND },
     329                 :             :   { "-mpku",          OPTION_MASK_ISA_PKU },
     330                 :             :   { "-mlwp",          OPTION_MASK_ISA_LWP },
     331                 :             :   { "-mfxsr",         OPTION_MASK_ISA_FXSR },
     332                 :             :   { "-mclwb",         OPTION_MASK_ISA_CLWB },
     333                 :             :   { "-mshstk",                OPTION_MASK_ISA_SHSTK },
     334                 :             :   { "-mmovdiri",      OPTION_MASK_ISA_MOVDIRI }
     335                 :             : };
     336                 :             : 
     337                 :             : /* Return 1 if TRAIT NAME is present in the OpenMP context's
     338                 :             :    device trait set, return 0 if not present in any OpenMP context in the
     339                 :             :    whole translation unit, or -1 if not present in the current OpenMP context
     340                 :             :    but might be present in another OpenMP context in the same TU.  */
     341                 :             : 
     342                 :             : int
     343                 :         886 : ix86_omp_device_kind_arch_isa (enum omp_device_kind_arch_isa trait,
     344                 :             :                                const char *name)
     345                 :             : {
     346                 :         886 :   switch (trait)
     347                 :             :     {
     348                 :         153 :     case omp_device_kind:
     349                 :         153 :       return strcmp (name, "cpu") == 0;
     350                 :         175 :     case omp_device_arch:
     351                 :         175 :       if (strcmp (name, "x86") == 0)
     352                 :             :         return 1;
     353                 :         175 :       if (TARGET_64BIT)
     354                 :             :         {
     355                 :         175 :           if (TARGET_X32)
     356                 :           0 :             return strcmp (name, "x32") == 0;
     357                 :             :           else
     358                 :         175 :             return strcmp (name, "x86_64") == 0;
     359                 :             :         }
     360                 :           0 :       if (strcmp (name, "ia32") == 0 || strcmp (name, "i386") == 0)
     361                 :             :         return 1;
     362                 :           0 :       if (strcmp (name, "i486") == 0)
     363                 :           0 :         return ix86_arch != PROCESSOR_I386 ? 1 : -1;
     364                 :           0 :       if (strcmp (name, "i586") == 0)
     365                 :           0 :         return (ix86_arch != PROCESSOR_I386
     366                 :           0 :                 && ix86_arch != PROCESSOR_I486) ? 1 : -1;
     367                 :           0 :       if (strcmp (name, "i686") == 0)
     368                 :           0 :         return (ix86_arch != PROCESSOR_I386
     369                 :           0 :                 && ix86_arch != PROCESSOR_I486
     370                 :           0 :                 && ix86_arch != PROCESSOR_LAKEMONT
     371                 :           0 :                 && ix86_arch != PROCESSOR_PENTIUM) ? 1 : -1;
     372                 :             :       return 0;
     373                 :             :     case omp_device_isa:
     374                 :         608 :       for (int i = 0; i < 2; i++)
     375                 :             :         {
     376                 :         583 :           struct ix86_target_opts *opts = i ? isa2_opts : isa_opts;
     377                 :         583 :           size_t nopts = i ? ARRAY_SIZE (isa2_opts) : ARRAY_SIZE (isa_opts);
     378                 :         583 :           HOST_WIDE_INT mask = i ? ix86_isa_flags2 : ix86_isa_flags;
     379                 :       10144 :           for (size_t n = 0; n < nopts; n++)
     380                 :             :             {
     381                 :             :               /* Handle sse4 as an alias to sse4.2.  */
     382                 :       10094 :               if (opts[n].mask == OPTION_MASK_ISA_SSE4_2)
     383                 :             :                 {
     384                 :         133 :                   if (strcmp (name, "sse4") == 0)
     385                 :          33 :                     return (mask & opts[n].mask) != 0 ? 1 : -1;
     386                 :             :                 }
     387                 :       10070 :               if (strcmp (name, opts[n].option + 2) == 0)
     388                 :         708 :                 return (mask & opts[n].mask) != 0 ? 1 : -1;
     389                 :             :             }
     390                 :             :         }
     391                 :             :       return 0;
     392                 :           0 :     default:
     393                 :           0 :       gcc_unreachable ();
     394                 :             :     }
     395                 :             : }
     396                 :             : 
     397                 :             : /* Return a string that documents the current -m options.  The caller is
     398                 :             :    responsible for freeing the string.  */
     399                 :             : 
     400                 :             : char *
     401                 :          23 : ix86_target_string (HOST_WIDE_INT isa, HOST_WIDE_INT isa2,
     402                 :             :                     int flags, int flags2,
     403                 :             :                     const char *arch, const char *tune,
     404                 :             :                     enum fpmath_unit fpmath,
     405                 :             :                     enum prefer_vector_width pvw,
     406                 :             :                     enum prefer_vector_width move_max,
     407                 :             :                     enum prefer_vector_width store_max,
     408                 :             :                     bool add_nl_p, bool add_abi_p)
     409                 :             : {
     410                 :             :   /* Flag options.  */
     411                 :          23 :   static struct ix86_target_opts flag_opts[] =
     412                 :             :   {
     413                 :             :     { "-m128bit-long-double",         MASK_128BIT_LONG_DOUBLE },
     414                 :             :     { "-mlong-double-128",            MASK_LONG_DOUBLE_128 },
     415                 :             :     { "-mlong-double-64",             MASK_LONG_DOUBLE_64 },
     416                 :             :     { "-m80387",                      MASK_80387 },
     417                 :             :     { "-maccumulate-outgoing-args",   MASK_ACCUMULATE_OUTGOING_ARGS },
     418                 :             :     { "-malign-double",                       MASK_ALIGN_DOUBLE },
     419                 :             :     { "-mcld",                                MASK_CLD },
     420                 :             :     { "-mfp-ret-in-387",              MASK_FLOAT_RETURNS },
     421                 :             :     { "-mieee-fp",                    MASK_IEEE_FP },
     422                 :             :     { "-minline-all-stringops",               MASK_INLINE_ALL_STRINGOPS },
     423                 :             :     { "-minline-stringops-dynamically",       MASK_INLINE_STRINGOPS_DYNAMICALLY },
     424                 :             :     { "-mms-bitfields",                       MASK_MS_BITFIELD_LAYOUT },
     425                 :             :     { "-mno-align-stringops",         MASK_NO_ALIGN_STRINGOPS },
     426                 :             :     { "-mno-fancy-math-387",          MASK_NO_FANCY_MATH_387 },
     427                 :             :     { "-mno-push-args",                       MASK_NO_PUSH_ARGS },
     428                 :             :     { "-mno-red-zone",                        MASK_NO_RED_ZONE },
     429                 :             :     { "-momit-leaf-frame-pointer",    MASK_OMIT_LEAF_FRAME_POINTER },
     430                 :             :     { "-mrecip",                      MASK_RECIP },
     431                 :             :     { "-mrtd",                                MASK_RTD },
     432                 :             :     { "-msseregparm",                 MASK_SSEREGPARM },
     433                 :             :     { "-mstack-arg-probe",            MASK_STACK_PROBE },
     434                 :             :     { "-mtls-direct-seg-refs",                MASK_TLS_DIRECT_SEG_REFS },
     435                 :             :     { "-mvect8-ret-in-mem",           MASK_VECT8_RETURNS },
     436                 :             :     { "-m8bit-idiv",                  MASK_USE_8BIT_IDIV },
     437                 :             :     { "-mvzeroupper",                 MASK_VZEROUPPER },
     438                 :             :     { "-mstv",                                MASK_STV },
     439                 :             :     { "-mavx256-split-unaligned-load",        MASK_AVX256_SPLIT_UNALIGNED_LOAD },
     440                 :             :     { "-mavx256-split-unaligned-store",       MASK_AVX256_SPLIT_UNALIGNED_STORE },
     441                 :             :     { "-mcall-ms2sysv-xlogues",               MASK_CALL_MS2SYSV_XLOGUES },
     442                 :             :     { "-mrelax-cmpxchg-loop",         MASK_RELAX_CMPXCHG_LOOP }
     443                 :             :   };
     444                 :             : 
     445                 :             :   /* Additional flag options.  */
     446                 :          23 :   static struct ix86_target_opts flag2_opts[] =
     447                 :             :   {
     448                 :             :     { "-mgeneral-regs-only",          OPTION_MASK_GENERAL_REGS_ONLY }
     449                 :             :   };
     450                 :             : 
     451                 :          23 :   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (isa2_opts)
     452                 :             :                    + ARRAY_SIZE (flag_opts) + ARRAY_SIZE (flag2_opts) + 6][2];
     453                 :             : 
     454                 :          23 :   char isa_other[40];
     455                 :          23 :   char isa2_other[40];
     456                 :          23 :   char flags_other[40];
     457                 :          23 :   char flags2_other[40];
     458                 :          23 :   unsigned num = 0;
     459                 :          23 :   unsigned i, j;
     460                 :          23 :   char *ret;
     461                 :          23 :   char *ptr;
     462                 :          23 :   size_t len;
     463                 :          23 :   size_t line_len;
     464                 :          23 :   size_t sep_len;
     465                 :          23 :   const char *abi;
     466                 :             : 
     467                 :          23 :   memset (opts, '\0', sizeof (opts));
     468                 :             : 
     469                 :             :   /* Add -march= option.  */
     470                 :          23 :   if (arch)
     471                 :             :     {
     472                 :           0 :       opts[num][0] = "-march=";
     473                 :           0 :       opts[num++][1] = arch;
     474                 :             :     }
     475                 :             : 
     476                 :             :   /* Add -mtune= option.  */
     477                 :          23 :   if (tune)
     478                 :             :     {
     479                 :           0 :       opts[num][0] = "-mtune=";
     480                 :           0 :       opts[num++][1] = tune;
     481                 :             :     }
     482                 :             : 
     483                 :             :   /* Add -m32/-m64/-mx32.  */
     484                 :          23 :   if (add_abi_p)
     485                 :             :     {
     486                 :           2 :       if ((isa & OPTION_MASK_ISA_64BIT) != 0)
     487                 :             :         {
     488                 :           2 :           if ((isa & OPTION_MASK_ABI_64) != 0)
     489                 :             :             abi = "-m64";
     490                 :             :           else
     491                 :           0 :             abi = "-mx32";
     492                 :             :         }
     493                 :             :       else
     494                 :             :         abi = "-m32";
     495                 :           2 :       opts[num++][0] = abi;
     496                 :             :     }
     497                 :          23 :   isa &= ~(OPTION_MASK_ISA_64BIT | OPTION_MASK_ABI_64 | OPTION_MASK_ABI_X32);
     498                 :             : 
     499                 :             :   /* Pick out the options in isa2 options.  */
     500                 :        1242 :   for (i = 0; i < ARRAY_SIZE (isa2_opts); i++)
     501                 :             :     {
     502                 :        1219 :       if ((isa2 & isa2_opts[i].mask) != 0)
     503                 :             :         {
     504                 :           7 :           opts[num++][0] = isa2_opts[i].option;
     505                 :           7 :           isa2 &= ~ isa2_opts[i].mask;
     506                 :             :         }
     507                 :             :     }
     508                 :             : 
     509                 :          23 :   if (isa2 && add_nl_p)
     510                 :             :     {
     511                 :           0 :       opts[num++][0] = isa2_other;
     512                 :           0 :       sprintf (isa2_other, "(other isa2: %#" HOST_WIDE_INT_PRINT "x)", isa2);
     513                 :             :     }
     514                 :             : 
     515                 :             :   /* Pick out the options in isa options.  */
     516                 :        1334 :   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
     517                 :             :     {
     518                 :        1311 :       if ((isa & isa_opts[i].mask) != 0)
     519                 :             :         {
     520                 :          36 :           opts[num++][0] = isa_opts[i].option;
     521                 :          36 :           isa &= ~ isa_opts[i].mask;
     522                 :             :         }
     523                 :             :     }
     524                 :             : 
     525                 :          23 :   if (isa && add_nl_p)
     526                 :             :     {
     527                 :           0 :       opts[num++][0] = isa_other;
     528                 :           0 :       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)", isa);
     529                 :             :     }
     530                 :             : 
     531                 :             :   /* Add flag options.  */
     532                 :         713 :   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
     533                 :             :     {
     534                 :         690 :       if ((flags & flag_opts[i].mask) != 0)
     535                 :             :         {
     536                 :           0 :           opts[num++][0] = flag_opts[i].option;
     537                 :           0 :           flags &= ~ flag_opts[i].mask;
     538                 :             :         }
     539                 :             :     }
     540                 :             : 
     541                 :          23 :   if (flags && add_nl_p)
     542                 :             :     {
     543                 :           0 :       opts[num++][0] = flags_other;
     544                 :           0 :       sprintf (flags_other, "(other flags: %#x)", flags);
     545                 :             :     }
     546                 :             : 
     547                 :             :     /* Add additional flag options.  */
     548                 :          46 :   for (i = 0; i < ARRAY_SIZE (flag2_opts); i++)
     549                 :             :     {
     550                 :          23 :       if ((flags2 & flag2_opts[i].mask) != 0)
     551                 :             :         {
     552                 :           0 :           opts[num++][0] = flag2_opts[i].option;
     553                 :           0 :           flags2 &= ~ flag2_opts[i].mask;
     554                 :             :         }
     555                 :             :     }
     556                 :             : 
     557                 :          23 :   if (flags2 && add_nl_p)
     558                 :             :     {
     559                 :           0 :       opts[num++][0] = flags2_other;
     560                 :           0 :       sprintf (flags2_other, "(other flags2: %#x)", flags2);
     561                 :             :     }
     562                 :             : 
     563                 :             :   /* Add -mfpmath= option.  */
     564                 :          23 :   if (fpmath)
     565                 :             :     {
     566                 :           0 :       opts[num][0] = "-mfpmath=";
     567                 :           0 :       switch ((int) fpmath)
     568                 :             :         {
     569                 :           0 :         case FPMATH_387:
     570                 :           0 :           opts[num++][1] = "387";
     571                 :           0 :           break;
     572                 :             : 
     573                 :           0 :         case FPMATH_SSE:
     574                 :           0 :           opts[num++][1] = "sse";
     575                 :           0 :           break;
     576                 :             : 
     577                 :           0 :         case FPMATH_387 | FPMATH_SSE:
     578                 :           0 :           opts[num++][1] = "sse+387";
     579                 :           0 :           break;
     580                 :             : 
     581                 :           0 :         default:
     582                 :           0 :           gcc_unreachable ();
     583                 :             :         }
     584                 :             :     }
     585                 :             : 
     586                 :          23 :   auto add_vector_width = [&opts, &num] (prefer_vector_width pvw,
     587                 :             :                                          const char *cmd)
     588                 :             :     {
     589                 :           0 :       opts[num][0] = cmd;
     590                 :           0 :       switch ((int) pvw)
     591                 :             :         {
     592                 :           0 :         case PVW_AVX128:
     593                 :           0 :           opts[num++][1] = "128";
     594                 :           0 :           break;
     595                 :             : 
     596                 :           0 :         case PVW_AVX256:
     597                 :           0 :           opts[num++][1] = "256";
     598                 :           0 :           break;
     599                 :             : 
     600                 :           0 :         case PVW_AVX512:
     601                 :           0 :           opts[num++][1] = "512";
     602                 :           0 :           break;
     603                 :             : 
     604                 :           0 :         default:
     605                 :           0 :           gcc_unreachable ();
     606                 :             :         }
     607                 :          23 :     };
     608                 :             : 
     609                 :             :   /* Add -mprefer-vector-width= option.  */
     610                 :          23 :   if (pvw)
     611                 :           0 :     add_vector_width (pvw, "-mprefer-vector-width=");
     612                 :             : 
     613                 :             :   /* Add -mmove-max= option.  */
     614                 :          23 :   if (move_max)
     615                 :           0 :     add_vector_width (move_max, "-mmove-max=");
     616                 :             : 
     617                 :             :   /* Add -mstore-max= option.  */
     618                 :          23 :   if (store_max)
     619                 :           0 :     add_vector_width (store_max, "-mstore-max=");
     620                 :             : 
     621                 :             :   /* Any options?  */
     622                 :          23 :   if (num == 0)
     623                 :             :     return NULL;
     624                 :             : 
     625                 :          23 :   gcc_assert (num < ARRAY_SIZE (opts));
     626                 :             : 
     627                 :             :   /* Size the string.  */
     628                 :          23 :   len = 0;
     629                 :          23 :   sep_len = (add_nl_p) ? 3 : 1;
     630                 :          68 :   for (i = 0; i < num; i++)
     631                 :             :     {
     632                 :          45 :       len += sep_len;
     633                 :         135 :       for (j = 0; j < 2; j++)
     634                 :          90 :         if (opts[i][j])
     635                 :          45 :           len += strlen (opts[i][j]);
     636                 :             :     }
     637                 :             : 
     638                 :             :   /* Build the string.  */
     639                 :          23 :   ret = ptr = (char *) xmalloc (len);
     640                 :          23 :   line_len = 0;
     641                 :             : 
     642                 :          68 :   for (i = 0; i < num; i++)
     643                 :             :     {
     644                 :             :       size_t len2[2];
     645                 :             : 
     646                 :         135 :       for (j = 0; j < 2; j++)
     647                 :          90 :         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
     648                 :             : 
     649                 :          45 :       if (i != 0)
     650                 :             :         {
     651                 :          22 :           *ptr++ = ' ';
     652                 :          22 :           line_len++;
     653                 :             : 
     654                 :          22 :           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
     655                 :             :             {
     656                 :           0 :               *ptr++ = '\\';
     657                 :           0 :               *ptr++ = '\n';
     658                 :           0 :               line_len = 0;
     659                 :             :             }
     660                 :             :         }
     661                 :             : 
     662                 :         135 :       for (j = 0; j < 2; j++)
     663                 :          90 :         if (opts[i][j])
     664                 :             :           {
     665                 :          45 :             memcpy (ptr, opts[i][j], len2[j]);
     666                 :          45 :             ptr += len2[j];
     667                 :          45 :             line_len += len2[j];
     668                 :             :           }
     669                 :             :     }
     670                 :             : 
     671                 :          23 :   *ptr = '\0';
     672                 :          23 :   gcc_assert (ret + len >= ptr);
     673                 :             : 
     674                 :             :   return ret;
     675                 :             : }
     676                 :             : 
     677                 :             : /* Function that is callable from the debugger to print the current
     678                 :             :    options.  */
     679                 :             : void ATTRIBUTE_UNUSED
     680                 :           0 : ix86_debug_options (void)
     681                 :             : {
     682                 :           0 :   char *opts = ix86_target_string (ix86_isa_flags, ix86_isa_flags2,
     683                 :             :                                    target_flags, ix86_target_flags,
     684                 :             :                                    ix86_arch_string, ix86_tune_string,
     685                 :             :                                    ix86_fpmath, prefer_vector_width_type,
     686                 :             :                                    ix86_move_max, ix86_store_max,
     687                 :             :                                    true, true);
     688                 :             : 
     689                 :           0 :   if (opts)
     690                 :             :     {
     691                 :           0 :       fprintf (stderr, "%s\n\n", opts);
     692                 :           0 :       free (opts);
     693                 :             :     }
     694                 :             :   else
     695                 :           0 :     fputs ("<no options>\n\n", stderr);
     696                 :             : 
     697                 :           0 :   return;
     698                 :             : }
     699                 :             : 
     700                 :             : /* Save the current options */
     701                 :             : 
     702                 :             : void
     703                 :    87703405 : ix86_function_specific_save (struct cl_target_option *ptr,
     704                 :             :                              struct gcc_options *opts,
     705                 :             :                              struct gcc_options */* opts_set */)
     706                 :             : {
     707                 :    87703405 :   ptr->arch = ix86_arch;
     708                 :    87703405 :   ptr->schedule = ix86_schedule;
     709                 :    87703405 :   ptr->prefetch_sse = ix86_prefetch_sse;
     710                 :    87703405 :   ptr->tune = ix86_tune;
     711                 :    87703405 :   ptr->branch_cost = ix86_branch_cost;
     712                 :    87703405 :   ptr->tune_defaulted = ix86_tune_defaulted;
     713                 :    87703405 :   ptr->arch_specified = ix86_arch_specified;
     714                 :    87703405 :   ptr->x_ix86_apx_features = opts->x_ix86_apx_features;
     715                 :    87703405 :   ptr->x_ix86_isa_flags_explicit = opts->x_ix86_isa_flags_explicit;
     716                 :    87703405 :   ptr->x_ix86_isa_flags2_explicit = opts->x_ix86_isa_flags2_explicit;
     717                 :    87703405 :   ptr->x_ix86_no_avx512_explicit = opts->x_ix86_no_avx512_explicit;
     718                 :    87703405 :   ptr->x_ix86_no_avx10_1_explicit = opts->x_ix86_no_avx10_1_explicit;
     719                 :    87703405 :   ptr->x_recip_mask_explicit = opts->x_recip_mask_explicit;
     720                 :    87703405 :   ptr->x_ix86_arch_string = opts->x_ix86_arch_string;
     721                 :    87703405 :   ptr->x_ix86_tune_string = opts->x_ix86_tune_string;
     722                 :    87703405 :   ptr->x_ix86_asm_dialect = opts->x_ix86_asm_dialect;
     723                 :    87703405 :   ptr->x_ix86_branch_cost = opts->x_ix86_branch_cost;
     724                 :    87703405 :   ptr->x_ix86_dump_tunes = opts->x_ix86_dump_tunes;
     725                 :    87703405 :   ptr->x_ix86_force_align_arg_pointer = opts->x_ix86_force_align_arg_pointer;
     726                 :    87703405 :   ptr->x_ix86_force_drap = opts->x_ix86_force_drap;
     727                 :    87703405 :   ptr->x_ix86_recip_name = opts->x_ix86_recip_name;
     728                 :    87703405 :   ptr->x_ix86_section_threshold = opts->x_ix86_section_threshold;
     729                 :    87703405 :   ptr->x_ix86_sse2avx = opts->x_ix86_sse2avx;
     730                 :    87703405 :   ptr->x_ix86_stack_protector_guard = opts->x_ix86_stack_protector_guard;
     731                 :    87703405 :   ptr->x_ix86_stringop_alg = opts->x_ix86_stringop_alg;
     732                 :    87703405 :   ptr->x_ix86_tls_dialect = opts->x_ix86_tls_dialect;
     733                 :    87703405 :   ptr->x_ix86_tune_ctrl_string = opts->x_ix86_tune_ctrl_string;
     734                 :    87703405 :   ptr->x_ix86_tune_memcpy_strategy = opts->x_ix86_tune_memcpy_strategy;
     735                 :    87703405 :   ptr->x_ix86_tune_memset_strategy = opts->x_ix86_tune_memset_strategy;
     736                 :    87703405 :   ptr->x_ix86_tune_no_default = opts->x_ix86_tune_no_default;
     737                 :             : 
     738                 :             :   /* The fields are char but the variables are not; make sure the
     739                 :             :      values fit in the fields.  */
     740                 :    87703405 :   gcc_assert (ptr->arch == ix86_arch);
     741                 :    87703405 :   gcc_assert (ptr->schedule == ix86_schedule);
     742                 :    87703405 :   gcc_assert (ptr->tune == ix86_tune);
     743                 :    87703405 :   gcc_assert (ptr->branch_cost == ix86_branch_cost);
     744                 :    87703405 : }
     745                 :             : 
     746                 :             : /* Feature tests against the various architecture variations, used to create
     747                 :             :    ix86_arch_features based on the processor mask.  */
     748                 :             : static unsigned HOST_WIDE_INT initial_ix86_arch_features[X86_ARCH_LAST] = {
     749                 :             :   /* X86_ARCH_CMOV: Conditional move was added for pentiumpro.  */
     750                 :             :   ~(m_386 | m_486 | m_PENT | m_LAKEMONT | m_K6),
     751                 :             : 
     752                 :             :   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
     753                 :             :   ~m_386,
     754                 :             : 
     755                 :             :   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
     756                 :             :   ~(m_386 | m_486),
     757                 :             : 
     758                 :             :   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
     759                 :             :   ~m_386,
     760                 :             : 
     761                 :             :   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
     762                 :             :   ~m_386,
     763                 :             : };
     764                 :             : 
     765                 :             : /* This table must be in sync with enum processor_type in i386.h.  */
     766                 :             : static const struct processor_costs *processor_cost_table[] =
     767                 :             : {
     768                 :             :   &generic_cost,
     769                 :             :   &i386_cost,
     770                 :             :   &i486_cost,
     771                 :             :   &pentium_cost,
     772                 :             :   &lakemont_cost,
     773                 :             :   &pentiumpro_cost,
     774                 :             :   &pentium4_cost,
     775                 :             :   &nocona_cost,
     776                 :             :   &core_cost,
     777                 :             :   &core_cost,
     778                 :             :   &core_cost,
     779                 :             :   &core_cost,
     780                 :             :   &atom_cost,
     781                 :             :   &slm_cost,
     782                 :             :   &slm_cost,
     783                 :             :   &slm_cost,
     784                 :             :   &tremont_cost,
     785                 :             :   &alderlake_cost,
     786                 :             :   &alderlake_cost,
     787                 :             :   &alderlake_cost,
     788                 :             :   &skylake_cost,
     789                 :             :   &skylake_cost,
     790                 :             :   &icelake_cost,
     791                 :             :   &icelake_cost,
     792                 :             :   &icelake_cost,
     793                 :             :   &skylake_cost,
     794                 :             :   &icelake_cost,
     795                 :             :   &skylake_cost,
     796                 :             :   &icelake_cost,
     797                 :             :   &alderlake_cost,
     798                 :             :   &icelake_cost,
     799                 :             :   &icelake_cost,
     800                 :             :   &icelake_cost,
     801                 :             :   &alderlake_cost,
     802                 :             :   &alderlake_cost,
     803                 :             :   &alderlake_cost,
     804                 :             :   &icelake_cost,
     805                 :             :   &intel_cost,
     806                 :             :   &lujiazui_cost,
     807                 :             :   &yongfeng_cost,
     808                 :             :   &shijidadao_cost,
     809                 :             :   &geode_cost,
     810                 :             :   &k6_cost,
     811                 :             :   &athlon_cost,
     812                 :             :   &k8_cost,
     813                 :             :   &amdfam10_cost,
     814                 :             :   &bdver_cost,
     815                 :             :   &bdver_cost,
     816                 :             :   &bdver_cost,
     817                 :             :   &bdver_cost,
     818                 :             :   &btver1_cost,
     819                 :             :   &btver2_cost,
     820                 :             :   &znver1_cost,
     821                 :             :   &znver2_cost,
     822                 :             :   &znver3_cost,
     823                 :             :   &znver4_cost,
     824                 :             :   &znver5_cost
     825                 :             : };
     826                 :             : 
     827                 :             : /* Guarantee that the array is aligned with enum processor_type.  */
     828                 :             : STATIC_ASSERT (ARRAY_SIZE (processor_cost_table) == PROCESSOR_max);
     829                 :             : 
     830                 :             : static bool
     831                 :             : ix86_option_override_internal (bool main_args_p,
     832                 :             :                                struct gcc_options *opts,
     833                 :             :                                struct gcc_options *opts_set);
     834                 :             : static void
     835                 :             : set_ix86_tune_features (struct gcc_options *opts,
     836                 :             :                         enum processor_type ix86_tune, bool dump);
     837                 :             : 
     838                 :             : /* Restore the current options */
     839                 :             : 
     840                 :             : void
     841                 :    66046796 : ix86_function_specific_restore (struct gcc_options *opts,
     842                 :             :                                 struct gcc_options */* opts_set */,
     843                 :             :                                 struct cl_target_option *ptr)
     844                 :             : {
     845                 :    66046796 :   enum processor_type old_tune = ix86_tune;
     846                 :    66046796 :   enum processor_type old_arch = ix86_arch;
     847                 :    66046796 :   unsigned HOST_WIDE_INT ix86_arch_mask;
     848                 :    66046796 :   int i;
     849                 :             : 
     850                 :             :   /* We don't change -fPIC.  */
     851                 :    66046796 :   opts->x_flag_pic = flag_pic;
     852                 :             : 
     853                 :    66046796 :   ix86_arch = (enum processor_type) ptr->arch;
     854                 :    66046796 :   ix86_schedule = (enum attr_cpu) ptr->schedule;
     855                 :    66046796 :   ix86_tune = (enum processor_type) ptr->tune;
     856                 :    66046796 :   ix86_prefetch_sse = ptr->prefetch_sse;
     857                 :    66046796 :   ix86_tune_defaulted = ptr->tune_defaulted;
     858                 :    66046796 :   ix86_arch_specified = ptr->arch_specified;
     859                 :    66046796 :   opts->x_ix86_apx_features = ptr->x_ix86_apx_features;
     860                 :    66046796 :   opts->x_ix86_isa_flags_explicit = ptr->x_ix86_isa_flags_explicit;
     861                 :    66046796 :   opts->x_ix86_isa_flags2_explicit = ptr->x_ix86_isa_flags2_explicit;
     862                 :    66046796 :   opts->x_ix86_no_avx512_explicit = ptr->x_ix86_no_avx512_explicit;
     863                 :    66046796 :   opts->x_ix86_no_avx10_1_explicit = ptr->x_ix86_no_avx10_1_explicit;
     864                 :    66046796 :   opts->x_recip_mask_explicit = ptr->x_recip_mask_explicit;
     865                 :    66046796 :   opts->x_ix86_arch_string = ptr->x_ix86_arch_string;
     866                 :    66046796 :   opts->x_ix86_tune_string = ptr->x_ix86_tune_string;
     867                 :    66046796 :   opts->x_ix86_asm_dialect = ptr->x_ix86_asm_dialect;
     868                 :    66046796 :   opts->x_ix86_branch_cost = ptr->x_ix86_branch_cost;
     869                 :    66046796 :   opts->x_ix86_dump_tunes = ptr->x_ix86_dump_tunes;
     870                 :    66046796 :   opts->x_ix86_force_align_arg_pointer = ptr->x_ix86_force_align_arg_pointer;
     871                 :    66046796 :   opts->x_ix86_force_drap = ptr->x_ix86_force_drap;
     872                 :    66046796 :   opts->x_ix86_recip_name = ptr->x_ix86_recip_name;
     873                 :    66046796 :   opts->x_ix86_section_threshold = ptr->x_ix86_section_threshold;
     874                 :    66046796 :   opts->x_ix86_sse2avx = ptr->x_ix86_sse2avx;
     875                 :    66046796 :   opts->x_ix86_stack_protector_guard = ptr->x_ix86_stack_protector_guard;
     876                 :    66046796 :   opts->x_ix86_stringop_alg = ptr->x_ix86_stringop_alg;
     877                 :    66046796 :   opts->x_ix86_tls_dialect = ptr->x_ix86_tls_dialect;
     878                 :    66046796 :   opts->x_ix86_tune_ctrl_string = ptr->x_ix86_tune_ctrl_string;
     879                 :    66046796 :   opts->x_ix86_tune_memcpy_strategy = ptr->x_ix86_tune_memcpy_strategy;
     880                 :    66046796 :   opts->x_ix86_tune_memset_strategy = ptr->x_ix86_tune_memset_strategy;
     881                 :    66046796 :   opts->x_ix86_tune_no_default = ptr->x_ix86_tune_no_default;
     882                 :    66046796 :   ix86_tune_cost = processor_cost_table[ix86_tune];
     883                 :             :   /* TODO: ix86_cost should be chosen at instruction or function granuality
     884                 :             :      so for cold code we use size_cost even in !optimize_size compilation.  */
     885                 :    66046796 :   if (opts->x_optimize_size)
     886                 :      829386 :     ix86_cost = &ix86_size_cost;
     887                 :             :   else
     888                 :    65217410 :     ix86_cost = ix86_tune_cost;
     889                 :             : 
     890                 :             :   /* Recreate the arch feature tests if the arch changed */
     891                 :    66046796 :   if (old_arch != ix86_arch)
     892                 :             :     {
     893                 :       28644 :       ix86_arch_mask = HOST_WIDE_INT_1U << ix86_arch;
     894                 :      171864 :       for (i = 0; i < X86_ARCH_LAST; ++i)
     895                 :      143220 :         ix86_arch_features[i]
     896                 :      143220 :           = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
     897                 :             :     }
     898                 :             : 
     899                 :             :   /* Recreate the tune optimization tests */
     900                 :    66046796 :   if (old_tune != ix86_tune)
     901                 :       28882 :     set_ix86_tune_features (opts, ix86_tune, false);
     902                 :    66046796 : }
     903                 :             : 
     904                 :             : /* Adjust target options after streaming them in.  This is mainly about
     905                 :             :    reconciling them with global options.  */
     906                 :             : 
     907                 :             : void
     908                 :       23578 : ix86_function_specific_post_stream_in (struct cl_target_option *ptr)
     909                 :             : {
     910                 :             :   /* flag_pic is a global option, but ix86_cmodel is target saved option
     911                 :             :      partly computed from flag_pic.  If flag_pic is on, adjust x_ix86_cmodel
     912                 :             :      for PIC, or error out.  */
     913                 :       23578 :   if (flag_pic)
     914                 :         324 :     switch (ptr->x_ix86_cmodel)
     915                 :             :       {
     916                 :          89 :       case CM_SMALL:
     917                 :          89 :         ptr->x_ix86_cmodel = CM_SMALL_PIC;
     918                 :          89 :         break;
     919                 :             : 
     920                 :           0 :       case CM_MEDIUM:
     921                 :           0 :         ptr->x_ix86_cmodel = CM_MEDIUM_PIC;
     922                 :           0 :         break;
     923                 :             : 
     924                 :           0 :       case CM_LARGE:
     925                 :           0 :         ptr->x_ix86_cmodel = CM_LARGE_PIC;
     926                 :           0 :         break;
     927                 :             : 
     928                 :           0 :       case CM_KERNEL:
     929                 :           0 :         error ("code model %s does not support PIC mode", "kernel");
     930                 :           0 :         break;
     931                 :             : 
     932                 :             :       default:
     933                 :             :         break;
     934                 :             :       }
     935                 :             :   else
     936                 :       23254 :     switch (ptr->x_ix86_cmodel)
     937                 :             :       {
     938                 :          98 :       case CM_SMALL_PIC:
     939                 :          98 :         ptr->x_ix86_cmodel = CM_SMALL;
     940                 :          98 :         break;
     941                 :             : 
     942                 :           0 :       case CM_MEDIUM_PIC:
     943                 :           0 :         ptr->x_ix86_cmodel = CM_MEDIUM;
     944                 :           0 :         break;
     945                 :             : 
     946                 :           0 :       case CM_LARGE_PIC:
     947                 :           0 :         ptr->x_ix86_cmodel = CM_LARGE;
     948                 :           0 :         break;
     949                 :             : 
     950                 :             :       default:
     951                 :             :         break;
     952                 :             :       }
     953                 :       23578 : }
     954                 :             : 
     955                 :             : /* Print the current options */
     956                 :             : 
     957                 :             : void
     958                 :           0 : ix86_function_specific_print (FILE *file, int indent,
     959                 :             :                               struct cl_target_option *ptr)
     960                 :             : {
     961                 :           0 :   char *target_string
     962                 :           0 :     = ix86_target_string (ptr->x_ix86_isa_flags, ptr->x_ix86_isa_flags2,
     963                 :             :                           ptr->x_target_flags, ptr->x_ix86_target_flags,
     964                 :             :                           NULL, NULL, ptr->x_ix86_fpmath,
     965                 :             :                           ptr->x_prefer_vector_width_type,
     966                 :             :                           ptr->x_ix86_move_max, ptr->x_ix86_store_max,
     967                 :             :                           false, true);
     968                 :             : 
     969                 :           0 :   gcc_assert (ptr->arch < PROCESSOR_max);
     970                 :           0 :   fprintf (file, "%*sarch = %d (%s)\n",
     971                 :             :            indent, "",
     972                 :           0 :            ptr->arch, processor_names[ptr->arch]);
     973                 :             : 
     974                 :           0 :   gcc_assert (ptr->tune < PROCESSOR_max);
     975                 :           0 :   fprintf (file, "%*stune = %d (%s)\n",
     976                 :             :            indent, "",
     977                 :           0 :            ptr->tune, processor_names[ptr->tune]);
     978                 :             : 
     979                 :           0 :   fprintf (file, "%*sbranch_cost = %d\n", indent, "", ptr->branch_cost);
     980                 :             : 
     981                 :           0 :   if (target_string)
     982                 :             :     {
     983                 :           0 :       fprintf (file, "%*s%s\n", indent, "", target_string);
     984                 :           0 :       free (target_string);
     985                 :             :     }
     986                 :           0 : }
     987                 :             : 
     988                 :             : 
     989                 :             : /* Inner function to process the attribute((target(...))), take an argument and
     990                 :             :    set the current options from the argument. If we have a list, recursively go
     991                 :             :    over the list.  */
     992                 :             : 
     993                 :             : static bool
     994                 :   114551184 : ix86_valid_target_attribute_inner_p (tree fndecl, tree args, char *p_strings[],
     995                 :             :                                      struct gcc_options *opts,
     996                 :             :                                      struct gcc_options *opts_set,
     997                 :             :                                      struct gcc_options *enum_opts_set,
     998                 :             :                                      bool target_clone_attr)
     999                 :             : {
    1000                 :   114551184 :   char *next_optstr;
    1001                 :   114551184 :   bool ret = true;
    1002                 :             : 
    1003                 :             : #define IX86_ATTR_ISA(S,O)   { S, sizeof (S)-1, ix86_opt_isa, O, 0 }
    1004                 :             : #define IX86_ATTR_STR(S,O)   { S, sizeof (S)-1, ix86_opt_str, O, 0 }
    1005                 :             : #define IX86_ATTR_ENUM(S,O)  { S, sizeof (S)-1, ix86_opt_enum, O, 0 }
    1006                 :             : #define IX86_ATTR_YES(S,O,M) { S, sizeof (S)-1, ix86_opt_yes, O, M }
    1007                 :             : #define IX86_ATTR_NO(S,O,M)  { S, sizeof (S)-1, ix86_opt_no,  O, M }
    1008                 :             : #define IX86_ATTR_IX86_YES(S,O,M) \
    1009                 :             :   { S, sizeof (S)-1, ix86_opt_ix86_yes, O, M }
    1010                 :             : #define IX86_ATTR_IX86_NO(S,O,M) \
    1011                 :             :   { S, sizeof (S)-1, ix86_opt_ix86_no,  O, M }
    1012                 :             : 
    1013                 :   114551184 :   enum ix86_opt_type
    1014                 :             :   {
    1015                 :             :     ix86_opt_unknown,
    1016                 :             :     ix86_opt_yes,
    1017                 :             :     ix86_opt_no,
    1018                 :             :     ix86_opt_ix86_yes,
    1019                 :             :     ix86_opt_ix86_no,
    1020                 :             :     ix86_opt_str,
    1021                 :             :     ix86_opt_enum,
    1022                 :             :     ix86_opt_isa
    1023                 :             :   };
    1024                 :             : 
    1025                 :   114551184 :   static const struct
    1026                 :             :   {
    1027                 :             :     const char *string;
    1028                 :             :     size_t len;
    1029                 :             :     enum ix86_opt_type type;
    1030                 :             :     int opt;
    1031                 :             :     int mask;
    1032                 :             :   } attrs[] = {
    1033                 :             :     /* isa options */
    1034                 :             :     IX86_ATTR_ISA ("pconfig", OPT_mpconfig),
    1035                 :             :     IX86_ATTR_ISA ("wbnoinvd",        OPT_mwbnoinvd),
    1036                 :             :     IX86_ATTR_ISA ("sgx",     OPT_msgx),
    1037                 :             :     IX86_ATTR_ISA ("avx512vpopcntdq", OPT_mavx512vpopcntdq),
    1038                 :             :     IX86_ATTR_ISA ("avx512vbmi2", OPT_mavx512vbmi2),
    1039                 :             :     IX86_ATTR_ISA ("avx512vnni", OPT_mavx512vnni),
    1040                 :             :     IX86_ATTR_ISA ("avx512bitalg", OPT_mavx512bitalg),
    1041                 :             :     IX86_ATTR_ISA ("avx512vp2intersect", OPT_mavx512vp2intersect),
    1042                 :             : 
    1043                 :             :     IX86_ATTR_ISA ("avx512vbmi", OPT_mavx512vbmi),
    1044                 :             :     IX86_ATTR_ISA ("avx512ifma", OPT_mavx512ifma),
    1045                 :             :     IX86_ATTR_ISA ("avx512vl",        OPT_mavx512vl),
    1046                 :             :     IX86_ATTR_ISA ("avx512bw",        OPT_mavx512bw),
    1047                 :             :     IX86_ATTR_ISA ("avx512dq",        OPT_mavx512dq),
    1048                 :             :     IX86_ATTR_ISA ("avx512cd",        OPT_mavx512cd),
    1049                 :             :     IX86_ATTR_ISA ("avx512f", OPT_mavx512f),
    1050                 :             :     IX86_ATTR_ISA ("avx2",    OPT_mavx2),
    1051                 :             :     IX86_ATTR_ISA ("fma",     OPT_mfma),
    1052                 :             :     IX86_ATTR_ISA ("xop",     OPT_mxop),
    1053                 :             :     IX86_ATTR_ISA ("fma4",    OPT_mfma4),
    1054                 :             :     IX86_ATTR_ISA ("f16c",    OPT_mf16c),
    1055                 :             :     IX86_ATTR_ISA ("avx",     OPT_mavx),
    1056                 :             :     IX86_ATTR_ISA ("sse4",    OPT_msse4),
    1057                 :             :     IX86_ATTR_ISA ("sse4.2",  OPT_msse4_2),
    1058                 :             :     IX86_ATTR_ISA ("sse4.1",  OPT_msse4_1),
    1059                 :             :     IX86_ATTR_ISA ("sse4a",   OPT_msse4a),
    1060                 :             :     IX86_ATTR_ISA ("ssse3",   OPT_mssse3),
    1061                 :             :     IX86_ATTR_ISA ("sse3",    OPT_msse3),
    1062                 :             :     IX86_ATTR_ISA ("aes",     OPT_maes),
    1063                 :             :     IX86_ATTR_ISA ("sha",     OPT_msha),
    1064                 :             :     IX86_ATTR_ISA ("pclmul",  OPT_mpclmul),
    1065                 :             :     IX86_ATTR_ISA ("sse2",    OPT_msse2),
    1066                 :             :     IX86_ATTR_ISA ("sse",     OPT_msse),
    1067                 :             :     IX86_ATTR_ISA ("3dnowa",  OPT_m3dnowa),
    1068                 :             :     IX86_ATTR_ISA ("3dnow",   OPT_m3dnow),
    1069                 :             :     IX86_ATTR_ISA ("mmx",     OPT_mmmx),
    1070                 :             :     IX86_ATTR_ISA ("rtm",     OPT_mrtm),
    1071                 :             :     IX86_ATTR_ISA ("prfchw",  OPT_mprfchw),
    1072                 :             :     IX86_ATTR_ISA ("rdseed",  OPT_mrdseed),
    1073                 :             :     IX86_ATTR_ISA ("adx",     OPT_madx),
    1074                 :             :     IX86_ATTR_ISA ("clflushopt", OPT_mclflushopt),
    1075                 :             :     IX86_ATTR_ISA ("xsaves",  OPT_mxsaves),
    1076                 :             :     IX86_ATTR_ISA ("xsavec",  OPT_mxsavec),
    1077                 :             :     IX86_ATTR_ISA ("xsaveopt",        OPT_mxsaveopt),
    1078                 :             :     IX86_ATTR_ISA ("xsave",   OPT_mxsave),
    1079                 :             :     IX86_ATTR_ISA ("abm",     OPT_mabm),
    1080                 :             :     IX86_ATTR_ISA ("bmi",     OPT_mbmi),
    1081                 :             :     IX86_ATTR_ISA ("bmi2",    OPT_mbmi2),
    1082                 :             :     IX86_ATTR_ISA ("lzcnt",   OPT_mlzcnt),
    1083                 :             :     IX86_ATTR_ISA ("tbm",     OPT_mtbm),
    1084                 :             :     IX86_ATTR_ISA ("popcnt",  OPT_mpopcnt),
    1085                 :             :     IX86_ATTR_ISA ("cx16",    OPT_mcx16),
    1086                 :             :     IX86_ATTR_ISA ("sahf",    OPT_msahf),
    1087                 :             :     IX86_ATTR_ISA ("movbe",   OPT_mmovbe),
    1088                 :             :     IX86_ATTR_ISA ("crc32",   OPT_mcrc32),
    1089                 :             :     IX86_ATTR_ISA ("fsgsbase",        OPT_mfsgsbase),
    1090                 :             :     IX86_ATTR_ISA ("rdrnd",   OPT_mrdrnd),
    1091                 :             :     IX86_ATTR_ISA ("mwaitx",  OPT_mmwaitx),
    1092                 :             :     IX86_ATTR_ISA ("mwait",   OPT_mmwait),
    1093                 :             :     IX86_ATTR_ISA ("clzero",  OPT_mclzero),
    1094                 :             :     IX86_ATTR_ISA ("pku",     OPT_mpku),
    1095                 :             :     IX86_ATTR_ISA ("lwp",     OPT_mlwp),
    1096                 :             :     IX86_ATTR_ISA ("hle",     OPT_mhle),
    1097                 :             :     IX86_ATTR_ISA ("fxsr",    OPT_mfxsr),
    1098                 :             :     IX86_ATTR_ISA ("clwb",    OPT_mclwb),
    1099                 :             :     IX86_ATTR_ISA ("rdpid",   OPT_mrdpid),
    1100                 :             :     IX86_ATTR_ISA ("gfni",    OPT_mgfni),
    1101                 :             :     IX86_ATTR_ISA ("shstk",   OPT_mshstk),
    1102                 :             :     IX86_ATTR_ISA ("vaes",    OPT_mvaes),
    1103                 :             :     IX86_ATTR_ISA ("vpclmulqdq", OPT_mvpclmulqdq),
    1104                 :             :     IX86_ATTR_ISA ("movdiri", OPT_mmovdiri),
    1105                 :             :     IX86_ATTR_ISA ("movdir64b", OPT_mmovdir64b),
    1106                 :             :     IX86_ATTR_ISA ("waitpkg", OPT_mwaitpkg),
    1107                 :             :     IX86_ATTR_ISA ("cldemote", OPT_mcldemote),
    1108                 :             :     IX86_ATTR_ISA ("uintr", OPT_muintr),
    1109                 :             :     IX86_ATTR_ISA ("ptwrite",   OPT_mptwrite),
    1110                 :             :     IX86_ATTR_ISA ("kl", OPT_mkl),
    1111                 :             :     IX86_ATTR_ISA ("widekl",  OPT_mwidekl),
    1112                 :             :     IX86_ATTR_ISA ("avx512bf16",   OPT_mavx512bf16),
    1113                 :             :     IX86_ATTR_ISA ("enqcmd", OPT_menqcmd),
    1114                 :             :     IX86_ATTR_ISA ("serialize", OPT_mserialize),
    1115                 :             :     IX86_ATTR_ISA ("tsxldtrk", OPT_mtsxldtrk),
    1116                 :             :     IX86_ATTR_ISA ("amx-tile", OPT_mamx_tile),
    1117                 :             :     IX86_ATTR_ISA ("amx-int8", OPT_mamx_int8),
    1118                 :             :     IX86_ATTR_ISA ("amx-bf16", OPT_mamx_bf16),
    1119                 :             :     IX86_ATTR_ISA ("hreset", OPT_mhreset),
    1120                 :             :     IX86_ATTR_ISA ("avxvnni",   OPT_mavxvnni),
    1121                 :             :     IX86_ATTR_ISA ("avx512fp16", OPT_mavx512fp16),
    1122                 :             :     IX86_ATTR_ISA ("avxifma", OPT_mavxifma),
    1123                 :             :     IX86_ATTR_ISA ("avxvnniint8", OPT_mavxvnniint8),
    1124                 :             :     IX86_ATTR_ISA ("avxneconvert", OPT_mavxneconvert),
    1125                 :             :     IX86_ATTR_ISA ("cmpccxadd",   OPT_mcmpccxadd),
    1126                 :             :     IX86_ATTR_ISA ("amx-fp16", OPT_mamx_fp16),
    1127                 :             :     IX86_ATTR_ISA ("prefetchi",   OPT_mprefetchi),
    1128                 :             :     IX86_ATTR_ISA ("raoint", OPT_mraoint),
    1129                 :             :     IX86_ATTR_ISA ("amx-complex", OPT_mamx_complex),
    1130                 :             :     IX86_ATTR_ISA ("avxvnniint16", OPT_mavxvnniint16),
    1131                 :             :     IX86_ATTR_ISA ("sm3", OPT_msm3),
    1132                 :             :     IX86_ATTR_ISA ("sha512", OPT_msha512),
    1133                 :             :     IX86_ATTR_ISA ("sm4", OPT_msm4),
    1134                 :             :     IX86_ATTR_ISA ("apxf", OPT_mapxf),
    1135                 :             :     IX86_ATTR_ISA ("evex512", OPT_mevex512),
    1136                 :             :     IX86_ATTR_ISA ("usermsr", OPT_musermsr),
    1137                 :             :     IX86_ATTR_ISA ("avx10.1", OPT_mavx10_1_256),
    1138                 :             :     IX86_ATTR_ISA ("avx10.1-256", OPT_mavx10_1_256),
    1139                 :             :     IX86_ATTR_ISA ("avx10.1-512", OPT_mavx10_1_512),
    1140                 :             :     IX86_ATTR_ISA ("avx10.2", OPT_mavx10_2_256),
    1141                 :             :     IX86_ATTR_ISA ("avx10.2-256", OPT_mavx10_2_256),
    1142                 :             :     IX86_ATTR_ISA ("avx10.2-512", OPT_mavx10_2_512),
    1143                 :             :     IX86_ATTR_ISA ("amx-avx512", OPT_mamx_avx512),
    1144                 :             :     IX86_ATTR_ISA ("amx-tf32", OPT_mamx_tf32),
    1145                 :             :     IX86_ATTR_ISA ("amx-transpose", OPT_mamx_transpose),
    1146                 :             :     IX86_ATTR_ISA ("amx-fp8", OPT_mamx_fp8),
    1147                 :             :     IX86_ATTR_ISA ("movrs", OPT_mmovrs),
    1148                 :             :     IX86_ATTR_ISA ("amx-movrs", OPT_mamx_movrs),
    1149                 :             : 
    1150                 :             :     /* enum options */
    1151                 :             :     IX86_ATTR_ENUM ("fpmath=",        OPT_mfpmath_),
    1152                 :             :     IX86_ATTR_ENUM ("prefer-vector-width=", OPT_mprefer_vector_width_),
    1153                 :             : 
    1154                 :             :     /* string options */
    1155                 :             :     IX86_ATTR_STR ("arch=",   IX86_FUNCTION_SPECIFIC_ARCH),
    1156                 :             :     IX86_ATTR_STR ("tune=",   IX86_FUNCTION_SPECIFIC_TUNE),
    1157                 :             : 
    1158                 :             :     /* flag options */
    1159                 :             :     IX86_ATTR_YES ("cld",
    1160                 :             :                    OPT_mcld,
    1161                 :             :                    MASK_CLD),
    1162                 :             : 
    1163                 :             :     IX86_ATTR_NO ("fancy-math-387",
    1164                 :             :                   OPT_mfancy_math_387,
    1165                 :             :                   MASK_NO_FANCY_MATH_387),
    1166                 :             : 
    1167                 :             :     IX86_ATTR_YES ("ieee-fp",
    1168                 :             :                    OPT_mieee_fp,
    1169                 :             :                    MASK_IEEE_FP),
    1170                 :             : 
    1171                 :             :     IX86_ATTR_YES ("inline-all-stringops",
    1172                 :             :                    OPT_minline_all_stringops,
    1173                 :             :                    MASK_INLINE_ALL_STRINGOPS),
    1174                 :             : 
    1175                 :             :     IX86_ATTR_YES ("inline-stringops-dynamically",
    1176                 :             :                    OPT_minline_stringops_dynamically,
    1177                 :             :                    MASK_INLINE_STRINGOPS_DYNAMICALLY),
    1178                 :             : 
    1179                 :             :     IX86_ATTR_NO ("align-stringops",
    1180                 :             :                   OPT_mno_align_stringops,
    1181                 :             :                   MASK_NO_ALIGN_STRINGOPS),
    1182                 :             : 
    1183                 :             :     IX86_ATTR_YES ("recip",
    1184                 :             :                    OPT_mrecip,
    1185                 :             :                    MASK_RECIP),
    1186                 :             : 
    1187                 :             :     IX86_ATTR_IX86_YES ("general-regs-only",
    1188                 :             :                         OPT_mgeneral_regs_only,
    1189                 :             :                         OPTION_MASK_GENERAL_REGS_ONLY),
    1190                 :             : 
    1191                 :             :     IX86_ATTR_YES ("relax-cmpxchg-loop",
    1192                 :             :                    OPT_mrelax_cmpxchg_loop,
    1193                 :             :                    MASK_RELAX_CMPXCHG_LOOP),
    1194                 :             :   };
    1195                 :             : 
    1196                 :   114551184 :   location_t loc
    1197                 :   114551184 :     = fndecl == NULL ? UNKNOWN_LOCATION : DECL_SOURCE_LOCATION (fndecl);
    1198                 :   114551184 :   const char *attr_name = target_clone_attr ? "target_clone" : "target";
    1199                 :             : 
    1200                 :             :   /* If this is a list, recurse to get the options.  */
    1201                 :   114551184 :   if (TREE_CODE (args) == TREE_LIST)
    1202                 :             :     {
    1203                 :   114550281 :       for (; args; args = TREE_CHAIN (args))
    1204                 :    58071301 :         if (TREE_VALUE (args)
    1205                 :    58071301 :             && !ix86_valid_target_attribute_inner_p (fndecl, TREE_VALUE (args),
    1206                 :             :                                                      p_strings, opts, opts_set,
    1207                 :             :                                                      enum_opts_set,
    1208                 :             :                                                      target_clone_attr))
    1209                 :             :           ret = false;
    1210                 :             : 
    1211                 :             :       return ret;
    1212                 :             :     }
    1213                 :             : 
    1214                 :    58072204 :   else if (TREE_CODE (args) != STRING_CST)
    1215                 :             :     {
    1216                 :           9 :       error_at (loc, "attribute %qs argument is not a string", attr_name);
    1217                 :           9 :       return false;
    1218                 :             :     }
    1219                 :             : 
    1220                 :             :   /* Handle multiple arguments separated by commas.  */
    1221                 :    58072195 :   next_optstr = ASTRDUP (TREE_STRING_POINTER (args));
    1222                 :             : 
    1223                 :   174771343 :   while (next_optstr && *next_optstr != '\0')
    1224                 :             :     {
    1225                 :   116699150 :       char *p = next_optstr;
    1226                 :   116699150 :       char *orig_p = p;
    1227                 :   116699150 :       char *comma = strchr (next_optstr, ',');
    1228                 :   116699150 :       size_t len, opt_len;
    1229                 :   116699150 :       int opt;
    1230                 :   116699150 :       bool opt_set_p;
    1231                 :   116699150 :       char ch;
    1232                 :   116699150 :       unsigned i;
    1233                 :   116699150 :       enum ix86_opt_type type = ix86_opt_unknown;
    1234                 :   116699150 :       int mask = 0;
    1235                 :             : 
    1236                 :   116699150 :       if (comma)
    1237                 :             :         {
    1238                 :    58626966 :           *comma = '\0';
    1239                 :    58626966 :           len = comma - next_optstr;
    1240                 :    58626966 :           next_optstr = comma + 1;
    1241                 :             :         }
    1242                 :             :       else
    1243                 :             :         {
    1244                 :    58072184 :           len = strlen (p);
    1245                 :    58072184 :           next_optstr = NULL;
    1246                 :             :         }
    1247                 :             : 
    1248                 :             :       /* Recognize no-xxx.  */
    1249                 :   116699150 :       if (len > 3 && p[0] == 'n' && p[1] == 'o' && p[2] == '-')
    1250                 :             :         {
    1251                 :    29801553 :           opt_set_p = false;
    1252                 :    29801553 :           p += 3;
    1253                 :    29801553 :           len -= 3;
    1254                 :             :         }
    1255                 :             :       else
    1256                 :             :         opt_set_p = true;
    1257                 :             : 
    1258                 :             :       /* Find the option.  */
    1259                 :   116699150 :       ch = *p;
    1260                 :   116699150 :       opt = N_OPTS;
    1261                 :  7355655343 :       for (i = 0; i < ARRAY_SIZE (attrs); i++)
    1262                 :             :         {
    1263                 :  7355655224 :           type = attrs[i].type;
    1264                 :  7355655224 :           opt_len = attrs[i].len;
    1265                 :  7355655224 :           if (ch == attrs[i].string[0]
    1266                 :  1124970875 :               && ((type != ix86_opt_str && type != ix86_opt_enum)
    1267                 :  1124970875 :                   ? len == opt_len
    1268                 :             :                   : len > opt_len)
    1269                 :   226636713 :               && memcmp (p, attrs[i].string, opt_len) == 0)
    1270                 :             :             {
    1271                 :   116699031 :               opt = attrs[i].opt;
    1272                 :   116699031 :               mask = attrs[i].mask;
    1273                 :   116699031 :               break;
    1274                 :             :             }
    1275                 :             :         }
    1276                 :             : 
    1277                 :             :       /* Process the option.  */
    1278                 :   116699150 :       if (opt == N_OPTS)
    1279                 :             :         {
    1280                 :         119 :           error_at (loc, "attribute %qs argument %qs is unknown",
    1281                 :             :                     attr_name, orig_p);
    1282                 :         119 :           ret = false;
    1283                 :             :         }
    1284                 :             : 
    1285                 :   116699031 :       else if (type == ix86_opt_isa)
    1286                 :             :         {
    1287                 :   114765651 :           struct cl_decoded_option decoded;
    1288                 :             : 
    1289                 :   114765651 :           generate_option (opt, NULL, opt_set_p, CL_TARGET, &decoded);
    1290                 :   114765651 :           ix86_handle_option (opts, opts_set,
    1291                 :             :                               &decoded, input_location);
    1292                 :             :         }
    1293                 :             : 
    1294                 :             :       else if (type == ix86_opt_yes || type == ix86_opt_no)
    1295                 :             :         {
    1296                 :          43 :           if (type == ix86_opt_no)
    1297                 :          12 :             opt_set_p = !opt_set_p;
    1298                 :             : 
    1299                 :          43 :           if (opt_set_p)
    1300                 :          35 :             opts->x_target_flags |= mask;
    1301                 :             :           else
    1302                 :           8 :             opts->x_target_flags &= ~mask;
    1303                 :             :         }
    1304                 :             : 
    1305                 :             :       else if (type == ix86_opt_ix86_yes || type == ix86_opt_ix86_no)
    1306                 :             :         {
    1307                 :     1916274 :           if (mask == OPTION_MASK_GENERAL_REGS_ONLY)
    1308                 :             :             {
    1309                 :     1916274 :               if (!opt_set_p)
    1310                 :             :                 {
    1311                 :           2 :                   error_at (loc, "pragma or attribute %<target(\"%s\")%> "
    1312                 :             :                             "does not allow a negated form", p);
    1313                 :           2 :                   return false;
    1314                 :             :                 }
    1315                 :             : 
    1316                 :     1916272 :               if (type != ix86_opt_ix86_yes)
    1317                 :           0 :                 gcc_unreachable ();
    1318                 :             : 
    1319                 :     1916272 :               opts->x_ix86_target_flags |= mask;
    1320                 :             : 
    1321                 :     1916272 :               struct cl_decoded_option decoded;
    1322                 :     1916272 :               generate_option (opt, NULL, opt_set_p, CL_TARGET,
    1323                 :             :                                &decoded);
    1324                 :     1916272 :               ix86_handle_option (opts, opts_set, &decoded,
    1325                 :             :                                   input_location);
    1326                 :             :             }
    1327                 :             :           else
    1328                 :             :             {
    1329                 :           0 :               if (type == ix86_opt_ix86_no)
    1330                 :           0 :                 opt_set_p = !opt_set_p;
    1331                 :             : 
    1332                 :           0 :               if (opt_set_p)
    1333                 :           0 :                 opts->x_ix86_target_flags |= mask;
    1334                 :             :               else
    1335                 :           0 :                 opts->x_ix86_target_flags &= ~mask;
    1336                 :             :             }
    1337                 :             :         }
    1338                 :             : 
    1339                 :             :       else if (type == ix86_opt_str)
    1340                 :             :         {
    1341                 :       16876 :           if (p_strings[opt])
    1342                 :             :             {
    1343                 :           1 :               error_at (loc, "attribute value %qs was already specified "
    1344                 :             :                         "in %qs attribute", orig_p, attr_name);
    1345                 :           1 :               ret = false;
    1346                 :             :             }
    1347                 :             :           else
    1348                 :             :             {
    1349                 :       16875 :               p_strings[opt] = xstrdup (p + opt_len);
    1350                 :       16875 :               if (opt == IX86_FUNCTION_SPECIFIC_ARCH)
    1351                 :             :                 {
    1352                 :             :                   /* If arch= is set,  clear all bits in x_ix86_isa_flags,
    1353                 :             :                      except for ISA_64BIT, ABI_64, ABI_X32, and CODE16
    1354                 :             :                      and all bits in x_ix86_isa_flags2.  */
    1355                 :       16846 :                   opts->x_ix86_isa_flags &= (OPTION_MASK_ISA_64BIT
    1356                 :             :                                              | OPTION_MASK_ABI_64
    1357                 :             :                                              | OPTION_MASK_ABI_X32
    1358                 :             :                                              | OPTION_MASK_CODE16);
    1359                 :       16846 :                   opts->x_ix86_isa_flags_explicit &= (OPTION_MASK_ISA_64BIT
    1360                 :             :                                                       | OPTION_MASK_ABI_64
    1361                 :             :                                                       | OPTION_MASK_ABI_X32
    1362                 :             :                                                       | OPTION_MASK_CODE16);
    1363                 :       16846 :                   opts->x_ix86_isa_flags2 = 0;
    1364                 :       16846 :                   opts->x_ix86_isa_flags2_explicit = 0;
    1365                 :             :                 }
    1366                 :             :             }
    1367                 :             :         }
    1368                 :             : 
    1369                 :             :       else if (type == ix86_opt_enum)
    1370                 :             :         {
    1371                 :         187 :           bool arg_ok;
    1372                 :         187 :           int value;
    1373                 :             : 
    1374                 :         187 :           arg_ok = opt_enum_arg_to_value (opt, p + opt_len, &value, CL_TARGET);
    1375                 :         187 :           if (arg_ok)
    1376                 :         187 :             set_option (opts, enum_opts_set, opt, value,
    1377                 :             :                         p + opt_len, DK_UNSPECIFIED, input_location,
    1378                 :             :                         global_dc);
    1379                 :             :           else
    1380                 :             :             {
    1381                 :           0 :               error_at (loc, "attribute value %qs is unknown in %qs attribute",
    1382                 :             :                         orig_p, attr_name);
    1383                 :           0 :               ret = false;
    1384                 :             :             }
    1385                 :             :         }
    1386                 :             : 
    1387                 :             :       else
    1388                 :           0 :         gcc_unreachable ();
    1389                 :             :     }
    1390                 :             : 
    1391                 :             :   return ret;
    1392                 :             : }
    1393                 :             : 
    1394                 :             : /* Release allocated strings.  */
    1395                 :             : static void
    1396                 :    56479258 : release_options_strings (char **option_strings)
    1397                 :             : {
    1398                 :             :   /* Free up memory allocated to hold the strings */
    1399                 :   169437774 :   for (unsigned i = 0; i < IX86_FUNCTION_SPECIFIC_MAX; i++)
    1400                 :   112958516 :     free (option_strings[i]);
    1401                 :    56479258 : }
    1402                 :             : 
    1403                 :             : /* Return a TARGET_OPTION_NODE tree of the target options listed or NULL.  */
    1404                 :             : 
    1405                 :             : tree
    1406                 :    56479883 : ix86_valid_target_attribute_tree (tree fndecl, tree args,
    1407                 :             :                                   struct gcc_options *opts,
    1408                 :             :                                   struct gcc_options *opts_set,
    1409                 :             :                                   bool target_clone_attr)
    1410                 :             : {
    1411                 :    56479883 :   const char *orig_arch_string = opts->x_ix86_arch_string;
    1412                 :    56479883 :   const char *orig_tune_string = opts->x_ix86_tune_string;
    1413                 :    56479883 :   enum fpmath_unit orig_fpmath_set = opts_set->x_ix86_fpmath;
    1414                 :    56479883 :   enum prefer_vector_width orig_pvw_set = opts_set->x_prefer_vector_width_type;
    1415                 :    56479883 :   enum prefer_vector_width orig_ix86_move_max_set
    1416                 :             :     = opts_set->x_ix86_move_max;
    1417                 :    56479883 :   enum prefer_vector_width orig_ix86_store_max_set
    1418                 :             :     = opts_set->x_ix86_store_max;
    1419                 :    56479883 :   int orig_tune_defaulted = ix86_tune_defaulted;
    1420                 :    56479883 :   int orig_arch_specified = ix86_arch_specified;
    1421                 :    56479883 :   char *option_strings[IX86_FUNCTION_SPECIFIC_MAX] = { NULL, NULL };
    1422                 :    56479883 :   tree t = NULL_TREE;
    1423                 :    56479883 :   struct cl_target_option *def
    1424                 :    56479883 :     = TREE_TARGET_OPTION (target_option_default_node);
    1425                 :    56479883 :   struct gcc_options enum_opts_set;
    1426                 :             : 
    1427                 :    56479883 :   memset (&enum_opts_set, 0, sizeof (enum_opts_set));
    1428                 :             : 
    1429                 :             :   /* Process each of the options on the chain.  */
    1430                 :    56479883 :   if (!ix86_valid_target_attribute_inner_p (fndecl, args, option_strings, opts,
    1431                 :             :                                             opts_set, &enum_opts_set,
    1432                 :             :                                             target_clone_attr))
    1433                 :         128 :     return error_mark_node;
    1434                 :             : 
    1435                 :             :   /* AVX10.1-256 will enable only 256 bit AVX512F features by setting all
    1436                 :             :      AVX512 related ISA flags and not setting EVEX512.  When it is used
    1437                 :             :      with avx512 related function attribute, we need to enable 512 bit to
    1438                 :             :      align with the command line behavior.  Manually set EVEX512 for this
    1439                 :             :      scenario.  */
    1440                 :    56479755 :   if ((def->x_ix86_isa_flags2 & OPTION_MASK_ISA2_AVX10_1_256)
    1441                 :      265522 :       && (opts->x_ix86_isa_flags & OPTION_MASK_ISA_AVX512F)
    1442                 :      247227 :       && (opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512F)
    1443                 :      220213 :       && !(def->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_EVEX512)
    1444                 :      216137 :       && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_EVEX512))
    1445                 :         951 :     opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA2_EVEX512;
    1446                 :             : 
    1447                 :             :   /* If the changed options are different from the default, rerun
    1448                 :             :      ix86_option_override_internal, and then save the options away.
    1449                 :             :      The string options are attribute options, and will be undone
    1450                 :             :      when we copy the save structure.  */
    1451                 :    56479755 :   if (opts->x_ix86_isa_flags != def->x_ix86_isa_flags
    1452                 :     7964107 :       || opts->x_ix86_isa_flags2 != def->x_ix86_isa_flags2
    1453                 :        1872 :       || opts->x_target_flags != def->x_target_flags
    1454                 :         719 :       || option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
    1455                 :         719 :       || option_strings[IX86_FUNCTION_SPECIFIC_TUNE]
    1456                 :         690 :       || enum_opts_set.x_ix86_fpmath
    1457                 :         521 :       || enum_opts_set.x_prefer_vector_width_type
    1458                 :         508 :       || (!(def->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_AVX10_1_256)
    1459                 :         494 :           && (opts->x_ix86_isa_flags2_explicit
    1460                 :             :               & OPTION_MASK_ISA2_AVX10_1_256)))
    1461                 :             :     {
    1462                 :             :       /* If we are using the default tune= or arch=, undo the string assigned,
    1463                 :             :          and use the default.  */
    1464                 :    56479258 :       if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH])
    1465                 :       16845 :         opts->x_ix86_arch_string
    1466                 :       16845 :           = ggc_strdup (option_strings[IX86_FUNCTION_SPECIFIC_ARCH]);
    1467                 :    56462413 :       else if (!orig_arch_specified)
    1468                 :           0 :         opts->x_ix86_arch_string = NULL;
    1469                 :             : 
    1470                 :    56479258 :       if (option_strings[IX86_FUNCTION_SPECIFIC_TUNE])
    1471                 :          29 :         opts->x_ix86_tune_string
    1472                 :          29 :           = ggc_strdup (option_strings[IX86_FUNCTION_SPECIFIC_TUNE]);
    1473                 :             :       /* If we have explicit arch string and no tune string specified, set
    1474                 :             :          tune_string to NULL and later it will be overriden by arch_string
    1475                 :             :          so target clones can get proper optimization.  */
    1476                 :    56479229 :       else if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
    1477                 :    56462384 :                || orig_tune_defaulted)
    1478                 :       16845 :         opts->x_ix86_tune_string = NULL;
    1479                 :             : 
    1480                 :             :       /* If fpmath= is not set, and we now have sse2 on 32-bit, use it.  */
    1481                 :    56479258 :       if (enum_opts_set.x_ix86_fpmath)
    1482                 :         169 :         opts_set->x_ix86_fpmath = (enum fpmath_unit) 1;
    1483                 :    56479258 :       if (enum_opts_set.x_prefer_vector_width_type)
    1484                 :          17 :         opts_set->x_prefer_vector_width_type = (enum prefer_vector_width) 1;
    1485                 :             : 
    1486                 :             :       /* Do any overrides, such as arch=xxx, or tune=xxx support.  */
    1487                 :    56479258 :       bool r = ix86_option_override_internal (false, opts, opts_set);
    1488                 :    56479258 :       if (!r)
    1489                 :             :         {
    1490                 :           3 :           release_options_strings (option_strings);
    1491                 :           3 :           return error_mark_node;
    1492                 :             :         }
    1493                 :             : 
    1494                 :             :       /* Add any builtin functions with the new isa if any.  */
    1495                 :    56479255 :       ix86_add_new_builtins (opts->x_ix86_isa_flags, opts->x_ix86_isa_flags2);
    1496                 :             : 
    1497                 :    56479255 :       enum excess_precision orig_ix86_excess_precision
    1498                 :             :         = opts->x_ix86_excess_precision;
    1499                 :    56479255 :       bool orig_ix86_unsafe_math_optimizations
    1500                 :             :         = opts->x_ix86_unsafe_math_optimizations;
    1501                 :    56479255 :       opts->x_ix86_excess_precision = opts->x_flag_excess_precision;
    1502                 :    56479255 :       opts->x_ix86_unsafe_math_optimizations
    1503                 :    56479255 :         = opts->x_flag_unsafe_math_optimizations;
    1504                 :             : 
    1505                 :             :       /* Save the current options unless we are validating options for
    1506                 :             :          #pragma.  */
    1507                 :    56479255 :       t = build_target_option_node (opts, opts_set);
    1508                 :             : 
    1509                 :    56479255 :       opts->x_ix86_arch_string = orig_arch_string;
    1510                 :    56479255 :       opts->x_ix86_tune_string = orig_tune_string;
    1511                 :    56479255 :       opts_set->x_ix86_fpmath = orig_fpmath_set;
    1512                 :    56479255 :       opts_set->x_prefer_vector_width_type = orig_pvw_set;
    1513                 :    56479255 :       opts_set->x_ix86_move_max = orig_ix86_move_max_set;
    1514                 :    56479255 :       opts_set->x_ix86_store_max = orig_ix86_store_max_set;
    1515                 :    56479255 :       opts->x_ix86_excess_precision = orig_ix86_excess_precision;
    1516                 :    56479255 :       opts->x_ix86_unsafe_math_optimizations
    1517                 :    56479255 :         = orig_ix86_unsafe_math_optimizations;
    1518                 :             : 
    1519                 :    56479255 :       release_options_strings (option_strings);
    1520                 :             :     }
    1521                 :             : 
    1522                 :             :   return t;
    1523                 :             : }
    1524                 :             : 
    1525                 :             : static GTY(()) tree target_attribute_cache[3];
    1526                 :             : 
    1527                 :             : /* Hook to validate attribute((target("string"))).  */
    1528                 :             : 
    1529                 :             : bool
    1530                 :    55854725 : ix86_valid_target_attribute_p (tree fndecl,
    1531                 :             :                                tree ARG_UNUSED (name),
    1532                 :             :                                tree args,
    1533                 :             :                                int flags)
    1534                 :             : {
    1535                 :    55854725 :   struct gcc_options func_options, func_options_set;
    1536                 :    55854725 :   tree new_target, new_optimize;
    1537                 :    55854725 :   bool ret = true;
    1538                 :             : 
    1539                 :             :   /* attribute((target("default"))) does nothing, beyond
    1540                 :             :      affecting multi-versioning.  */
    1541                 :    55854725 :   if (TREE_VALUE (args)
    1542                 :    55854725 :       && TREE_CODE (TREE_VALUE (args)) == STRING_CST
    1543                 :    55854719 :       && TREE_CHAIN (args) == NULL_TREE
    1544                 :   110167169 :       && strcmp (TREE_STRING_POINTER (TREE_VALUE (args)), "default") == 0)
    1545                 :             :     return true;
    1546                 :             : 
    1547                 :    55854545 :   if ((DECL_FUNCTION_SPECIFIC_TARGET (fndecl) == target_attribute_cache[1]
    1548                 :    55852257 :        || DECL_FUNCTION_SPECIFIC_TARGET (fndecl) == NULL_TREE)
    1549                 :        6346 :       && (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl)
    1550                 :        6346 :           == target_attribute_cache[2]
    1551                 :         432 :           || DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) == NULL_TREE)
    1552                 :    55860857 :       && simple_cst_list_equal (args, target_attribute_cache[0]))
    1553                 :             :     {
    1554                 :        1257 :       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = target_attribute_cache[1];
    1555                 :        1257 :       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl)
    1556                 :        1257 :         = target_attribute_cache[2];
    1557                 :        1257 :       return true;
    1558                 :             :     }
    1559                 :             : 
    1560                 :    55853288 :   tree old_optimize = build_optimization_node (&global_options,
    1561                 :             :                                                &global_options_set);
    1562                 :             : 
    1563                 :             :   /* Get the optimization options of the current function.  */
    1564                 :    55853288 :   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
    1565                 :             : 
    1566                 :    55853288 :   if (!func_optimize)
    1567                 :        5055 :     func_optimize = old_optimize;
    1568                 :             : 
    1569                 :             :   /* Init func_options.  */
    1570                 :    55853288 :   memset (&func_options, 0, sizeof (func_options));
    1571                 :    55853288 :   init_options_struct (&func_options, NULL);
    1572                 :    55853288 :   lang_hooks.init_options_struct (&func_options);
    1573                 :    55853288 :   memset (&func_options_set, 0, sizeof (func_options_set));
    1574                 :             : 
    1575                 :    55853288 :   cl_optimization_restore (&func_options, &func_options_set,
    1576                 :    55853288 :                            TREE_OPTIMIZATION (func_optimize));
    1577                 :             : 
    1578                 :             :   /* Initialize func_options to the default before its target options can
    1579                 :             :      be set.  */
    1580                 :    55853288 :   tree old_target = DECL_FUNCTION_SPECIFIC_TARGET (fndecl);
    1581                 :    55853288 :   if (old_target == NULL_TREE)
    1582                 :        5086 :     old_target = target_option_default_node;
    1583                 :    55853288 :   cl_target_option_restore (&func_options, &func_options_set,
    1584                 :    55853288 :                             TREE_TARGET_OPTION (old_target));
    1585                 :             : 
    1586                 :             :   /* FLAGS == 1 is used for target_clones attribute.  */
    1587                 :    55853288 :   new_target
    1588                 :    55853288 :     = ix86_valid_target_attribute_tree (fndecl, args, &func_options,
    1589                 :             :                                         &func_options_set, flags == 1);
    1590                 :             : 
    1591                 :    55853288 :   new_optimize = build_optimization_node (&func_options, &func_options_set);
    1592                 :             : 
    1593                 :    55853288 :   if (new_target == error_mark_node)
    1594                 :             :     ret = false;
    1595                 :             : 
    1596                 :    55853161 :   else if (new_target)
    1597                 :             :     {
    1598                 :    55852929 :       if (DECL_FUNCTION_SPECIFIC_TARGET (fndecl) == NULL_TREE
    1599                 :    55852929 :           && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) == NULL_TREE)
    1600                 :             :         {
    1601                 :        4714 :           target_attribute_cache[0] = copy_list (args);
    1602                 :        4714 :           target_attribute_cache[1] = new_target;
    1603                 :        4714 :           target_attribute_cache[2]
    1604                 :        8969 :             = old_optimize != new_optimize ? new_optimize : NULL_TREE;
    1605                 :             :         }
    1606                 :             : 
    1607                 :    55852929 :       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
    1608                 :             : 
    1609                 :    55852929 :       if (old_optimize != new_optimize)
    1610                 :       15805 :         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
    1611                 :             :     }
    1612                 :             : 
    1613                 :             :   return ret;
    1614                 :             : }
    1615                 :             : 
    1616                 :             : const char *stringop_alg_names[] = {
    1617                 :             : #define DEF_ALG(alg, name) #name,
    1618                 :             : #include "stringop.def"
    1619                 :             : #undef DEF_ALG
    1620                 :             : };
    1621                 :             : 
    1622                 :             : /* Parse parameter string passed to -mmemcpy-strategy= or -mmemset-strategy=.
    1623                 :             :    The string is of the following form (or comma separated list of it):
    1624                 :             : 
    1625                 :             :      strategy_alg:max_size:[align|noalign]
    1626                 :             : 
    1627                 :             :    where the full size range for the strategy is either [0, max_size] or
    1628                 :             :    [min_size, max_size], in which min_size is the max_size + 1 of the
    1629                 :             :    preceding range.  The last size range must have max_size == -1.
    1630                 :             : 
    1631                 :             :    Examples:
    1632                 :             : 
    1633                 :             :     1.
    1634                 :             :        -mmemcpy-strategy=libcall:-1:noalign
    1635                 :             : 
    1636                 :             :       this is equivalent to (for known size memcpy) -mstringop-strategy=libcall
    1637                 :             : 
    1638                 :             : 
    1639                 :             :    2.
    1640                 :             :       -mmemset-strategy=rep_8byte:16:noalign,vector_loop:2048:align,libcall:-1:noalign
    1641                 :             : 
    1642                 :             :       This is to tell the compiler to use the following strategy for memset
    1643                 :             :       1) when the expected size is between [1, 16], use rep_8byte strategy;
    1644                 :             :       2) when the size is between [17, 2048], use vector_loop;
    1645                 :             :       3) when the size is > 2048, use libcall.  */
    1646                 :             : 
    1647                 :             : struct stringop_size_range
    1648                 :             : {
    1649                 :             :   int max;
    1650                 :             :   stringop_alg alg;
    1651                 :             :   bool noalign;
    1652                 :             : };
    1653                 :             : 
    1654                 :             : static void
    1655                 :          10 : ix86_parse_stringop_strategy_string (char *strategy_str, bool is_memset)
    1656                 :             : {
    1657                 :          10 :   const struct stringop_algs *default_algs;
    1658                 :          10 :   stringop_size_range input_ranges[MAX_STRINGOP_ALGS];
    1659                 :          10 :   char *curr_range_str, *next_range_str;
    1660                 :          10 :   const char *opt = is_memset ? "-mmemset_strategy=" : "-mmemcpy_strategy=";
    1661                 :          10 :   int i = 0, n = 0;
    1662                 :             : 
    1663                 :          10 :   if (is_memset)
    1664                 :           3 :     default_algs = &ix86_cost->memset[TARGET_64BIT != 0];
    1665                 :             :   else
    1666                 :           7 :     default_algs = &ix86_cost->memcpy[TARGET_64BIT != 0];
    1667                 :             : 
    1668                 :          10 :   curr_range_str = strategy_str;
    1669                 :             : 
    1670                 :          12 :   do
    1671                 :             :     {
    1672                 :          12 :       int maxs;
    1673                 :          12 :       char alg_name[128];
    1674                 :          12 :       char align[16];
    1675                 :          12 :       next_range_str = strchr (curr_range_str, ',');
    1676                 :          12 :       if (next_range_str)
    1677                 :           2 :         *next_range_str++ = '\0';
    1678                 :             : 
    1679                 :          12 :       if (sscanf (curr_range_str, "%20[^:]:%d:%10s", alg_name, &maxs,
    1680                 :             :                   align) != 3)
    1681                 :             :         {
    1682                 :           0 :           error ("wrong argument %qs to option %qs", curr_range_str, opt);
    1683                 :           1 :           return;
    1684                 :             :         }
    1685                 :             : 
    1686                 :          12 :       if (n > 0 && (maxs < (input_ranges[n - 1].max + 1) && maxs != -1))
    1687                 :             :         {
    1688                 :           0 :           error ("size ranges of option %qs should be increasing", opt);
    1689                 :           0 :           return;
    1690                 :             :         }
    1691                 :             : 
    1692                 :          55 :       for (i = 0; i < last_alg; i++)
    1693                 :          54 :         if (!strcmp (alg_name, stringop_alg_names[i]))
    1694                 :             :           break;
    1695                 :             : 
    1696                 :          12 :       if (i == last_alg)
    1697                 :             :         {
    1698                 :           1 :           error ("wrong strategy name %qs specified for option %qs",
    1699                 :             :                  alg_name, opt);
    1700                 :             : 
    1701                 :           1 :           auto_vec <const char *> candidates;
    1702                 :          10 :           for (i = 0; i < last_alg; i++)
    1703                 :           9 :             if ((stringop_alg) i != rep_prefix_8_byte || TARGET_64BIT)
    1704                 :           9 :               candidates.safe_push (stringop_alg_names[i]);
    1705                 :             : 
    1706                 :           1 :           char *s;
    1707                 :           1 :           const char *hint
    1708                 :           1 :             = candidates_list_and_hint (alg_name, s, candidates);
    1709                 :           1 :           if (hint)
    1710                 :           1 :             inform (input_location,
    1711                 :             :                     "valid arguments to %qs are: %s; did you mean %qs?",
    1712                 :             :                     opt, s, hint);
    1713                 :             :           else
    1714                 :           0 :             inform (input_location, "valid arguments to %qs are: %s",
    1715                 :             :                     opt, s);
    1716                 :           1 :           XDELETEVEC (s);
    1717                 :           1 :           return;
    1718                 :           1 :         }
    1719                 :             : 
    1720                 :          11 :       if ((stringop_alg) i == rep_prefix_8_byte
    1721                 :           1 :           && !TARGET_64BIT)
    1722                 :             :         {
    1723                 :             :           /* rep; movq isn't available in 32-bit code.  */
    1724                 :           0 :           error ("strategy name %qs specified for option %qs "
    1725                 :             :                  "not supported for 32-bit code", alg_name, opt);
    1726                 :           0 :           return;
    1727                 :             :         }
    1728                 :             : 
    1729                 :          11 :       input_ranges[n].max = maxs;
    1730                 :          11 :       input_ranges[n].alg = (stringop_alg) i;
    1731                 :          11 :       if (!strcmp (align, "align"))
    1732                 :           8 :         input_ranges[n].noalign = false;
    1733                 :           3 :       else if (!strcmp (align, "noalign"))
    1734                 :           3 :         input_ranges[n].noalign = true;
    1735                 :             :       else
    1736                 :             :         {
    1737                 :           0 :           error ("unknown alignment %qs specified for option %qs", align, opt);
    1738                 :           0 :           return;
    1739                 :             :         }
    1740                 :          11 :       n++;
    1741                 :          11 :       curr_range_str = next_range_str;
    1742                 :             :     }
    1743                 :          11 :   while (curr_range_str);
    1744                 :             : 
    1745                 :           9 :   if (input_ranges[n - 1].max != -1)
    1746                 :             :     {
    1747                 :           0 :       error ("the max value for the last size range should be -1"
    1748                 :             :              " for option %qs", opt);
    1749                 :           0 :       return;
    1750                 :             :     }
    1751                 :             : 
    1752                 :           9 :   if (n > MAX_STRINGOP_ALGS)
    1753                 :             :     {
    1754                 :           0 :       error ("too many size ranges specified in option %qs", opt);
    1755                 :           0 :       return;
    1756                 :             :     }
    1757                 :             : 
    1758                 :             :   /* Now override the default algs array.  */
    1759                 :          20 :   for (i = 0; i < n; i++)
    1760                 :             :     {
    1761                 :          11 :       *const_cast<int *>(&default_algs->size[i].max) = input_ranges[i].max;
    1762                 :          11 :       *const_cast<stringop_alg *>(&default_algs->size[i].alg)
    1763                 :          11 :           = input_ranges[i].alg;
    1764                 :          11 :       *const_cast<int *>(&default_algs->size[i].noalign)
    1765                 :          11 :           = input_ranges[i].noalign;
    1766                 :             :     }
    1767                 :             : }
    1768                 :             : 
    1769                 :             : 
    1770                 :             : /* parse -mtune-ctrl= option. When DUMP is true,
    1771                 :             :    print the features that are explicitly set.  */
    1772                 :             : 
    1773                 :             : static void
    1774                 :    56789739 : parse_mtune_ctrl_str (struct gcc_options *opts, bool dump)
    1775                 :             : {
    1776                 :    56789739 :   if (!opts->x_ix86_tune_ctrl_string)
    1777                 :             :     return;
    1778                 :             : 
    1779                 :      212361 :   char *next_feature_string = NULL;
    1780                 :      212361 :   char *curr_feature_string = xstrdup (opts->x_ix86_tune_ctrl_string);
    1781                 :      212361 :   char *orig = curr_feature_string;
    1782                 :      212384 :   int i;
    1783                 :      212384 :   do
    1784                 :             :     {
    1785                 :      212384 :       bool clear = false;
    1786                 :             : 
    1787                 :      212384 :       next_feature_string = strchr (curr_feature_string, ',');
    1788                 :      212384 :       if (next_feature_string)
    1789                 :          23 :         *next_feature_string++ = '\0';
    1790                 :      212384 :       if (*curr_feature_string == '^')
    1791                 :             :         {
    1792                 :          51 :           curr_feature_string++;
    1793                 :          51 :           clear = true;
    1794                 :             :         }
    1795                 :             : 
    1796                 :      212384 :       if (!strcmp (curr_feature_string, "use_gather"))
    1797                 :             :         {
    1798                 :      132166 :           ix86_tune_features[X86_TUNE_USE_GATHER_2PARTS] = !clear;
    1799                 :      132166 :           ix86_tune_features[X86_TUNE_USE_GATHER_4PARTS] = !clear;
    1800                 :      132166 :           ix86_tune_features[X86_TUNE_USE_GATHER_8PARTS] = !clear;
    1801                 :      132166 :           if (dump)
    1802                 :           0 :             fprintf (stderr, "Explicitly %s features use_gather_2parts,"
    1803                 :             :                      " use_gather_4parts, use_gather_8parts\n",
    1804                 :             :                      clear ? "clear" : "set");
    1805                 :             : 
    1806                 :             :         }
    1807                 :       80218 :       else if (!strcmp (curr_feature_string, "use_scatter"))
    1808                 :             :         {
    1809                 :           0 :           ix86_tune_features[X86_TUNE_USE_SCATTER_2PARTS] = !clear;
    1810                 :           0 :           ix86_tune_features[X86_TUNE_USE_SCATTER_4PARTS] = !clear;
    1811                 :           0 :           ix86_tune_features[X86_TUNE_USE_SCATTER_8PARTS] = !clear;
    1812                 :           0 :           if (dump)
    1813                 :           0 :             fprintf (stderr, "Explicitly %s features use_scatter_2parts,"
    1814                 :             :                      " use_scatter_4parts, use_scatter_8parts\n",
    1815                 :             :                      clear ? "clear" : "set");
    1816                 :             :         }
    1817                 :             :       else
    1818                 :             :         {
    1819                 :     1522601 :           for (i = 0; i < X86_TUNE_LAST; i++)
    1820                 :             :             {
    1821                 :     1522601 :               if (!strcmp (curr_feature_string, ix86_tune_feature_names[i]))
    1822                 :             :                 {
    1823                 :       80218 :                   ix86_tune_features[i] = !clear;
    1824                 :       80218 :                   if (dump)
    1825                 :           0 :                     fprintf (stderr, "Explicitly %s feature %s\n",
    1826                 :             :                              clear ? "clear" : "set", ix86_tune_feature_names[i]);
    1827                 :             :                   break;
    1828                 :             :                 }
    1829                 :             :             }
    1830                 :             : 
    1831                 :       80218 :           if (i == X86_TUNE_LAST)
    1832                 :           0 :             error ("unknown parameter to option %<-mtune-ctrl%>: %s",
    1833                 :             :                    clear ? curr_feature_string - 1 : curr_feature_string);
    1834                 :             :         }
    1835                 :      212384 :       curr_feature_string = next_feature_string;
    1836                 :             :     }
    1837                 :      212384 :   while (curr_feature_string);
    1838                 :      212361 :   free (orig);
    1839                 :             : }
    1840                 :             : 
    1841                 :             : /* Helper function to set ix86_tune_features. IX86_TUNE is the
    1842                 :             :    processor type.  */
    1843                 :             : 
    1844                 :             : static void
    1845                 :    56789739 : set_ix86_tune_features (struct gcc_options *opts,
    1846                 :             :                         enum processor_type ix86_tune, bool dump)
    1847                 :             : {
    1848                 :    56789739 :   unsigned HOST_WIDE_INT ix86_tune_mask = HOST_WIDE_INT_1U << ix86_tune;
    1849                 :    56789739 :   int i;
    1850                 :             : 
    1851                 :  6644399463 :   for (i = 0; i < X86_TUNE_LAST; ++i)
    1852                 :             :     {
    1853                 :  6587609724 :       if (ix86_tune_no_default)
    1854                 :           0 :         ix86_tune_features[i] = 0;
    1855                 :             :       else
    1856                 :  6587609724 :         ix86_tune_features[i]
    1857                 :  6587609724 :           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
    1858                 :             :     }
    1859                 :             : 
    1860                 :    56789739 :   if (dump)
    1861                 :             :     {
    1862                 :           0 :       fprintf (stderr, "List of x86 specific tuning parameter names:\n");
    1863                 :           0 :       for (i = 0; i < X86_TUNE_LAST; i++)
    1864                 :           0 :         fprintf (stderr, "%s : %s\n", ix86_tune_feature_names[i],
    1865                 :           0 :                  ix86_tune_features[i] ? "on" : "off");
    1866                 :             :     }
    1867                 :             : 
    1868                 :    56789739 :   parse_mtune_ctrl_str (opts, dump);
    1869                 :    56789739 : }
    1870                 :             : 
    1871                 :             : 
    1872                 :             : /* Default align_* from the processor table.  */
    1873                 :             : 
    1874                 :             : static void
    1875                 :   117178450 : ix86_default_align (struct gcc_options *opts)
    1876                 :             : {
    1877                 :             :   /* -falign-foo without argument: supply one.  */
    1878                 :   117178450 :   if (opts->x_flag_align_loops && !opts->x_str_align_loops)
    1879                 :      126281 :     opts->x_str_align_loops = processor_cost_table[ix86_tune]->align_loop;
    1880                 :   117178450 :   if (opts->x_flag_align_jumps && !opts->x_str_align_jumps)
    1881                 :      126282 :     opts->x_str_align_jumps = processor_cost_table[ix86_tune]->align_jump;
    1882                 :   117178450 :   if (opts->x_flag_align_labels && !opts->x_str_align_labels)
    1883                 :      126282 :     opts->x_str_align_labels = processor_cost_table[ix86_tune]->align_label;
    1884                 :   117178450 :   if (opts->x_flag_align_functions && !opts->x_str_align_functions)
    1885                 :      126277 :     opts->x_str_align_functions = processor_cost_table[ix86_tune]->align_func;
    1886                 :   117178450 : }
    1887                 :             : 
    1888                 :             : #ifndef USE_IX86_FRAME_POINTER
    1889                 :             : #define USE_IX86_FRAME_POINTER 0
    1890                 :             : #endif
    1891                 :             : 
    1892                 :             : /* (Re)compute option overrides affected by optimization levels in
    1893                 :             :    target-specific ways.  */
    1894                 :             : 
    1895                 :             : static void
    1896                 :   117178450 : ix86_recompute_optlev_based_flags (struct gcc_options *opts,
    1897                 :             :                                    struct gcc_options *opts_set)
    1898                 :             : {
    1899                 :             :   /* Set the default values for switches whose default depends on TARGET_64BIT
    1900                 :             :      in case they weren't overwritten by command line options.  */
    1901                 :   117178450 :   if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    1902                 :             :     {
    1903                 :   115202449 :       if (opts->x_optimize >= 1)
    1904                 :   111841248 :         SET_OPTION_IF_UNSET (opts, opts_set, flag_omit_frame_pointer,
    1905                 :             :                              !USE_IX86_FRAME_POINTER);
    1906                 :   115202449 :       if (opts->x_flag_asynchronous_unwind_tables
    1907                 :   115202449 :           && TARGET_64BIT_MS_ABI)
    1908                 :      281284 :         SET_OPTION_IF_UNSET (opts, opts_set, flag_unwind_tables, 1);
    1909                 :   115202449 :       if (opts->x_flag_asynchronous_unwind_tables == 2)
    1910                 :      274557 :         opts->x_flag_unwind_tables
    1911                 :      274557 :           = opts->x_flag_asynchronous_unwind_tables = 1;
    1912                 :   115202449 :       if (opts->x_flag_pcc_struct_return == 2)
    1913                 :      274597 :         opts->x_flag_pcc_struct_return = 0;
    1914                 :             :     }
    1915                 :             :   else
    1916                 :             :     {
    1917                 :     1976001 :       if (opts->x_optimize >= 1)
    1918                 :     1975515 :           SET_OPTION_IF_UNSET (opts, opts_set, flag_omit_frame_pointer,
    1919                 :             :                                !(USE_IX86_FRAME_POINTER || opts->x_optimize_size));
    1920                 :     1976001 :       if (opts->x_flag_asynchronous_unwind_tables == 2)
    1921                 :        6989 :         opts->x_flag_asynchronous_unwind_tables = !USE_IX86_FRAME_POINTER;
    1922                 :     1976001 :       if (opts->x_flag_pcc_struct_return == 2)
    1923                 :             :         {
    1924                 :             :           /* Intel MCU psABI specifies that -freg-struct-return should
    1925                 :             :              be on.  Instead of setting DEFAULT_PCC_STRUCT_RETURN to 0,
    1926                 :             :              we check -miamcu so that -freg-struct-return is always
    1927                 :             :              turned on if -miamcu is used.  */
    1928                 :        6995 :           if (TARGET_IAMCU_P (opts->x_target_flags))
    1929                 :           0 :             opts->x_flag_pcc_struct_return = 0;
    1930                 :             :           else
    1931                 :        6995 :             opts->x_flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
    1932                 :             :         }
    1933                 :             :     }
    1934                 :             : 
    1935                 :             :   /* Keep nonleaf frame pointers.  */
    1936                 :   117178450 :   if (opts->x_flag_omit_frame_pointer)
    1937                 :   113336105 :     opts->x_target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
    1938                 :     3842345 :   else if (TARGET_OMIT_LEAF_FRAME_POINTER_P (opts->x_target_flags))
    1939                 :           0 :     opts->x_flag_omit_frame_pointer = 1;
    1940                 :   117178450 : }
    1941                 :             : 
    1942                 :             : /* Implement part of TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE hook.  */
    1943                 :             : 
    1944                 :             : static void
    1945                 :   117178450 : ix86_override_options_after_change_1 (struct gcc_options *opts,
    1946                 :             :                                       struct gcc_options *opts_set)
    1947                 :             : {
    1948                 :             : #define OPTS_SET_P(OPTION) opts_set->x_ ## OPTION
    1949                 :             : #define OPTS(OPTION) opts->x_ ## OPTION
    1950                 :             : 
    1951                 :             :   /* Disable unrolling small loops when there's explicit
    1952                 :             :      -f{,no}unroll-loop.  */
    1953                 :   117178450 :   if ((OPTS_SET_P (flag_unroll_loops))
    1954                 :   116380512 :      || (OPTS_SET_P (flag_unroll_all_loops)
    1955                 :         124 :          && OPTS (flag_unroll_all_loops)))
    1956                 :             :     {
    1957                 :      798062 :       if (!OPTS_SET_P (ix86_unroll_only_small_loops))
    1958                 :      798062 :         OPTS (ix86_unroll_only_small_loops) = 0;
    1959                 :             :       /* Re-enable -frename-registers and -fweb if funroll-loops
    1960                 :             :          enabled.  */
    1961                 :      798062 :       if (!OPTS_SET_P (flag_web))
    1962                 :      798054 :         OPTS (flag_web) = OPTS (flag_unroll_loops);
    1963                 :      798062 :       if (!OPTS_SET_P (flag_rename_registers))
    1964                 :      798060 :         OPTS (flag_rename_registers) = OPTS (flag_unroll_loops);
    1965                 :             :       /* -fcunroll-grow-size default follws -f[no]-unroll-loops.  */
    1966                 :      798062 :       if (!OPTS_SET_P (flag_cunroll_grow_size))
    1967                 :      798062 :         OPTS (flag_cunroll_grow_size)
    1968                 :     1596124 :           = (OPTS (flag_unroll_loops)
    1969                 :          44 :              || OPTS (flag_peel_loops)
    1970                 :     1596124 :              || OPTS (optimize) >= 3);
    1971                 :             :     }
    1972                 :             :   else
    1973                 :             :     {
    1974                 :   116380388 :       if (!OPTS_SET_P (flag_cunroll_grow_size))
    1975                 :   116380388 :         OPTS (flag_cunroll_grow_size)
    1976                 :   232760776 :           = (OPTS (flag_peel_loops)
    1977                 :   121093188 :              || OPTS (optimize) >= 3);
    1978                 :             :     }
    1979                 :             : 
    1980                 :             : #undef OPTS
    1981                 :             : #undef OPTS_SET_P
    1982                 :   117178450 : }
    1983                 :             : 
    1984                 :             : /* Implement TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE hook.  */
    1985                 :             : 
    1986                 :             : void
    1987                 :    60417593 : ix86_override_options_after_change (void)
    1988                 :             : {
    1989                 :    60417593 :   ix86_default_align (&global_options);
    1990                 :             : 
    1991                 :    60417593 :   ix86_recompute_optlev_based_flags (&global_options, &global_options_set);
    1992                 :             : 
    1993                 :    60417593 :   ix86_override_options_after_change_1 (&global_options, &global_options_set);
    1994                 :    60417593 : }
    1995                 :             : 
    1996                 :             : /* Clear stack slot assignments remembered from previous functions.
    1997                 :             :    This is called from INIT_EXPANDERS once before RTL is emitted for each
    1998                 :             :    function.  */
    1999                 :             : 
    2000                 :             : static struct machine_function *
    2001                 :   169303716 : ix86_init_machine_status (void)
    2002                 :             : {
    2003                 :   169303716 :   struct machine_function *f;
    2004                 :             : 
    2005                 :   169303716 :   f = ggc_cleared_alloc<machine_function> ();
    2006                 :   169303716 :   f->call_abi = ix86_abi;
    2007                 :   169303716 :   f->stack_frame_required = true;
    2008                 :   169303716 :   f->silent_p = true;
    2009                 :             : 
    2010                 :   169303716 :   return f;
    2011                 :             : }
    2012                 :             : 
    2013                 :             : /* Override various settings based on options.  If MAIN_ARGS_P, the
    2014                 :             :    options are from the command line, otherwise they are from
    2015                 :             :    attributes.  Return true if there's an error related to march
    2016                 :             :    option.  */
    2017                 :             : 
    2018                 :             : static bool
    2019                 :    56760861 : ix86_option_override_internal (bool main_args_p,
    2020                 :             :                                struct gcc_options *opts,
    2021                 :             :                                struct gcc_options *opts_set)
    2022                 :             : {
    2023                 :    56760861 :   unsigned int i;
    2024                 :    56760861 :   unsigned HOST_WIDE_INT ix86_arch_mask, avx512_isa_flags, avx512_isa_flags2;
    2025                 :    56760861 :   const bool ix86_tune_specified = (opts->x_ix86_tune_string != NULL);
    2026                 :             : 
    2027                 :             :   /* -mrecip options.  */
    2028                 :    56760861 :   static struct
    2029                 :             :     {
    2030                 :             :       const char *string;           /* option name */
    2031                 :             :       unsigned int mask;            /* mask bits to set */
    2032                 :             :     }
    2033                 :             :   const recip_options[] =
    2034                 :             :     {
    2035                 :             :       { "all",       RECIP_MASK_ALL },
    2036                 :             :       { "none",      RECIP_MASK_NONE },
    2037                 :             :       { "div",       RECIP_MASK_DIV },
    2038                 :             :       { "sqrt",      RECIP_MASK_SQRT },
    2039                 :             :       { "vec-div",   RECIP_MASK_VEC_DIV },
    2040                 :             :       { "vec-sqrt",  RECIP_MASK_VEC_SQRT },
    2041                 :             :     };
    2042                 :             : 
    2043                 :    56760861 :   avx512_isa_flags = OPTION_MASK_ISA_AVX512F | OPTION_MASK_ISA_AVX512CD
    2044                 :             :     | OPTION_MASK_ISA_AVX512DQ | OPTION_MASK_ISA_AVX512BW
    2045                 :             :     | OPTION_MASK_ISA_AVX512VL | OPTION_MASK_ISA_AVX512IFMA
    2046                 :             :     | OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VBMI2
    2047                 :             :     | OPTION_MASK_ISA_AVX512VNNI | OPTION_MASK_ISA_AVX512VPOPCNTDQ
    2048                 :             :     | OPTION_MASK_ISA_AVX512BITALG;
    2049                 :    56760861 :   avx512_isa_flags2 = OPTION_MASK_ISA2_AVX512FP16
    2050                 :             :     | OPTION_MASK_ISA2_AVX512BF16;
    2051                 :             : 
    2052                 :             :   /* Turn off both OPTION_MASK_ABI_64 and OPTION_MASK_ABI_X32 if
    2053                 :             :      TARGET_64BIT_DEFAULT is true and TARGET_64BIT is false.  */
    2054                 :    56760861 :   if (TARGET_64BIT_DEFAULT && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2055                 :      639431 :     opts->x_ix86_isa_flags &= ~(OPTION_MASK_ABI_64 | OPTION_MASK_ABI_X32);
    2056                 :             : #ifdef TARGET_BI_ARCH
    2057                 :             :   else
    2058                 :             :     {
    2059                 :             : #if TARGET_BI_ARCH == 1
    2060                 :             :       /* When TARGET_BI_ARCH == 1, by default, OPTION_MASK_ABI_64
    2061                 :             :          is on and OPTION_MASK_ABI_X32 is off.  We turn off
    2062                 :             :          OPTION_MASK_ABI_64 if OPTION_MASK_ABI_X32 is turned on by
    2063                 :             :          -mx32.  */
    2064                 :    56121430 :       if (TARGET_X32_P (opts->x_ix86_isa_flags))
    2065                 :          87 :         opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_64;
    2066                 :             : #else
    2067                 :             :       /* When TARGET_BI_ARCH == 2, by default, OPTION_MASK_ABI_X32 is
    2068                 :             :          on and OPTION_MASK_ABI_64 is off.  We turn off
    2069                 :             :          OPTION_MASK_ABI_X32 if OPTION_MASK_ABI_64 is turned on by
    2070                 :             :          -m64 or OPTION_MASK_CODE16 is turned on by -m16.  */
    2071                 :             :       if (TARGET_LP64_P (opts->x_ix86_isa_flags)
    2072                 :             :           || TARGET_16BIT_P (opts->x_ix86_isa_flags))
    2073                 :             :         opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_X32;
    2074                 :             : #endif
    2075                 :    56121430 :       if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2076                 :    56121430 :           && TARGET_IAMCU_P (opts->x_target_flags))
    2077                 :           0 :         sorry ("Intel MCU psABI isn%'t supported in %s mode",
    2078                 :             :                TARGET_X32_P (opts->x_ix86_isa_flags) ? "x32" : "64-bit");
    2079                 :             :     }
    2080                 :             : #endif
    2081                 :             : 
    2082                 :    56760861 :   if (TARGET_X32_P (opts->x_ix86_isa_flags))
    2083                 :             :     {
    2084                 :             :       /* Always turn on OPTION_MASK_ISA_64BIT and turn off
    2085                 :             :          OPTION_MASK_ABI_64 for TARGET_X32.  */
    2086                 :          87 :       opts->x_ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
    2087                 :          87 :       opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_64;
    2088                 :             :     }
    2089                 :    56760774 :   else if (TARGET_16BIT_P (opts->x_ix86_isa_flags))
    2090                 :           5 :     opts->x_ix86_isa_flags &= ~(OPTION_MASK_ISA_64BIT
    2091                 :             :                                 | OPTION_MASK_ABI_X32
    2092                 :             :                                 | OPTION_MASK_ABI_64);
    2093                 :    56760769 :   else if (TARGET_LP64_P (opts->x_ix86_isa_flags))
    2094                 :             :     {
    2095                 :             :       /* Always turn on OPTION_MASK_ISA_64BIT and turn off
    2096                 :             :          OPTION_MASK_ABI_X32 for TARGET_LP64.  */
    2097                 :    56121338 :       opts->x_ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
    2098                 :    56121338 :       opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_X32;
    2099                 :             :     }
    2100                 :             : 
    2101                 :             : #ifdef SUBTARGET_OVERRIDE_OPTIONS
    2102                 :             :   SUBTARGET_OVERRIDE_OPTIONS;
    2103                 :             : #endif
    2104                 :             : 
    2105                 :             : #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
    2106                 :             :   SUBSUBTARGET_OVERRIDE_OPTIONS;
    2107                 :             : #endif
    2108                 :             : 
    2109                 :             : #ifdef HAVE_LD_BROKEN_PE_DWARF5
    2110                 :             :   /* If the PE linker has broken DWARF 5 support, make
    2111                 :             :      DWARF 4 the default.  */
    2112                 :             :   if (TARGET_PECOFF)
    2113                 :             :     SET_OPTION_IF_UNSET (opts, opts_set, dwarf_version, 4);
    2114                 :             : #endif
    2115                 :             : 
    2116                 :             :   /* -fPIC is the default for x86_64.  */
    2117                 :    56760861 :   if (TARGET_MACHO && TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2118                 :             :     opts->x_flag_pic = 2;
    2119                 :             : 
    2120                 :             :   /* Need to check -mtune=generic first.  */
    2121                 :    56760861 :   if (opts->x_ix86_tune_string)
    2122                 :             :     {
    2123                 :             :       /* As special support for cross compilers we read -mtune=native
    2124                 :             :              as -mtune=generic.  With native compilers we won't see the
    2125                 :             :              -mtune=native, as it was changed by the driver.  */
    2126                 :    56743150 :       if (!strcmp (opts->x_ix86_tune_string, "native"))
    2127                 :           0 :         opts->x_ix86_tune_string = "generic";
    2128                 :    56743150 :       else if (!strcmp (opts->x_ix86_tune_string, "x86-64"))
    2129                 :           0 :         warning (OPT_Wdeprecated,
    2130                 :             :                  main_args_p
    2131                 :             :                  ? G_("%<-mtune=x86-64%> is deprecated; use %<-mtune=k8%> "
    2132                 :             :                       "or %<-mtune=generic%> instead as appropriate")
    2133                 :             :                  : G_("%<target(\"tune=x86-64\")%> is deprecated; use "
    2134                 :             :                       "%<target(\"tune=k8\")%> or %<target(\"tune=generic\")%>"
    2135                 :             :                       " instead as appropriate"));
    2136                 :             :     }
    2137                 :             :   else
    2138                 :             :     {
    2139                 :       17711 :       if (opts->x_ix86_arch_string)
    2140                 :       17711 :         opts->x_ix86_tune_string = opts->x_ix86_arch_string;
    2141                 :       17711 :       if (!opts->x_ix86_tune_string)
    2142                 :             :         {
    2143                 :           0 :           opts->x_ix86_tune_string = processor_names[TARGET_CPU_DEFAULT];
    2144                 :           0 :           ix86_tune_defaulted = 1;
    2145                 :             :         }
    2146                 :             : 
    2147                 :             :       /* opts->x_ix86_tune_string is set to opts->x_ix86_arch_string
    2148                 :             :          or defaulted.  We need to use a sensible tune option.  */
    2149                 :       17711 :       if (startswith (opts->x_ix86_tune_string, "x86-64")
    2150                 :       17711 :           && (opts->x_ix86_tune_string[6] == '\0'
    2151                 :         131 :               || (!strcmp (opts->x_ix86_tune_string + 6, "-v2")
    2152                 :         108 :                   || !strcmp (opts->x_ix86_tune_string + 6, "-v3")
    2153                 :          33 :                   || !strcmp (opts->x_ix86_tune_string + 6, "-v4"))))
    2154                 :         287 :         opts->x_ix86_tune_string = "generic";
    2155                 :             :     }
    2156                 :             : 
    2157                 :    56760861 :   if (opts->x_ix86_stringop_alg == rep_prefix_8_byte
    2158                 :          10 :       && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2159                 :             :     {
    2160                 :             :       /* rep; movq isn't available in 32-bit code.  */
    2161                 :           0 :       error ("%<-mstringop-strategy=rep_8byte%> not supported for 32-bit code");
    2162                 :           0 :       opts->x_ix86_stringop_alg = no_stringop;
    2163                 :             :     }
    2164                 :             : 
    2165                 :    56760861 :   if (TARGET_APX_F_P (opts->x_ix86_isa_flags2)
    2166                 :       38668 :       && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2167                 :           0 :     error ("%<-mapxf%> is not supported for 32-bit code");
    2168                 :    56760861 :   else if (opts->x_ix86_apx_features != apx_none
    2169                 :       38681 :            && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2170                 :           0 :     error ("%<-mapx-features=%> option is not supported for 32-bit code");
    2171                 :             : 
    2172                 :    56760861 :   if (TARGET_UINTR_P (opts->x_ix86_isa_flags2)
    2173                 :      141368 :       && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2174                 :           0 :     error ("%<-muintr%> not supported for 32-bit code");
    2175                 :             : 
    2176                 :    56760861 :   if (ix86_lam_type && !TARGET_LP64_P (opts->x_ix86_isa_flags))
    2177                 :           0 :     error ("%<-mlam=%> option: [u48|u57] not supported for 32-bit code");
    2178                 :             : 
    2179                 :    56760861 :   if (!opts->x_ix86_arch_string)
    2180                 :           0 :     opts->x_ix86_arch_string
    2181                 :           0 :       = TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2182                 :           0 :         ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
    2183                 :             :   else
    2184                 :    56760861 :     ix86_arch_specified = 1;
    2185                 :             : 
    2186                 :    56760861 :   if (opts_set->x_ix86_pmode)
    2187                 :             :     {
    2188                 :          63 :       if ((TARGET_LP64_P (opts->x_ix86_isa_flags)
    2189                 :           0 :            && opts->x_ix86_pmode == PMODE_SI)
    2190                 :          63 :           || (!TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2191                 :           0 :                && opts->x_ix86_pmode == PMODE_DI))
    2192                 :           0 :         error ("address mode %qs not supported in the %s bit mode",
    2193                 :             :                TARGET_64BIT_P (opts->x_ix86_isa_flags) ? "short" : "long",
    2194                 :             :                TARGET_64BIT_P (opts->x_ix86_isa_flags) ? "64" : "32");
    2195                 :             :     }
    2196                 :             :   else
    2197                 :    56760798 :     opts->x_ix86_pmode = TARGET_LP64_P (opts->x_ix86_isa_flags)
    2198                 :    56760798 :                          ? PMODE_DI : PMODE_SI;
    2199                 :             : 
    2200                 :    56760861 :   SET_OPTION_IF_UNSET (opts, opts_set, ix86_abi, DEFAULT_ABI);
    2201                 :             : 
    2202                 :    56760861 :   if (opts->x_ix86_abi == MS_ABI && TARGET_X32_P (opts->x_ix86_isa_flags))
    2203                 :           1 :     error ("%<-mabi=ms%> not supported with X32 ABI");
    2204                 :    56760861 :   gcc_assert (opts->x_ix86_abi == SYSV_ABI || opts->x_ix86_abi == MS_ABI);
    2205                 :             : 
    2206                 :    56760861 :   const char *abi_name = opts->x_ix86_abi == MS_ABI ? "ms" : "sysv";
    2207                 :    56760861 :   if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
    2208                 :        2878 :       && opts->x_ix86_abi != DEFAULT_ABI)
    2209                 :           7 :     error ("%<-mabi=%s%> not supported with %<-fsanitize=address%>", abi_name);
    2210                 :    56760861 :   if ((opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
    2211                 :         141 :       && opts->x_ix86_abi != DEFAULT_ABI)
    2212                 :           0 :     error ("%<-mabi=%s%> not supported with %<-fsanitize=kernel-address%>",
    2213                 :             :            abi_name);
    2214                 :    56760861 :   if ((opts->x_flag_sanitize & SANITIZE_THREAD)
    2215                 :         366 :       && opts->x_ix86_abi != DEFAULT_ABI)
    2216                 :           2 :     error ("%<-mabi=%s%> not supported with %<-fsanitize=thread%>", abi_name);
    2217                 :             : 
    2218                 :             :   /* Hwasan is supported with lam_u57 only.  */
    2219                 :    56760861 :   if (opts->x_flag_sanitize & SANITIZE_HWADDRESS)
    2220                 :             :     {
    2221                 :         551 :       if (ix86_lam_type == lam_u48)
    2222                 :           0 :         warning (0, "%<-mlam=u48%> is not compatible with Hardware-assisted "
    2223                 :             :                  "AddressSanitizer, override to %<-mlam=u57%>");
    2224                 :         551 :       ix86_lam_type = lam_u57;
    2225                 :             :     }
    2226                 :             : 
    2227                 :             :   /* For targets using ms ABI enable ms-extensions, if not
    2228                 :             :      explicit turned off.  For non-ms ABI we turn off this
    2229                 :             :      option.  */
    2230                 :    56760861 :   SET_OPTION_IF_UNSET (opts, opts_set, flag_ms_extensions,
    2231                 :             :                        (MS_ABI == DEFAULT_ABI));
    2232                 :             : 
    2233                 :    56760861 :   if (opts_set->x_ix86_cmodel)
    2234                 :             :     {
    2235                 :       37958 :       switch (opts->x_ix86_cmodel)
    2236                 :             :         {
    2237                 :           1 :         case CM_SMALL:
    2238                 :           1 :         case CM_SMALL_PIC:
    2239                 :           1 :           if (opts->x_flag_pic)
    2240                 :           0 :             opts->x_ix86_cmodel = CM_SMALL_PIC;
    2241                 :           1 :           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2242                 :           0 :             error ("code model %qs not supported in the %s bit mode",
    2243                 :             :                    "small", "32");
    2244                 :             :           break;
    2245                 :             : 
    2246                 :       24245 :         case CM_MEDIUM:
    2247                 :       24245 :         case CM_MEDIUM_PIC:
    2248                 :       24245 :           if (opts->x_flag_pic)
    2249                 :       24233 :             opts->x_ix86_cmodel = CM_MEDIUM_PIC;
    2250                 :       24245 :           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2251                 :           0 :             error ("code model %qs not supported in the %s bit mode",
    2252                 :             :                    "medium", "32");
    2253                 :       24245 :           else if (TARGET_X32_P (opts->x_ix86_isa_flags))
    2254                 :           0 :             error ("code model %qs not supported in x32 mode",
    2255                 :             :                    "medium");
    2256                 :             :           break;
    2257                 :             : 
    2258                 :       13711 :         case CM_LARGE:
    2259                 :       13711 :         case CM_LARGE_PIC:
    2260                 :       13711 :           if (opts->x_flag_pic)
    2261                 :          24 :             opts->x_ix86_cmodel = CM_LARGE_PIC;
    2262                 :       13711 :           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2263                 :           0 :             error ("code model %qs not supported in the %s bit mode",
    2264                 :             :                    "large", "32");
    2265                 :       13711 :           else if (TARGET_X32_P (opts->x_ix86_isa_flags))
    2266                 :           0 :             error ("code model %qs not supported in x32 mode",
    2267                 :             :                    "large");
    2268                 :             :           break;
    2269                 :             : 
    2270                 :           0 :         case CM_32:
    2271                 :           0 :           if (opts->x_flag_pic)
    2272                 :           0 :             error ("code model %s does not support PIC mode", "32");
    2273                 :           0 :           if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2274                 :           0 :             error ("code model %qs not supported in the %s bit mode",
    2275                 :             :                    "32", "64");
    2276                 :             :           break;
    2277                 :             : 
    2278                 :           1 :         case CM_KERNEL:
    2279                 :           1 :           if (opts->x_flag_pic)
    2280                 :             :             {
    2281                 :           0 :               error ("code model %s does not support PIC mode", "kernel");
    2282                 :           0 :               opts->x_ix86_cmodel = CM_32;
    2283                 :             :             }
    2284                 :           1 :           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2285                 :           0 :             error ("code model %qs not supported in the %s bit mode",
    2286                 :             :                    "kernel", "32");
    2287                 :             :           break;
    2288                 :             : 
    2289                 :           0 :         default:
    2290                 :           0 :           gcc_unreachable ();
    2291                 :             :         }
    2292                 :             :     }
    2293                 :             :   else
    2294                 :             :     {
    2295                 :             :       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
    2296                 :             :          use of rip-relative addressing.  This eliminates fixups that
    2297                 :             :          would otherwise be needed if this object is to be placed in a
    2298                 :             :          DLL, and is essentially just as efficient as direct addressing.  */
    2299                 :    56722903 :       if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2300                 :             :           && (TARGET_RDOS || TARGET_PECOFF))
    2301                 :             :         opts->x_ix86_cmodel = CM_MEDIUM_PIC, opts->x_flag_pic = 1;
    2302                 :    56722903 :       else if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2303                 :   111821103 :         opts->x_ix86_cmodel = opts->x_flag_pic ? CM_SMALL_PIC : CM_SMALL;
    2304                 :             :       else
    2305                 :      639436 :         opts->x_ix86_cmodel = CM_32;
    2306                 :             :     }
    2307                 :    56760861 :   if (TARGET_MACHO && opts->x_ix86_asm_dialect == ASM_INTEL)
    2308                 :             :     {
    2309                 :             :       error ("%<-masm=intel%> not supported in this configuration");
    2310                 :             :       opts->x_ix86_asm_dialect = ASM_ATT;
    2311                 :             :     }
    2312                 :    56760861 :   if ((TARGET_64BIT_P (opts->x_ix86_isa_flags) != 0)
    2313                 :             :       != ((opts->x_ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
    2314                 :             :     sorry ("%i-bit mode not compiled in",
    2315                 :             :            (opts->x_ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
    2316                 :             : 
    2317                 :             :   /* Last processor_alias_table must point to "generic" entry.  */
    2318                 :    56760861 :   gcc_checking_assert (strcmp (processor_alias_table[pta_size - 1].name,
    2319                 :             :                                "generic") == 0);
    2320                 :  4411862372 :   for (i = 0; i < pta_size; i++)
    2321                 :  4411862367 :     if (! strcmp (opts->x_ix86_arch_string, processor_alias_table[i].name))
    2322                 :             :       {
    2323                 :    56760856 :         if (!strcmp (opts->x_ix86_arch_string, "generic"))
    2324                 :             :           {
    2325                 :           2 :             error (main_args_p
    2326                 :             :                    ? G_("%<generic%> CPU can be used only for %<-mtune=%> "
    2327                 :             :                         "switch")
    2328                 :             :                    : G_("%<generic%> CPU can be used only for "
    2329                 :             :                         "%<target(\"tune=\")%> attribute"));
    2330                 :           2 :             return false;
    2331                 :             :           }
    2332                 :    56760854 :         else if (!strcmp (opts->x_ix86_arch_string, "intel"))
    2333                 :             :           {
    2334                 :           1 :             error (main_args_p
    2335                 :             :                    ? G_("%<intel%> CPU can be used only for %<-mtune=%> "
    2336                 :             :                         "switch")
    2337                 :             :                    : G_("%<intel%> CPU can be used only for "
    2338                 :             :                         "%<target(\"tune=\")%> attribute"));
    2339                 :           1 :             return false;
    2340                 :             :           }
    2341                 :             : 
    2342                 :    56760853 :         if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2343                 :    56760853 :             && !((processor_alias_table[i].flags & PTA_64BIT) != 0))
    2344                 :             :           {
    2345                 :           1 :             error ("CPU you selected does not support x86-64 "
    2346                 :             :                    "instruction set");
    2347                 :           1 :             return false;
    2348                 :             :           }
    2349                 :             : 
    2350                 :    56760852 :         ix86_schedule = processor_alias_table[i].schedule;
    2351                 :    56760852 :         ix86_arch = processor_alias_table[i].processor;
    2352                 :             : 
    2353                 :             :         /* Default cpu tuning to the architecture, unless the table
    2354                 :             :            entry requests not to do this.  Used by the x86-64 psABI
    2355                 :             :            micro-architecture levels.  */
    2356                 :    56760852 :         if ((processor_alias_table[i].flags & PTA_NO_TUNE) == 0)
    2357                 :    56425967 :           ix86_tune = ix86_arch;
    2358                 :             :         else
    2359                 :      334885 :           ix86_tune = PROCESSOR_GENERIC;
    2360                 :             : 
    2361                 :             :         /* Enable PTA flags that are enabled by default by a -march option.  */
    2362                 :             : #define TARGET_EXPLICIT_NO_SAHF_P(opts) (false)
    2363                 :             : #define SET_TARGET_NO_SAHF(opts) {}
    2364                 :             : #define TARGET_EXPLICIT_PREFETCH_SSE_P(opts) (false)
    2365                 :             : #define SET_TARGET_PREFETCH_SSE(opts) {}
    2366                 :             : #define TARGET_EXPLICIT_NO_TUNE_P(opts) (false)
    2367                 :             : #define SET_TARGET_NO_TUNE(opts) {}
    2368                 :             : #define TARGET_EXPLICIT_NO_80387_P(opts) (false)
    2369                 :             : #define SET_TARGET_NO_80387(opts) {}
    2370                 :             : 
    2371                 :             : #define DEF_PTA(NAME) \
    2372                 :             :         if (((processor_alias_table[i].flags & PTA_ ## NAME) != 0) \
    2373                 :             :             && PTA_ ## NAME != PTA_64BIT \
    2374                 :             :             && (TARGET_64BIT || (PTA_ ## NAME != PTA_UINTR \
    2375                 :             :                                  && PTA_ ## NAME != PTA_APX_F))\
    2376                 :             :             && !TARGET_EXPLICIT_ ## NAME ## _P (opts)) \
    2377                 :             :           SET_TARGET_ ## NAME (opts);
    2378                 :             : #include "i386-isa.def"
    2379                 :             : #undef DEF_PTA
    2380                 :             : 
    2381                 :             : 
    2382                 :    56760852 :        if (!(TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2383                 :    56121416 :              && ((processor_alias_table[i].flags & PTA_NO_SAHF) != 0))
    2384                 :    57592174 :            && !TARGET_EXPLICIT_SAHF_P (opts))
    2385                 :     1470747 :             SET_TARGET_SAHF (opts);
    2386                 :             : 
    2387                 :    56760852 :         if (((processor_alias_table[i].flags & PTA_ABM) != 0)
    2388                 :       10183 :             && !TARGET_EXPLICIT_ABM_P (opts))
    2389                 :             :           {
    2390                 :       10172 :             if (!TARGET_EXPLICIT_LZCNT_P (opts))
    2391                 :       10171 :               SET_TARGET_LZCNT (opts);
    2392                 :       10172 :             if (!TARGET_EXPLICIT_POPCNT_P (opts))
    2393                 :        9739 :               SET_TARGET_POPCNT (opts);
    2394                 :             :           }
    2395                 :             : 
    2396                 :             :         /* Enable apx if apxf or apx_features are not
    2397                 :             :            explicitly set for -march.  */
    2398                 :    56760852 :         if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2399                 :    56121416 :              && ((processor_alias_table[i].flags & PTA_APX_F) != 0)
    2400                 :          10 :              && !TARGET_EXPLICIT_APX_F_P (opts)
    2401                 :    56760862 :              && !OPTION_SET_P (ix86_apx_features))
    2402                 :          10 :           opts->x_ix86_apx_features = apx_all;
    2403                 :             : 
    2404                 :    56760852 :         if ((processor_alias_table[i].flags
    2405                 :    56760852 :            & (PTA_PREFETCH_SSE | PTA_SSE)) != 0)
    2406                 :    56760852 :           ix86_prefetch_sse = true;
    2407                 :             : 
    2408                 :             :         /* Don't enable x87 instructions if only general registers are
    2409                 :             :            allowed by target("general-regs-only") function attribute or
    2410                 :             :            -mgeneral-regs-only.  */
    2411                 :    56760852 :         if (!(opts->x_ix86_target_flags & OPTION_MASK_GENERAL_REGS_ONLY)
    2412                 :    54573744 :             && !(opts_set->x_target_flags & MASK_80387))
    2413                 :             :           {
    2414                 :    54573724 :             if (((processor_alias_table[i].flags & PTA_NO_80387) != 0))
    2415                 :           0 :               opts->x_target_flags &= ~MASK_80387;
    2416                 :             :             else
    2417                 :    54573724 :               opts->x_target_flags |= MASK_80387;
    2418                 :             :           }
    2419                 :             :         break;
    2420                 :             :       }
    2421                 :             : 
    2422                 :    56760857 :   if (i == pta_size)
    2423                 :             :     {
    2424                 :           7 :       error (main_args_p
    2425                 :             :              ? G_("bad value %qs for %<-march=%> switch")
    2426                 :             :              : G_("bad value %qs for %<target(\"arch=\")%> attribute"),
    2427                 :             :              opts->x_ix86_arch_string);
    2428                 :             : 
    2429                 :           5 :       auto_vec <const char *> candidates;
    2430                 :         570 :       for (i = 0; i < pta_size; i++)
    2431                 :         565 :         if (strcmp (processor_alias_table[i].name, "generic")
    2432                 :         560 :             && strcmp (processor_alias_table[i].name, "intel")
    2433                 :        1120 :             && (!TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2434                 :         960 :                 || ((processor_alias_table[i].flags & PTA_64BIT) != 0)))
    2435                 :         395 :           candidates.safe_push (processor_alias_table[i].name);
    2436                 :             : 
    2437                 :             : #ifdef HAVE_LOCAL_CPU_DETECT
    2438                 :             :       /* Add also "native" as possible value.  */
    2439                 :           5 :       candidates.safe_push ("native");
    2440                 :             : #endif
    2441                 :             : 
    2442                 :           5 :       char *s;
    2443                 :           5 :       const char *hint
    2444                 :           5 :         = candidates_list_and_hint (opts->x_ix86_arch_string, s, candidates);
    2445                 :           5 :       if (hint)
    2446                 :           3 :         inform (input_location,
    2447                 :             :                 main_args_p
    2448                 :             :                 ? G_("valid arguments to %<-march=%> switch are: "
    2449                 :             :                      "%s; did you mean %qs?")
    2450                 :             :                 : G_("valid arguments to %<target(\"arch=\")%> attribute are: "
    2451                 :             :                      "%s; did you mean %qs?"), s, hint);
    2452                 :             :       else
    2453                 :           4 :         inform (input_location,
    2454                 :             :                 main_args_p
    2455                 :             :                 ? G_("valid arguments to %<-march=%> switch are: %s")
    2456                 :             :                 : G_("valid arguments to %<target(\"arch=\")%> attribute "
    2457                 :             :                      "are: %s"), s);
    2458                 :           5 :       XDELETEVEC (s);
    2459                 :           5 :     }
    2460                 :             : 
    2461                 :    56760857 :   ix86_arch_mask = HOST_WIDE_INT_1U << ix86_arch;
    2462                 :   340565142 :   for (i = 0; i < X86_ARCH_LAST; ++i)
    2463                 :   283804285 :     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
    2464                 :             : 
    2465                 :  6348907731 :   for (i = 0; i < pta_size; i++)
    2466                 :  6348907722 :     if (! strcmp (opts->x_ix86_tune_string, processor_alias_table[i].name)
    2467                 :  6348907722 :         && (processor_alias_table[i].flags & PTA_NO_TUNE) == 0)
    2468                 :             :       {
    2469                 :    56760848 :         ix86_schedule = processor_alias_table[i].schedule;
    2470                 :    56760848 :         ix86_tune = processor_alias_table[i].processor;
    2471                 :    56760848 :         if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2472                 :             :           {
    2473                 :    56121412 :             if (!((processor_alias_table[i].flags & PTA_64BIT) != 0))
    2474                 :             :               {
    2475                 :           0 :                 if (ix86_tune_defaulted)
    2476                 :             :                   {
    2477                 :           0 :                     opts->x_ix86_tune_string = "x86-64";
    2478                 :           0 :                     for (i = 0; i < pta_size; i++)
    2479                 :           0 :                       if (! strcmp (opts->x_ix86_tune_string,
    2480                 :           0 :                                     processor_alias_table[i].name))
    2481                 :             :                         break;
    2482                 :           0 :                     ix86_schedule = processor_alias_table[i].schedule;
    2483                 :           0 :                     ix86_tune = processor_alias_table[i].processor;
    2484                 :             :                   }
    2485                 :             :                 else
    2486                 :           0 :                   error ("CPU you selected does not support x86-64 "
    2487                 :             :                          "instruction set");
    2488                 :             :               }
    2489                 :             :           }
    2490                 :             :         /* Intel CPUs have always interpreted SSE prefetch instructions as
    2491                 :             :            NOPs; so, we can enable SSE prefetch instructions even when
    2492                 :             :            -mtune (rather than -march) points us to a processor that has them.
    2493                 :             :            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
    2494                 :             :            higher processors.  */
    2495                 :    56760848 :         if (TARGET_CMOV
    2496                 :    56760848 :             && ((processor_alias_table[i].flags
    2497                 :    56760848 :               & (PTA_PREFETCH_SSE | PTA_SSE)) != 0))
    2498                 :     1045775 :           ix86_prefetch_sse = true;
    2499                 :             :         break;
    2500                 :             :       }
    2501                 :             : 
    2502                 :    56760857 :   if (ix86_tune_specified && i == pta_size)
    2503                 :             :     {
    2504                 :           6 :       error (main_args_p
    2505                 :             :              ? G_("bad value %qs for %<-mtune=%> switch")
    2506                 :             :              : G_("bad value %qs for %<target(\"tune=\")%> attribute"),
    2507                 :             :              opts->x_ix86_tune_string);
    2508                 :             : 
    2509                 :           4 :       auto_vec <const char *> candidates;
    2510                 :         456 :       for (i = 0; i < pta_size; i++)
    2511                 :         452 :         if ((!TARGET_64BIT_P (opts->x_ix86_isa_flags)
    2512                 :         452 :              || ((processor_alias_table[i].flags & PTA_64BIT) != 0))
    2513                 :        1216 :             && (processor_alias_table[i].flags & PTA_NO_TUNE) == 0)
    2514                 :         312 :           candidates.safe_push (processor_alias_table[i].name);
    2515                 :             : 
    2516                 :             : #ifdef HAVE_LOCAL_CPU_DETECT
    2517                 :             :       /* Add also "native" as possible value.  */
    2518                 :           4 :       candidates.safe_push ("native");
    2519                 :             : #endif
    2520                 :             : 
    2521                 :           4 :       char *s;
    2522                 :           4 :       const char *hint
    2523                 :           4 :         = candidates_list_and_hint (opts->x_ix86_tune_string, s, candidates);
    2524                 :           4 :       if (hint)
    2525                 :           1 :         inform (input_location,
    2526                 :             :                 main_args_p
    2527                 :             :                 ? G_("valid arguments to %<-mtune=%> switch are: "
    2528                 :             :                      "%s; did you mean %qs?")
    2529                 :             :                 : G_("valid arguments to %<target(\"tune=\")%> attribute are: "
    2530                 :             :                      "%s; did you mean %qs?"), s, hint);
    2531                 :             :       else
    2532                 :           5 :         inform (input_location,
    2533                 :             :                 main_args_p
    2534                 :             :                 ? G_("valid arguments to %<-mtune=%> switch are: %s")
    2535                 :             :                 : G_("valid arguments to %<target(\"tune=\")%> attribute "
    2536                 :             :                      "are: %s"), s);
    2537                 :           4 :       XDELETEVEC (s);
    2538                 :           4 :     }
    2539                 :             : 
    2540                 :    56760857 :   set_ix86_tune_features (opts, ix86_tune, opts->x_ix86_dump_tunes);
    2541                 :             : 
    2542                 :    56760857 :   ix86_recompute_optlev_based_flags (opts, opts_set);
    2543                 :             : 
    2544                 :    56760857 :   ix86_override_options_after_change_1 (opts, opts_set);
    2545                 :             : 
    2546                 :    56760857 :   ix86_tune_cost = processor_cost_table[ix86_tune];
    2547                 :             :   /* TODO: ix86_cost should be chosen at instruction or function granuality
    2548                 :             :      so for cold code we use size_cost even in !optimize_size compilation.  */
    2549                 :    56760857 :   if (opts->x_optimize_size)
    2550                 :      771390 :     ix86_cost = &ix86_size_cost;
    2551                 :             :   else
    2552                 :    55989467 :     ix86_cost = ix86_tune_cost;
    2553                 :             : 
    2554                 :             :   /* Arrange to set up i386_stack_locals for all functions.  */
    2555                 :    56760857 :   init_machine_status = ix86_init_machine_status;
    2556                 :             : 
    2557                 :             :   /* Override APX flag here if ISA bit is set.  */
    2558                 :    56760857 :   if (TARGET_APX_F_P (opts->x_ix86_isa_flags2)
    2559                 :       38678 :       && !OPTION_SET_P (ix86_apx_features))
    2560                 :       38678 :     opts->x_ix86_apx_features = apx_all;
    2561                 :             : 
    2562                 :             :   /* Validate -mregparm= value.  */
    2563                 :    56760857 :   if (opts_set->x_ix86_regparm)
    2564                 :             :     {
    2565                 :           0 :       if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2566                 :           0 :         warning (0, "%<-mregparm%> is ignored in 64-bit mode");
    2567                 :           0 :       else if (TARGET_IAMCU_P (opts->x_target_flags))
    2568                 :           0 :         warning (0, "%<-mregparm%> is ignored for Intel MCU psABI");
    2569                 :           0 :       if (opts->x_ix86_regparm > REGPARM_MAX)
    2570                 :             :         {
    2571                 :           0 :           error ("%<-mregparm=%d%> is not between 0 and %d",
    2572                 :           0 :                  opts->x_ix86_regparm, REGPARM_MAX);
    2573                 :           0 :           opts->x_ix86_regparm = 0;
    2574                 :             :         }
    2575                 :             :     }
    2576                 :    56760857 :   if (TARGET_IAMCU_P (opts->x_target_flags)
    2577                 :    56760857 :       || TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2578                 :   112168744 :     opts->x_ix86_regparm = REGPARM_MAX;
    2579                 :             : 
    2580                 :             :   /* Default align_* from the processor table.  */
    2581                 :    56760857 :   ix86_default_align (&global_options);
    2582                 :             : 
    2583                 :             :   /* Provide default for -mbranch-cost= value.  */
    2584                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, ix86_branch_cost,
    2585                 :             :                        ix86_tune_cost->branch_cost);
    2586                 :             : 
    2587                 :    56760857 :   if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2588                 :             :     {
    2589                 :    56121421 :       opts->x_target_flags
    2590                 :    56121421 :         |= TARGET_SUBTARGET64_DEFAULT & ~opts_set->x_target_flags;
    2591                 :             : 
    2592                 :    56121421 :       if (!ix86_arch_specified)
    2593                 :           0 :         opts->x_ix86_isa_flags
    2594                 :           0 :           |= TARGET_SUBTARGET64_ISA_DEFAULT & ~opts->x_ix86_isa_flags_explicit;
    2595                 :             : 
    2596                 :    56121421 :       if (!TARGET_128BIT_LONG_DOUBLE_P (opts->x_target_flags))
    2597                 :           1 :         error ("%<-m96bit-long-double%> is not compatible with this target");
    2598                 :             : 
    2599                 :    56121421 :       if (TARGET_RTD_P (opts->x_target_flags))
    2600                 :           0 :         warning (0,
    2601                 :             :                  main_args_p
    2602                 :             :                  ? G_("%<-mrtd%> is ignored in 64bit mode")
    2603                 :             :                  : G_("%<target(\"rtd\")%> is ignored in 64bit mode"));
    2604                 :             :     }
    2605                 :             :   else
    2606                 :             :     {
    2607                 :      639436 :       opts->x_target_flags
    2608                 :             :         |= TARGET_SUBTARGET32_DEFAULT & ~opts_set->x_target_flags;
    2609                 :             : 
    2610                 :      639436 :       if (!ix86_arch_specified)
    2611                 :      639436 :         opts->x_ix86_isa_flags
    2612                 :             :           |= TARGET_SUBTARGET32_ISA_DEFAULT & ~opts->x_ix86_isa_flags_explicit;
    2613                 :             : 
    2614                 :             :       /* i386 ABI does not specify red zone.  It still makes sense to use it
    2615                 :             :          when programmer takes care to stack from being destroyed.  */
    2616                 :      639436 :       if (!(opts_set->x_target_flags & MASK_NO_RED_ZONE))
    2617                 :      639436 :         opts->x_target_flags |= MASK_NO_RED_ZONE;
    2618                 :             :     }
    2619                 :             : 
    2620                 :             :   /* If we're doing fast math, we don't care about comparison order
    2621                 :             :      wrt NaNs.  This lets us use a shorter comparison sequence.  */
    2622                 :    56760857 :   if (opts->x_flag_finite_math_only)
    2623                 :     1133298 :     opts->x_target_flags &= ~MASK_IEEE_FP;
    2624                 :             : 
    2625                 :             :   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
    2626                 :             :      since the insns won't need emulation.  */
    2627                 :    56760857 :   if (ix86_tune_features [X86_TUNE_ALWAYS_FANCY_MATH_387])
    2628                 :    56760857 :     opts->x_target_flags &= ~MASK_NO_FANCY_MATH_387;
    2629                 :             : 
    2630                 :             :   /* Likewise, if the target doesn't have a 387, or we've specified
    2631                 :             :      software floating point, don't use 387 inline intrinsics.  */
    2632                 :    56760857 :   if (!TARGET_80387_P (opts->x_target_flags))
    2633                 :     2187123 :     opts->x_target_flags |= MASK_NO_FANCY_MATH_387;
    2634                 :             : 
    2635                 :             :   /* Turn on MMX builtins for -msse.  */
    2636                 :    56760857 :   if (TARGET_SSE_P (opts->x_ix86_isa_flags))
    2637                 :    54634473 :     opts->x_ix86_isa_flags
    2638                 :    54634473 :       |= OPTION_MASK_ISA_MMX & ~opts->x_ix86_isa_flags_explicit;
    2639                 :             : 
    2640                 :             :   /* Enable SSE prefetch.  */
    2641                 :    56760857 :   if (TARGET_SSE_P (opts->x_ix86_isa_flags)
    2642                 :     2126384 :       || (TARGET_PRFCHW_P (opts->x_ix86_isa_flags)
    2643                 :             :           && !TARGET_3DNOW_P (opts->x_ix86_isa_flags)))
    2644                 :    54652798 :     ix86_prefetch_sse = true;
    2645                 :             : 
    2646                 :             :   /* Enable mwait/monitor instructions for -msse3.  */
    2647                 :    56760857 :   if (TARGET_SSE3_P (opts->x_ix86_isa_flags))
    2648                 :    54293146 :     opts->x_ix86_isa_flags2
    2649                 :    54293146 :       |= OPTION_MASK_ISA2_MWAIT & ~opts->x_ix86_isa_flags2_explicit;
    2650                 :             : 
    2651                 :             :   /* Enable popcnt instruction for -msse4.2 or -mabm.  */
    2652                 :    56760857 :   if (TARGET_SSE4_2_P (opts->x_ix86_isa_flags)
    2653                 :             :       || TARGET_ABM_P (opts->x_ix86_isa_flags))
    2654                 :    54200326 :     opts->x_ix86_isa_flags
    2655                 :    54200326 :       |= OPTION_MASK_ISA_POPCNT & ~opts->x_ix86_isa_flags_explicit;
    2656                 :             : 
    2657                 :             :   /* Enable crc32 instruction for -msse4.2.  */
    2658                 :    56760857 :   if (TARGET_SSE4_2_P (opts->x_ix86_isa_flags))
    2659                 :    54194521 :     opts->x_ix86_isa_flags
    2660                 :    54194521 :       |= OPTION_MASK_ISA_CRC32 & ~opts->x_ix86_isa_flags_explicit;
    2661                 :             : 
    2662                 :             :   /* Enable lzcnt instruction for -mabm.  */
    2663                 :    56760857 :   if (TARGET_ABM_P(opts->x_ix86_isa_flags))
    2664                 :      129122 :     opts->x_ix86_isa_flags
    2665                 :      129122 :       |= OPTION_MASK_ISA_LZCNT & ~opts->x_ix86_isa_flags_explicit;
    2666                 :             : 
    2667                 :             :   /* Disable BMI, BMI2 and TBM instructions for -m16.  */
    2668                 :    56760857 :   if (TARGET_16BIT_P(opts->x_ix86_isa_flags))
    2669                 :           5 :     opts->x_ix86_isa_flags
    2670                 :           5 :       &= ~((OPTION_MASK_ISA_BMI | OPTION_MASK_ISA_BMI2 | OPTION_MASK_ISA_TBM)
    2671                 :           5 :            & ~opts->x_ix86_isa_flags_explicit);
    2672                 :             : 
    2673                 :             :   /* Emit a warning if AVX10.1 options is used with AVX512/EVEX512 options except
    2674                 :             :      for the following option combinations:
    2675                 :             :      1. Both AVX10.1-512 and AVX512 with 512 bit vector width are enabled with no
    2676                 :             :         explicit disable on other AVX512 features.
    2677                 :             :      2. Both AVX10.1-256 and AVX512 w/o 512 bit vector width are enabled with no
    2678                 :             :         explicit disable on other AVX512 features.
    2679                 :             :      3. Both AVX10.1 and AVX512 are disabled.  */
    2680                 :    56760857 :   if (TARGET_AVX10_1_512_P (opts->x_ix86_isa_flags2))
    2681                 :             :     {
    2682                 :     2607397 :       if (opts->x_ix86_no_avx512_explicit
    2683                 :      183701 :           && (((~(avx512_isa_flags & opts->x_ix86_isa_flags)
    2684                 :      183701 :                & (avx512_isa_flags & opts->x_ix86_isa_flags_explicit)))
    2685                 :      183338 :               || ((~((avx512_isa_flags2 | OPTION_MASK_ISA2_EVEX512)
    2686                 :      183338 :                      & opts->x_ix86_isa_flags2)
    2687                 :      183338 :                    & ((avx512_isa_flags2 | OPTION_MASK_ISA2_EVEX512)
    2688                 :      183338 :                       & opts->x_ix86_isa_flags2_explicit)))))
    2689                 :      162493 :         warning (0, "%<-mno-evex512%> or %<-mno-avx512XXX%> cannot disable "
    2690                 :             :                     "AVX10 instructions when AVX10.1-512 is available");
    2691                 :             :     }
    2692                 :    54153460 :   else if (TARGET_AVX10_1_256_P (opts->x_ix86_isa_flags2))
    2693                 :             :     {
    2694                 :     8006278 :       if (TARGET_EVEX512_P (opts->x_ix86_isa_flags2)
    2695                 :     6555208 :           && (OPTION_MASK_ISA2_EVEX512 & opts->x_ix86_isa_flags2_explicit))
    2696                 :             :         {
    2697                 :       83027 :           if (!TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    2698                 :       83025 :               || !(OPTION_MASK_ISA_AVX512F & opts->x_ix86_isa_flags_explicit))
    2699                 :             :             {
    2700                 :             :               /* We should not emit 512 bit instructions under AVX10.1-256
    2701                 :             :                  when EVEX512 is enabled w/o any AVX512 features enabled.
    2702                 :             :                  Disable EVEX512 bit for this.  */
    2703                 :           3 :               warning (0, "Using %<-mevex512%> without any AVX512 features "
    2704                 :             :                           "enabled together with AVX10.1 only will not enable "
    2705                 :             :                           "any AVX512 or AVX10.1-512 features, using 256 as "
    2706                 :             :                           "max vector size");
    2707                 :           3 :               opts->x_ix86_isa_flags2 &= ~OPTION_MASK_ISA2_EVEX512;
    2708                 :             :             }
    2709                 :             :           else
    2710                 :       83024 :             warning (0, "Vector size conflicts between AVX10.1 and AVX512, "
    2711                 :             :                         "using 512 as max vector size");
    2712                 :             :         }
    2713                 :     7923251 :       else if (TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    2714                 :     7909871 :                && !(OPTION_MASK_ISA2_EVEX512
    2715                 :     7909871 :                     & opts->x_ix86_isa_flags2_explicit))
    2716                 :     7907003 :         warning (0, "Vector size conflicts between AVX10.1 and AVX512, using "
    2717                 :             :                     "512 as max vector size");
    2718                 :       16248 :       else if (opts->x_ix86_no_avx512_explicit
    2719                 :        2980 :                && (((~(avx512_isa_flags & opts->x_ix86_isa_flags)
    2720                 :        2980 :                     & (avx512_isa_flags & opts->x_ix86_isa_flags_explicit)))
    2721                 :        2868 :                    || ((~(avx512_isa_flags2 & opts->x_ix86_isa_flags2)
    2722                 :        2868 :                         & (avx512_isa_flags2
    2723                 :        2868 :                            & opts->x_ix86_isa_flags2_explicit)))))
    2724                 :         112 :         warning (0, "%<-mno-avx512XXX%> cannot disable AVX10 instructions "
    2725                 :             :                     "when AVX10 is available");
    2726                 :             :     }
    2727                 :    46147182 :   else if (TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    2728                 :    42221635 :            && (OPTION_MASK_ISA_AVX512F & opts->x_ix86_isa_flags_explicit))
    2729                 :             :     {
    2730                 :    42209531 :       if (opts->x_ix86_no_avx10_1_explicit
    2731                 :           3 :           && ((OPTION_MASK_ISA2_AVX10_1_256 | OPTION_MASK_ISA2_AVX10_1_512)
    2732                 :           3 :               & opts->x_ix86_isa_flags2_explicit))
    2733                 :             :         {
    2734                 :           3 :           warning (0, "%<-mno-avx10.1, -mno-avx10.1-256, -mno-avx10.1-512%> "
    2735                 :             :                       "cannot disable AVX512 instructions when "
    2736                 :             :                       "%<-mavx512XXX%>");
    2737                 :             :           /* Reset those unset AVX512 flags set by AVX10 options when AVX10 is
    2738                 :             :              disabled.  */
    2739                 :           3 :           if (OPTION_MASK_ISA2_AVX10_1_256 & opts->x_ix86_isa_flags2_explicit)
    2740                 :             :             {
    2741                 :           1 :               opts->x_ix86_isa_flags = (~avx512_isa_flags
    2742                 :           1 :                                         & opts->x_ix86_isa_flags)
    2743                 :             :                 | (avx512_isa_flags & opts->x_ix86_isa_flags
    2744                 :           1 :                    & opts->x_ix86_isa_flags_explicit);
    2745                 :           1 :               opts->x_ix86_isa_flags2 = (~avx512_isa_flags2
    2746                 :           1 :                                          & opts->x_ix86_isa_flags2)
    2747                 :             :                 | (avx512_isa_flags2 & opts->x_ix86_isa_flags2
    2748                 :             :                    & opts->x_ix86_isa_flags2_explicit);
    2749                 :             :             }
    2750                 :             :         }
    2751                 :             :     }
    2752                 :             : 
    2753                 :             :   /* Set EVEX512 if one of the following conditions meets:
    2754                 :             :      1. AVX512 is enabled while EVEX512 is not explicitly set/unset.
    2755                 :             :      2. AVX10.1-512 is enabled.  */
    2756                 :    56760857 :   if (TARGET_AVX10_1_512_P (opts->x_ix86_isa_flags2)
    2757                 :    54153460 :       || (TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    2758                 :    50214531 :           && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_EVEX512)))
    2759                 :    11651148 :     opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA2_EVEX512;
    2760                 :             : 
    2761                 :             :   /* Enable all AVX512 related ISAs when AVX10.1 is enabled.  */
    2762                 :    56760857 :   if (TARGET_AVX10_1_256_P (opts->x_ix86_isa_flags2))
    2763                 :             :     {
    2764                 :    10613665 :       opts->x_ix86_isa_flags |= avx512_isa_flags;
    2765                 :    10613665 :       opts->x_ix86_isa_flags2 |= avx512_isa_flags2;
    2766                 :             :     }
    2767                 :             : 
    2768                 :             :   /* Validate -mpreferred-stack-boundary= value or default it to
    2769                 :             :      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
    2770                 :    56760857 :   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
    2771                 :    56760857 :   if (opts_set->x_ix86_preferred_stack_boundary_arg)
    2772                 :             :     {
    2773                 :        1616 :       int min = TARGET_64BIT_P (opts->x_ix86_isa_flags)? 3 : 2;
    2774                 :        1616 :       int max = TARGET_SEH ? 4 : 12;
    2775                 :             : 
    2776                 :        1616 :       if (opts->x_ix86_preferred_stack_boundary_arg < min
    2777                 :        1616 :           || opts->x_ix86_preferred_stack_boundary_arg > max)
    2778                 :             :         {
    2779                 :           0 :           if (min == max)
    2780                 :             :             error ("%<-mpreferred-stack-boundary%> is not supported "
    2781                 :             :                    "for this target");
    2782                 :             :           else
    2783                 :           0 :             error ("%<-mpreferred-stack-boundary=%d%> is not between %d and %d",
    2784                 :             :                    opts->x_ix86_preferred_stack_boundary_arg, min, max);
    2785                 :             :         }
    2786                 :             :       else
    2787                 :        1616 :         ix86_preferred_stack_boundary
    2788                 :        1616 :           = (1 << opts->x_ix86_preferred_stack_boundary_arg) * BITS_PER_UNIT;
    2789                 :             :     }
    2790                 :             : 
    2791                 :             :   /* Set the default value for -mstackrealign.  */
    2792                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, ix86_force_align_arg_pointer,
    2793                 :             :                        STACK_REALIGN_DEFAULT);
    2794                 :             : 
    2795                 :    56760857 :   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
    2796                 :             : 
    2797                 :             :   /* Validate -mincoming-stack-boundary= value or default it to
    2798                 :             :      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
    2799                 :    56760857 :   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
    2800                 :    56760857 :   if (opts_set->x_ix86_incoming_stack_boundary_arg)
    2801                 :             :     {
    2802                 :          15 :       int min = TARGET_64BIT_P (opts->x_ix86_isa_flags) ? 3 : 2;
    2803                 :             : 
    2804                 :          15 :       if (opts->x_ix86_incoming_stack_boundary_arg < min
    2805                 :          15 :           || opts->x_ix86_incoming_stack_boundary_arg > 12)
    2806                 :           0 :         error ("%<-mincoming-stack-boundary=%d%> is not between %d and 12",
    2807                 :             :                opts->x_ix86_incoming_stack_boundary_arg, min);
    2808                 :             :       else
    2809                 :             :         {
    2810                 :          15 :           ix86_user_incoming_stack_boundary
    2811                 :          15 :             = (1 << opts->x_ix86_incoming_stack_boundary_arg) * BITS_PER_UNIT;
    2812                 :          15 :           ix86_incoming_stack_boundary
    2813                 :          15 :             = ix86_user_incoming_stack_boundary;
    2814                 :             :         }
    2815                 :             :     }
    2816                 :             : 
    2817                 :             : #ifndef NO_PROFILE_COUNTERS
    2818                 :             :   if (flag_nop_mcount)
    2819                 :             :     error ("%<-mnop-mcount%> is not compatible with this target");
    2820                 :             : #endif
    2821                 :    56760857 :   if (flag_nop_mcount && flag_pic)
    2822                 :           0 :     error ("%<-mnop-mcount%> is not implemented for %<-fPIC%>");
    2823                 :             : 
    2824                 :             :   /* Accept -msseregparm only if at least SSE support is enabled.  */
    2825                 :    56760857 :   if (TARGET_SSEREGPARM_P (opts->x_target_flags)
    2826                 :           0 :       && ! TARGET_SSE_P (opts->x_ix86_isa_flags))
    2827                 :           0 :     error (main_args_p
    2828                 :             :            ? G_("%<-msseregparm%> used without SSE enabled")
    2829                 :             :            : G_("%<target(\"sseregparm\")%> used without SSE enabled"));
    2830                 :             : 
    2831                 :    56760857 :   if (opts_set->x_ix86_fpmath)
    2832                 :             :     {
    2833                 :     1366188 :       if (opts->x_ix86_fpmath & FPMATH_SSE)
    2834                 :             :         {
    2835                 :     1321708 :           if (!TARGET_SSE_P (opts->x_ix86_isa_flags))
    2836                 :             :             {
    2837                 :       42542 :               if (TARGET_80387_P (opts->x_target_flags))
    2838                 :             :                 {
    2839                 :           0 :                   warning (0, "SSE instruction set disabled, using 387 arithmetics");
    2840                 :           0 :                   opts->x_ix86_fpmath = FPMATH_387;
    2841                 :             :                 }
    2842                 :             :             }
    2843                 :     1279166 :           else if ((opts->x_ix86_fpmath & FPMATH_387)
    2844                 :          89 :                    && !TARGET_80387_P (opts->x_target_flags))
    2845                 :             :             {
    2846                 :           0 :               warning (0, "387 instruction set disabled, using SSE arithmetics");
    2847                 :           0 :               opts->x_ix86_fpmath = FPMATH_SSE;
    2848                 :             :             }
    2849                 :             :         }
    2850                 :             :     }
    2851                 :             :   /* For all chips supporting SSE2, -mfpmath=sse performs better than
    2852                 :             :      fpmath=387.  The second is however default at many targets since the
    2853                 :             :      extra 80bit precision of temporaries is considered to be part of ABI.
    2854                 :             :      Overwrite the default at least for -ffast-math.
    2855                 :             :      TODO: -mfpmath=both seems to produce same performing code with bit
    2856                 :             :      smaller binaries.  It is however not clear if register allocation is
    2857                 :             :      ready for this setting.
    2858                 :             :      Also -mfpmath=387 is overall a lot more compact (bout 4-5%) than SSE
    2859                 :             :      codegen.  We may switch to 387 with -ffast-math for size optimized
    2860                 :             :      functions. */
    2861                 :    55394669 :   else if (fast_math_flags_set_p (&global_options)
    2862                 :    55394669 :            && TARGET_SSE2_P (opts->x_ix86_isa_flags))
    2863                 :     1054790 :     opts->x_ix86_fpmath = FPMATH_SSE;
    2864                 :             :   else
    2865                 :    57047712 :     opts->x_ix86_fpmath = TARGET_FPMATH_DEFAULT_P (opts->x_ix86_isa_flags);
    2866                 :             : 
    2867                 :             :   /* Use external vectorized library in vectorizing intrinsics.  */
    2868                 :    56760857 :   if (opts_set->x_ix86_veclibabi_type)
    2869                 :           6 :     switch (opts->x_ix86_veclibabi_type)
    2870                 :             :       {
    2871                 :           3 :       case ix86_veclibabi_type_svml:
    2872                 :           3 :         ix86_veclib_handler = &ix86_veclibabi_svml;
    2873                 :           3 :         break;
    2874                 :             : 
    2875                 :           2 :       case ix86_veclibabi_type_acml:
    2876                 :           2 :         ix86_veclib_handler = &ix86_veclibabi_acml;
    2877                 :           2 :         break;
    2878                 :             : 
    2879                 :           1 :       case ix86_veclibabi_type_aocl:
    2880                 :           1 :         ix86_veclib_handler = &ix86_veclibabi_aocl;
    2881                 :           1 :         break;
    2882                 :             : 
    2883                 :           0 :       default:
    2884                 :           0 :         gcc_unreachable ();
    2885                 :             :       }
    2886                 :             : 
    2887                 :    56760857 :   if (ix86_tune_features [X86_TUNE_ACCUMULATE_OUTGOING_ARGS]
    2888                 :      316072 :       && !(opts_set->x_target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
    2889                 :      316072 :     opts->x_target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
    2890                 :             : 
    2891                 :             :   /* If stack probes are required, the space used for large function
    2892                 :             :      arguments on the stack must also be probed, so enable
    2893                 :             :      -maccumulate-outgoing-args so this happens in the prologue.  */
    2894                 :    56760857 :   if (TARGET_STACK_PROBE_P (opts->x_target_flags)
    2895                 :    56760857 :       && !(opts->x_target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
    2896                 :             :     {
    2897                 :          21 :       if (opts_set->x_target_flags & MASK_ACCUMULATE_OUTGOING_ARGS)
    2898                 :           0 :         warning (0,
    2899                 :             :                  main_args_p
    2900                 :             :                  ? G_("stack probing requires %<-maccumulate-outgoing-args%> "
    2901                 :             :                       "for correctness")
    2902                 :             :                  : G_("stack probing requires "
    2903                 :             :                       "%<target(\"accumulate-outgoing-args\")%> for "
    2904                 :             :                       "correctness"));
    2905                 :          21 :       opts->x_target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
    2906                 :             :     }
    2907                 :             : 
    2908                 :             :   /* Stack realignment without -maccumulate-outgoing-args requires %ebp,
    2909                 :             :      so enable -maccumulate-outgoing-args when %ebp is fixed.  */
    2910                 :    56760857 :   if (fixed_regs[BP_REG]
    2911                 :           3 :       && !(opts->x_target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
    2912                 :             :     {
    2913                 :           3 :       if (opts_set->x_target_flags & MASK_ACCUMULATE_OUTGOING_ARGS)
    2914                 :           2 :         warning (0,
    2915                 :             :                  main_args_p
    2916                 :             :                  ? G_("fixed ebp register requires "
    2917                 :             :                       "%<-maccumulate-outgoing-args%>")
    2918                 :             :                  : G_("fixed ebp register requires "
    2919                 :             :                       "%<target(\"accumulate-outgoing-args\")%>"));
    2920                 :           3 :       opts->x_target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
    2921                 :             :     }
    2922                 :             : 
    2923                 :             :   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
    2924                 :    56760857 :   {
    2925                 :    56760857 :     char *p;
    2926                 :    56760857 :     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
    2927                 :    56760857 :     p = strchr (internal_label_prefix, 'X');
    2928                 :    56760857 :     internal_label_prefix_len = p - internal_label_prefix;
    2929                 :    56760857 :     *p = '\0';
    2930                 :             :   }
    2931                 :             : 
    2932                 :             :   /* When scheduling description is not available, disable scheduler pass
    2933                 :             :      so it won't slow down the compilation and make x87 code slower.  */
    2934                 :    56760857 :   if (!TARGET_SCHEDULE)
    2935                 :          12 :     opts->x_flag_schedule_insns_after_reload = opts->x_flag_schedule_insns = 0;
    2936                 :             : 
    2937                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_simultaneous_prefetches,
    2938                 :             :                        ix86_tune_cost->simultaneous_prefetches);
    2939                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_line_size,
    2940                 :             :                        ix86_tune_cost->prefetch_block);
    2941                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_size,
    2942                 :             :                        ix86_tune_cost->l1_cache_size);
    2943                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_l2_cache_size,
    2944                 :             :                        ix86_tune_cost->l2_cache_size);
    2945                 :             : 
    2946                 :             :   /* 64B is the accepted value for these for all x86.  */
    2947                 :    56760857 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set,
    2948                 :             :                        param_destruct_interfere_size, 64);
    2949                 :    56760857 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set,
    2950                 :             :                        param_construct_interfere_size, 64);
    2951                 :             : 
    2952                 :             :   /* Enable sw prefetching at -O3 for CPUS that prefetching is helpful.  */
    2953                 :    56760857 :   if (opts->x_flag_prefetch_loop_arrays < 0
    2954                 :    56760798 :       && HAVE_prefetch
    2955                 :    56760795 :       && (opts->x_optimize >= 3 || opts->x_flag_profile_use)
    2956                 :     2752256 :       && !opts->x_optimize_size
    2957                 :     2752252 :       && TARGET_SOFTWARE_PREFETCHING_BENEFICIAL)
    2958                 :          50 :     opts->x_flag_prefetch_loop_arrays = 1;
    2959                 :             : 
    2960                 :             :   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
    2961                 :             :      can be opts->x_optimized to ap = __builtin_next_arg (0).  */
    2962                 :    56760857 :   if (!TARGET_64BIT_P (opts->x_ix86_isa_flags) && !opts->x_flag_split_stack)
    2963                 :       16122 :     targetm.expand_builtin_va_start = NULL;
    2964                 :             : 
    2965                 :             : #ifdef USE_IX86_CLD
    2966                 :             :   /* Use -mcld by default for 32-bit code if configured with --enable-cld.  */
    2967                 :             :   if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
    2968                 :             :     opts->x_target_flags |= MASK_CLD & ~opts_set->x_target_flags;
    2969                 :             : #endif
    2970                 :             : 
    2971                 :             :   /* Set the default value for -mfentry.  */
    2972                 :    56760857 :   if (!opts_set->x_flag_fentry)
    2973                 :    56760831 :     opts->x_flag_fentry = TARGET_SEH;
    2974                 :             :   else
    2975                 :             :     {
    2976                 :          26 :       if (!TARGET_64BIT_P (opts->x_ix86_isa_flags) && opts->x_flag_pic
    2977                 :           0 :           && opts->x_flag_fentry)
    2978                 :           0 :         sorry ("%<-mfentry%> isn%'t supported for 32-bit in combination "
    2979                 :             :                "with %<-fpic%>");
    2980                 :             :       else if (TARGET_SEH && !opts->x_flag_fentry)
    2981                 :             :         sorry ("%<-mno-fentry%> isn%'t compatible with SEH");
    2982                 :             :     }
    2983                 :             : 
    2984                 :    56760857 :   if (TARGET_SEH && TARGET_CALL_MS2SYSV_XLOGUES)
    2985                 :             :     sorry ("%<-mcall-ms2sysv-xlogues%> isn%'t currently supported with SEH");
    2986                 :             : 
    2987                 :    56760857 :   if (!(opts_set->x_target_flags & MASK_VZEROUPPER)
    2988                 :    56549384 :       && flag_expensive_optimizations
    2989                 :    53025560 :       && !optimize_size)
    2990                 :    52254173 :     opts->x_target_flags |= MASK_VZEROUPPER;
    2991                 :    56760857 :   if (!(opts_set->x_target_flags & MASK_STV))
    2992                 :    56750717 :     opts->x_target_flags |= MASK_STV;
    2993                 :             :   /* Disable STV if -mpreferred-stack-boundary={2,3} or
    2994                 :             :      -mincoming-stack-boundary={2,3} or -mstackrealign - the needed
    2995                 :             :      stack realignment will be extra cost the pass doesn't take into
    2996                 :             :      account and the pass can't realign the stack.  */
    2997                 :    56760857 :   if (ix86_preferred_stack_boundary < 128
    2998                 :    56760849 :       || ix86_incoming_stack_boundary < 128
    2999                 :    56760848 :       || opts->x_ix86_force_align_arg_pointer)
    3000                 :        1617 :     opts->x_target_flags &= ~MASK_STV;
    3001                 :    56760857 :   if (!ix86_tune_features[X86_TUNE_AVX256_UNALIGNED_LOAD_OPTIMAL]
    3002                 :       14324 :       && !(opts_set->x_target_flags & MASK_AVX256_SPLIT_UNALIGNED_LOAD))
    3003                 :       14324 :     opts->x_target_flags |= MASK_AVX256_SPLIT_UNALIGNED_LOAD;
    3004                 :    56746533 :   else if (!main_args_p
    3005                 :    56464972 :            && ix86_tune_features[X86_TUNE_AVX256_UNALIGNED_LOAD_OPTIMAL])
    3006                 :    56464972 :     opts->x_target_flags &= ~MASK_AVX256_SPLIT_UNALIGNED_LOAD;
    3007                 :             : 
    3008                 :    56760857 :   if (!ix86_tune_features[X86_TUNE_AVX256_UNALIGNED_STORE_OPTIMAL]
    3009                 :       14550 :       && !(opts_set->x_target_flags & MASK_AVX256_SPLIT_UNALIGNED_STORE))
    3010                 :       14550 :     opts->x_target_flags |= MASK_AVX256_SPLIT_UNALIGNED_STORE;
    3011                 :    56746307 :   else if (!main_args_p
    3012                 :    56464790 :            && ix86_tune_features[X86_TUNE_AVX256_UNALIGNED_STORE_OPTIMAL])
    3013                 :    56464790 :     opts->x_target_flags &= ~MASK_AVX256_SPLIT_UNALIGNED_STORE;
    3014                 :             : 
    3015                 :             :   /* Enable 128-bit AVX instruction generation
    3016                 :             :      for the auto-vectorizer.  */
    3017                 :    56760857 :   if (ix86_tune_features[X86_TUNE_AVX128_OPTIMAL]
    3018                 :         260 :       && (opts_set->x_prefer_vector_width_type == PVW_NONE))
    3019                 :         249 :     opts->x_prefer_vector_width_type = PVW_AVX128;
    3020                 :             : 
    3021                 :             :   /* Use 256-bit AVX instruction generation
    3022                 :             :      in the auto-vectorizer.  */
    3023                 :    56760857 :   if (ix86_tune_features[X86_TUNE_AVX256_OPTIMAL]
    3024                 :      373710 :       && (opts_set->x_prefer_vector_width_type == PVW_NONE))
    3025                 :      166686 :     opts->x_prefer_vector_width_type = PVW_AVX256;
    3026                 :             : 
    3027                 :    56760857 :   if (opts_set->x_ix86_move_max == PVW_NONE)
    3028                 :             :     {
    3029                 :             :       /* Set the maximum number of bits can be moved from memory to
    3030                 :             :          memory efficiently.  */
    3031                 :    56760853 :       if (opts_set->x_prefer_vector_width_type != PVW_NONE)
    3032                 :     1290853 :         opts->x_ix86_move_max = opts->x_prefer_vector_width_type;
    3033                 :    55470000 :       else if (ix86_tune_features[X86_TUNE_AVX512_MOVE_BY_PIECES])
    3034                 :       46970 :         opts->x_ix86_move_max = PVW_AVX512;
    3035                 :    55423030 :       else if (ix86_tune_features[X86_TUNE_AVX256_MOVE_BY_PIECES])
    3036                 :      460798 :         opts->x_ix86_move_max = PVW_AVX256;
    3037                 :             :       else
    3038                 :             :         {
    3039                 :    54962232 :           opts->x_ix86_move_max = opts->x_prefer_vector_width_type;
    3040                 :    54962232 :           if (opts_set->x_ix86_move_max == PVW_NONE)
    3041                 :             :             {
    3042                 :    54962232 :               if (TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    3043                 :    51127083 :                   && TARGET_EVEX512_P (opts->x_ix86_isa_flags2))
    3044                 :    22447652 :                 opts->x_ix86_move_max = PVW_AVX512;
    3045                 :             :               /* Align with vectorizer to avoid potential STLF issue.  */
    3046                 :    32514580 :               else if (TARGET_AVX_P (opts->x_ix86_isa_flags))
    3047                 :    29998059 :                 opts->x_ix86_move_max = PVW_AVX256;
    3048                 :             :               else
    3049                 :     2516521 :                 opts->x_ix86_move_max = PVW_AVX128;
    3050                 :             :             }
    3051                 :             :         }
    3052                 :             :     }
    3053                 :             : 
    3054                 :    56760857 :   if (opts_set->x_ix86_store_max == PVW_NONE)
    3055                 :             :     {
    3056                 :             :       /* Set the maximum number of bits can be stored to memory
    3057                 :             :          efficiently.  */
    3058                 :    56760852 :       if (opts_set->x_prefer_vector_width_type != PVW_NONE)
    3059                 :     1290854 :         opts->x_ix86_store_max = opts->x_prefer_vector_width_type;
    3060                 :    55469998 :       else if (ix86_tune_features[X86_TUNE_AVX512_STORE_BY_PIECES])
    3061                 :       46969 :         opts->x_ix86_store_max = PVW_AVX512;
    3062                 :    55423029 :       else if (ix86_tune_features[X86_TUNE_AVX256_STORE_BY_PIECES])
    3063                 :      460808 :         opts->x_ix86_store_max = PVW_AVX256;
    3064                 :             :       else
    3065                 :             :         {
    3066                 :    54962221 :           opts->x_ix86_store_max = opts->x_prefer_vector_width_type;
    3067                 :    54962221 :           if (opts_set->x_ix86_store_max == PVW_NONE)
    3068                 :             :             {
    3069                 :    54962221 :               if (TARGET_AVX512F_P (opts->x_ix86_isa_flags)
    3070                 :    51127082 :                   && TARGET_EVEX512_P (opts->x_ix86_isa_flags2))
    3071                 :    22447651 :                 opts->x_ix86_store_max = PVW_AVX512;
    3072                 :             :               /* Align with vectorizer to avoid potential STLF issue.  */
    3073                 :    32514570 :               else if (TARGET_AVX_P (opts->x_ix86_isa_flags))
    3074                 :    29998049 :                 opts->x_ix86_store_max = PVW_AVX256;
    3075                 :             :               else
    3076                 :     2516521 :                 opts->x_ix86_store_max = PVW_AVX128;
    3077                 :             :             }
    3078                 :             :         }
    3079                 :             :     }
    3080                 :             : 
    3081                 :    56760857 :   if (opts->x_ix86_recip_name)
    3082                 :             :     {
    3083                 :           0 :       char *p = ASTRDUP (opts->x_ix86_recip_name);
    3084                 :           0 :       char *q;
    3085                 :           0 :       unsigned int mask;
    3086                 :           0 :       bool invert;
    3087                 :             : 
    3088                 :           0 :       while ((q = strtok (p, ",")) != NULL)
    3089                 :             :         {
    3090                 :           0 :           p = NULL;
    3091                 :           0 :           if (*q == '!')
    3092                 :             :             {
    3093                 :           0 :               invert = true;
    3094                 :           0 :               q++;
    3095                 :             :             }
    3096                 :             :           else
    3097                 :             :             invert = false;
    3098                 :             : 
    3099                 :           0 :           if (!strcmp (q, "default"))
    3100                 :             :             mask = RECIP_MASK_ALL;
    3101                 :             :           else
    3102                 :             :             {
    3103                 :           0 :               for (i = 0; i < ARRAY_SIZE (recip_options); i++)
    3104                 :           0 :                 if (!strcmp (q, recip_options[i].string))
    3105                 :             :                   {
    3106                 :           0 :                     mask = recip_options[i].mask;
    3107                 :           0 :                     break;
    3108                 :             :                   }
    3109                 :             : 
    3110                 :           0 :               if (i == ARRAY_SIZE (recip_options))
    3111                 :             :                 {
    3112                 :           0 :                   error ("unknown option for %<-mrecip=%s%>", q);
    3113                 :           0 :                   invert = false;
    3114                 :           0 :                   mask = RECIP_MASK_NONE;
    3115                 :             :                 }
    3116                 :             :             }
    3117                 :             : 
    3118                 :           0 :           opts->x_recip_mask_explicit |= mask;
    3119                 :           0 :           if (invert)
    3120                 :           0 :             opts->x_recip_mask &= ~mask;
    3121                 :             :           else
    3122                 :           0 :             opts->x_recip_mask |= mask;
    3123                 :             :         }
    3124                 :             :     }
    3125                 :             : 
    3126                 :    56760857 :   if (TARGET_RECIP_P (opts->x_target_flags))
    3127                 :       13682 :     opts->x_recip_mask |= RECIP_MASK_ALL & ~opts->x_recip_mask_explicit;
    3128                 :    56747175 :   else if (opts_set->x_target_flags & MASK_RECIP)
    3129                 :           2 :     opts->x_recip_mask &= ~(RECIP_MASK_ALL & ~opts->x_recip_mask_explicit);
    3130                 :             : 
    3131                 :             :   /* Default long double to 64-bit for 32-bit Bionic and to __float128
    3132                 :             :      for 64-bit Bionic.  Also default long double to 64-bit for Intel
    3133                 :             :      MCU psABI.  */
    3134                 :    56760857 :   if ((TARGET_HAS_BIONIC || TARGET_IAMCU)
    3135                 :           8 :       && !(opts_set->x_target_flags
    3136                 :             :            & (MASK_LONG_DOUBLE_64 | MASK_LONG_DOUBLE_128)))
    3137                 :           2 :     opts->x_target_flags |= (TARGET_64BIT
    3138                 :           2 :                              ? MASK_LONG_DOUBLE_128
    3139                 :             :                              : MASK_LONG_DOUBLE_64);
    3140                 :             : 
    3141                 :             :   /* Only one of them can be active.  */
    3142                 :    56760857 :   gcc_assert ((opts->x_target_flags & MASK_LONG_DOUBLE_64) == 0
    3143                 :             :               || (opts->x_target_flags & MASK_LONG_DOUBLE_128) == 0);
    3144                 :             : 
    3145                 :             :   /* Handle stack protector */
    3146                 :    56760857 :   if (!opts_set->x_ix86_stack_protector_guard)
    3147                 :             :     {
    3148                 :             : #ifdef TARGET_THREAD_SSP_OFFSET
    3149                 :    56760855 :       if (!TARGET_HAS_BIONIC)
    3150                 :    56760847 :         opts->x_ix86_stack_protector_guard = SSP_TLS;
    3151                 :             :       else
    3152                 :             : #endif
    3153                 :           8 :         opts->x_ix86_stack_protector_guard = SSP_GLOBAL;
    3154                 :             :     }
    3155                 :             : 
    3156                 :    56760857 :   if (opts_set->x_ix86_stack_protector_guard_offset_str)
    3157                 :             :     {
    3158                 :           1 :       char *endp;
    3159                 :           1 :       const char *str = opts->x_ix86_stack_protector_guard_offset_str;
    3160                 :             : 
    3161                 :           1 :       errno = 0;
    3162                 :           1 :       int64_t offset;
    3163                 :             : 
    3164                 :             : #if defined(INT64_T_IS_LONG)
    3165                 :           1 :       offset = strtol (str, &endp, 0);
    3166                 :             : #else
    3167                 :             :       offset = strtoll (str, &endp, 0);
    3168                 :             : #endif
    3169                 :             : 
    3170                 :           1 :       if (!*str || *endp || errno)
    3171                 :           0 :         error ("%qs is not a valid number "
    3172                 :             :                "in %<-mstack-protector-guard-offset=%>", str);
    3173                 :             : 
    3174                 :           1 :       if (!IN_RANGE (offset, HOST_WIDE_INT_C (-0x80000000),
    3175                 :             :                      HOST_WIDE_INT_C (0x7fffffff)))
    3176                 :           0 :         error ("%qs is not a valid offset "
    3177                 :             :                "in %<-mstack-protector-guard-offset=%>", str);
    3178                 :             : 
    3179                 :           1 :       opts->x_ix86_stack_protector_guard_offset = offset;
    3180                 :             :     }
    3181                 :             : #ifdef TARGET_THREAD_SSP_OFFSET
    3182                 :             :   else
    3183                 :   112882189 :     opts->x_ix86_stack_protector_guard_offset = TARGET_THREAD_SSP_OFFSET;
    3184                 :             : #endif
    3185                 :             : 
    3186                 :    56760857 :   if (opts_set->x_ix86_stack_protector_guard_reg_str)
    3187                 :             :     {
    3188                 :           2 :       const char *str = opts->x_ix86_stack_protector_guard_reg_str;
    3189                 :           2 :       addr_space_t seg = ADDR_SPACE_GENERIC;
    3190                 :             : 
    3191                 :             :       /* Discard optional register prefix.  */
    3192                 :           2 :       if (str[0] == '%')
    3193                 :           0 :         str++;
    3194                 :             : 
    3195                 :           2 :       if (strlen (str) == 2 && str[1] == 's')
    3196                 :             :         {
    3197                 :           2 :           if (str[0] == 'f')
    3198                 :             :             seg = ADDR_SPACE_SEG_FS;
    3199                 :           2 :           else if (str[0] == 'g')
    3200                 :             :             seg = ADDR_SPACE_SEG_GS;
    3201                 :             :         }
    3202                 :             : 
    3203                 :             :       if (seg == ADDR_SPACE_GENERIC)
    3204                 :           0 :         error ("%qs is not a valid base register "
    3205                 :             :                "in %<-mstack-protector-guard-reg=%>",
    3206                 :             :                opts->x_ix86_stack_protector_guard_reg_str);
    3207                 :             : 
    3208                 :           2 :       opts->x_ix86_stack_protector_guard_reg = seg;
    3209                 :             :     }
    3210                 :             :   else
    3211                 :             :     {
    3212                 :    56760855 :       opts->x_ix86_stack_protector_guard_reg = DEFAULT_TLS_SEG_REG;
    3213                 :             : 
    3214                 :             :       /* The kernel uses a different segment register for performance
    3215                 :             :          reasons; a system call would not have to trash the userspace
    3216                 :             :          segment register, which would be expensive.  */
    3217                 :    56760855 :       if (opts->x_ix86_cmodel == CM_KERNEL)
    3218                 :           1 :         opts->x_ix86_stack_protector_guard_reg = ADDR_SPACE_SEG_GS;
    3219                 :             :     }
    3220                 :             : 
    3221                 :             :   /* Handle -mmemcpy-strategy= and -mmemset-strategy=  */
    3222                 :    56760857 :   if (opts->x_ix86_tune_memcpy_strategy)
    3223                 :             :     {
    3224                 :           7 :       char *str = xstrdup (opts->x_ix86_tune_memcpy_strategy);
    3225                 :           7 :       ix86_parse_stringop_strategy_string (str, false);
    3226                 :           7 :       free (str);
    3227                 :             :     }
    3228                 :             : 
    3229                 :    56760857 :   if (opts->x_ix86_tune_memset_strategy)
    3230                 :             :     {
    3231                 :           3 :       char *str = xstrdup (opts->x_ix86_tune_memset_strategy);
    3232                 :           3 :       ix86_parse_stringop_strategy_string (str, true);
    3233                 :           3 :       free (str);
    3234                 :             :     }
    3235                 :             : 
    3236                 :             :   /* Save the initial options in case the user does function specific
    3237                 :             :      options.  */
    3238                 :    56760857 :   if (main_args_p)
    3239                 :             :     {
    3240                 :      281602 :       opts->x_ix86_excess_precision
    3241                 :      281602 :         = opts->x_flag_excess_precision;
    3242                 :      281602 :       opts->x_ix86_unsafe_math_optimizations
    3243                 :      281602 :         = opts->x_flag_unsafe_math_optimizations;
    3244                 :      563204 :       target_option_default_node = target_option_current_node
    3245                 :      281602 :         = build_target_option_node (opts, opts_set);
    3246                 :             :     }
    3247                 :             : 
    3248                 :    56760857 :   const bool cf_okay_p = (TARGET_64BIT || TARGET_CMOV);
    3249                 :             :   /* When -fhardened, enable -fcf-protection=full, but only when it's
    3250                 :             :      compatible with this target, and when it wasn't already specified
    3251                 :             :      on the command line.  */
    3252                 :    56760857 :   if (opts->x_flag_hardened && cf_okay_p)
    3253                 :             :     {
    3254                 :          67 :       if (!opts_set->x_flag_cf_protection)
    3255                 :          66 :         opts->x_flag_cf_protection = CF_FULL;
    3256                 :           1 :       else if (opts->x_flag_cf_protection != CF_FULL)
    3257                 :           1 :         warning_at (UNKNOWN_LOCATION, OPT_Whardened,
    3258                 :             :                     "%<-fcf-protection=full%> is not enabled by "
    3259                 :             :                     "%<-fhardened%> because it was specified on the command "
    3260                 :             :                     "line");
    3261                 :             :     }
    3262                 :             : 
    3263                 :    56760857 :   if (opts->x_flag_cf_protection != CF_NONE)
    3264                 :             :     {
    3265                 :       43738 :       if ((opts->x_flag_cf_protection & CF_BRANCH) == CF_BRANCH
    3266                 :       43591 :           && !cf_okay_p)
    3267                 :           0 :         error ("%<-fcf-protection%> is not compatible with this target");
    3268                 :             : 
    3269                 :       43738 :       opts->x_flag_cf_protection
    3270                 :       43738 :       = (cf_protection_level) (opts->x_flag_cf_protection | CF_SET);
    3271                 :             :     }
    3272                 :             : 
    3273                 :    56760857 :   if (ix86_tune_features [X86_TUNE_AVOID_512FMA_CHAINS])
    3274                 :          21 :     SET_OPTION_IF_UNSET (opts, opts_set, param_avoid_fma_max_bits, 512);
    3275                 :    56760836 :   else if (ix86_tune_features [X86_TUNE_AVOID_256FMA_CHAINS])
    3276                 :    55819769 :     SET_OPTION_IF_UNSET (opts, opts_set, param_avoid_fma_max_bits, 256);
    3277                 :      941067 :   else if (ix86_tune_features [X86_TUNE_AVOID_128FMA_CHAINS])
    3278                 :          59 :     SET_OPTION_IF_UNSET (opts, opts_set, param_avoid_fma_max_bits, 128);
    3279                 :             : 
    3280                 :             :   /* PR86952: jump table usage with retpolines is slow.
    3281                 :             :      The PR provides some numbers about the slowness.  */
    3282                 :    56760857 :   if (ix86_indirect_branch != indirect_branch_keep)
    3283                 :          49 :     SET_OPTION_IF_UNSET (opts, opts_set, flag_jump_tables, 0);
    3284                 :             : 
    3285                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_ira_consider_dup_in_all_alts, 0);
    3286                 :             : 
    3287                 :             :   /* Fully masking the main or the epilogue vectorized loop is not
    3288                 :             :      profitable generally so leave it disabled until we get more
    3289                 :             :      fine grained control & costing.  */
    3290                 :    56760857 :   SET_OPTION_IF_UNSET (opts, opts_set, param_vect_partial_vector_usage, 0);
    3291                 :             : 
    3292                 :             :   return true;
    3293                 :             : }
    3294                 :             : 
    3295                 :             : /* Implement the TARGET_OPTION_OVERRIDE hook.  */
    3296                 :             : 
    3297                 :             : void
    3298                 :      281603 : ix86_option_override (void)
    3299                 :             : {
    3300                 :      281603 :   ix86_option_override_internal (true, &global_options, &global_options_set);
    3301                 :      281603 : }
    3302                 :             : 
    3303                 :             : /* Remember the last target of ix86_set_current_function.  */
    3304                 :             : static GTY(()) tree ix86_previous_fndecl;
    3305                 :             : 
    3306                 :             : /* Set targets globals to the default (or current #pragma GCC target
    3307                 :             :    if active).  Invalidate ix86_previous_fndecl cache.  */
    3308                 :             : 
    3309                 :             : void
    3310                 :     4941820 : ix86_reset_previous_fndecl (void)
    3311                 :             : {
    3312                 :     4941820 :   tree new_tree = target_option_current_node;
    3313                 :     4941820 :   cl_target_option_restore (&global_options, &global_options_set,
    3314                 :     4941820 :                             TREE_TARGET_OPTION (new_tree));
    3315                 :     4941820 :   if (TREE_TARGET_GLOBALS (new_tree))
    3316                 :     2573941 :     restore_target_globals (TREE_TARGET_GLOBALS (new_tree));
    3317                 :     2367879 :   else if (new_tree == target_option_default_node)
    3318                 :     1824703 :     restore_target_globals (&default_target_globals);
    3319                 :             :   else
    3320                 :      543176 :     TREE_TARGET_GLOBALS (new_tree) = save_target_globals_default_opts ();
    3321                 :     4941820 :   ix86_previous_fndecl = NULL_TREE;
    3322                 :     4941820 : }
    3323                 :             : 
    3324                 :             : /* Add target attribute to SIMD clone NODE if needed.  */
    3325                 :             : 
    3326                 :             : void
    3327                 :        7116 : ix86_simd_clone_adjust (struct cgraph_node *node)
    3328                 :             : {
    3329                 :        7116 :   const char *str = NULL;
    3330                 :             : 
    3331                 :             :   /* Attributes need to be adjusted for definitions, not declarations.  */
    3332                 :        7116 :   if (!node->definition)
    3333                 :             :     return;
    3334                 :             : 
    3335                 :        4408 :   gcc_assert (node->decl == cfun->decl);
    3336                 :        4408 :   switch (node->simdclone->vecsize_mangle)
    3337                 :             :     {
    3338                 :        1099 :     case 'b':
    3339                 :        1099 :       if (!TARGET_SSE2)
    3340                 :             :         str = "sse2";
    3341                 :             :       break;
    3342                 :        1160 :     case 'c':
    3343                 :        1160 :       if (TARGET_PREFER_AVX128)
    3344                 :             :         {
    3345                 :           1 :           if (!TARGET_AVX)
    3346                 :             :             str = "avx,prefer-vector-width=256";
    3347                 :             :           else
    3348                 :             :             str = "prefer-vector-width=256";
    3349                 :             :         }
    3350                 :        1159 :       else if (!TARGET_AVX)
    3351                 :             :         str = "avx";
    3352                 :             :       break;
    3353                 :        1075 :     case 'd':
    3354                 :        1075 :       if (TARGET_PREFER_AVX128)
    3355                 :             :         {
    3356                 :           1 :           if (!TARGET_AVX2)
    3357                 :             :             str = "avx2,prefer-vector-width=256";
    3358                 :             :           else
    3359                 :             :             str = "prefer-vector-width=256";
    3360                 :             :         }
    3361                 :        1074 :       else if (!TARGET_AVX2)
    3362                 :             :         str = "avx2";
    3363                 :             :       break;
    3364                 :        1074 :     case 'e':
    3365                 :        1074 :       if (TARGET_PREFER_AVX256)
    3366                 :             :         {
    3367                 :           4 :           if (!TARGET_AVX512F || !TARGET_EVEX512)
    3368                 :             :             str = "avx512f,evex512,prefer-vector-width=512";
    3369                 :             :           else
    3370                 :             :             str = "prefer-vector-width=512";
    3371                 :             :         }
    3372                 :        1070 :       else if (!TARGET_AVX512F || !TARGET_EVEX512)
    3373                 :             :         str = "avx512f,evex512";
    3374                 :             :       break;
    3375                 :           0 :     default:
    3376                 :           0 :       gcc_unreachable ();
    3377                 :             :     }
    3378                 :             :   if (str == NULL)
    3379                 :             :     return;
    3380                 :        2821 :   push_cfun (NULL);
    3381                 :        2821 :   tree args = build_tree_list (NULL_TREE, build_string (strlen (str), str));
    3382                 :        2821 :   bool ok = ix86_valid_target_attribute_p (node->decl, NULL, args, 0);
    3383                 :        2821 :   gcc_assert (ok);
    3384                 :        2821 :   pop_cfun ();
    3385                 :        2821 :   ix86_reset_previous_fndecl ();
    3386                 :        2821 :   ix86_set_current_function (node->decl);
    3387                 :             : }
    3388                 :             : 
    3389                 :             : 
    3390                 :             : 
    3391                 :             : /* Set the func_type field from the function FNDECL.  */
    3392                 :             : 
    3393                 :             : static void
    3394                 :   327729084 : ix86_set_func_type (tree fndecl)
    3395                 :             : {
    3396                 :             :   /* No need to save and restore callee-saved registers for a noreturn
    3397                 :             :      function with nothrow or compiled with -fno-exceptions unless when
    3398                 :             :      compiling with -O0 or -Og, except that it interferes with debugging
    3399                 :             :      of callers.  So that backtrace works for those at least
    3400                 :             :      in most cases, save the bp register if it is used, because it often
    3401                 :             :      is used in callers to compute CFA.
    3402                 :             : 
    3403                 :             :      NB: Can't use just TREE_THIS_VOLATILE to check if this is a noreturn
    3404                 :             :      function.  The local-pure-const pass turns an interrupt function
    3405                 :             :      into a noreturn function by setting TREE_THIS_VOLATILE.  Normally
    3406                 :             :      the local-pure-const pass is run after ix86_set_func_type is called.
    3407                 :             :      When the local-pure-const pass is enabled for LTO, the interrupt
    3408                 :             :      function is marked with TREE_THIS_VOLATILE in the IR output, which
    3409                 :             :      leads to the incompatible attribute error in LTO1.  Ignore the
    3410                 :             :      interrupt function in this case.  */
    3411                 :   327729084 :   enum call_saved_registers_type no_callee_saved_registers
    3412                 :             :     = TYPE_DEFAULT_CALL_SAVED_REGISTERS;
    3413                 :   327729084 :   if (lookup_attribute ("no_callee_saved_registers",
    3414                 :   327729084 :                         TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
    3415                 :             :     no_callee_saved_registers = TYPE_NO_CALLEE_SAVED_REGISTERS;
    3416                 :   327727982 :   else if (ix86_noreturn_no_callee_saved_registers
    3417                 :         398 :            && TREE_THIS_VOLATILE (fndecl)
    3418                 :         398 :            && optimize
    3419                 :         363 :            && !optimize_debug
    3420                 :         312 :            && (TREE_NOTHROW (fndecl) || !flag_exceptions)
    3421                 :         312 :            && !lookup_attribute ("interrupt",
    3422                 :         312 :                                  TYPE_ATTRIBUTES (TREE_TYPE (fndecl)))
    3423                 :   327728294 :            && !lookup_attribute ("no_caller_saved_registers",
    3424                 :         312 :                                  TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
    3425                 :             :     no_callee_saved_registers = TYPE_NO_CALLEE_SAVED_REGISTERS_EXCEPT_BP;
    3426                 :             : 
    3427                 :   327729084 :   if (cfun->machine->func_type == TYPE_UNKNOWN)
    3428                 :             :     {
    3429                 :   168748791 :       if (lookup_attribute ("interrupt",
    3430                 :   168748791 :                             TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
    3431                 :             :         {
    3432                 :         149 :           if (ix86_function_naked (fndecl))
    3433                 :           1 :             error_at (DECL_SOURCE_LOCATION (fndecl),
    3434                 :             :                       "interrupt and naked attributes are not compatible");
    3435                 :             : 
    3436                 :         149 :           if (no_callee_saved_registers)
    3437                 :           1 :             error_at (DECL_SOURCE_LOCATION (fndecl),
    3438                 :             :                       "%qs and %qs attributes are not compatible",
    3439                 :             :                       "interrupt", "no_callee_saved_registers");
    3440                 :             : 
    3441                 :         149 :           int nargs = 0;
    3442                 :         149 :           for (tree arg = DECL_ARGUMENTS (fndecl);
    3443                 :         377 :                arg;
    3444                 :         228 :                arg = TREE_CHAIN (arg))
    3445                 :         228 :             nargs++;
    3446                 :         149 :           cfun->machine->call_saved_registers
    3447                 :         149 :             = TYPE_NO_CALLER_SAVED_REGISTERS;
    3448                 :         149 :           cfun->machine->func_type
    3449                 :         149 :             = nargs == 2 ? TYPE_EXCEPTION : TYPE_INTERRUPT;
    3450                 :             : 
    3451                 :         149 :           ix86_optimize_mode_switching[X86_DIRFLAG] = 1;
    3452                 :             : 
    3453                 :             :           /* Only dwarf2out.cc can handle -WORD(AP) as a pointer argument.  */
    3454                 :         149 :           if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
    3455                 :           0 :             sorry ("only DWARF debug format is supported for interrupt "
    3456                 :             :                    "service routine");
    3457                 :             :         }
    3458                 :             :       else
    3459                 :             :         {
    3460                 :   168748642 :           cfun->machine->func_type = TYPE_NORMAL;
    3461                 :   168748642 :           if (lookup_attribute ("no_caller_saved_registers",
    3462                 :   168748642 :                                 TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
    3463                 :          26 :             cfun->machine->call_saved_registers
    3464                 :          26 :               = TYPE_NO_CALLER_SAVED_REGISTERS;
    3465                 :   168748642 :           if (no_callee_saved_registers)
    3466                 :             :             {
    3467                 :          34 :               if (cfun->machine->call_saved_registers
    3468                 :          34 :                   == TYPE_NO_CALLER_SAVED_REGISTERS)
    3469                 :           1 :                 error_at (DECL_SOURCE_LOCATION (fndecl),
    3470                 :             :                           "%qs and %qs attributes are not compatible",
    3471                 :             :                           "no_caller_saved_registers",
    3472                 :             :                           "no_callee_saved_registers");
    3473                 :          34 :               cfun->machine->call_saved_registers
    3474                 :          34 :                 = no_callee_saved_registers;
    3475                 :             :             }
    3476                 :             :         }
    3477                 :             :     }
    3478                 :   327729084 : }
    3479                 :             : 
    3480                 :             : /* Set the indirect_branch_type field from the function FNDECL.  */
    3481                 :             : 
    3482                 :             : static void
    3483                 :   327729084 : ix86_set_indirect_branch_type (tree fndecl)
    3484                 :             : {
    3485                 :   327729084 :   if (cfun->machine->indirect_branch_type == indirect_branch_unset)
    3486                 :             :     {
    3487                 :   168748791 :       tree attr = lookup_attribute ("indirect_branch",
    3488                 :   168748791 :                                     DECL_ATTRIBUTES (fndecl));
    3489                 :   168748791 :       if (attr != NULL)
    3490                 :             :         {
    3491                 :          17 :           tree args = TREE_VALUE (attr);
    3492                 :          17 :           if (args == NULL)
    3493                 :           0 :             gcc_unreachable ();
    3494                 :          17 :           tree cst = TREE_VALUE (args);
    3495                 :          17 :           if (strcmp (TREE_STRING_POINTER (cst), "keep") == 0)
    3496                 :           2 :             cfun->machine->indirect_branch_type = indirect_branch_keep;
    3497                 :          15 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk") == 0)
    3498                 :           5 :             cfun->machine->indirect_branch_type = indirect_branch_thunk;
    3499                 :          10 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk-inline") == 0)
    3500                 :           3 :             cfun->machine->indirect_branch_type = indirect_branch_thunk_inline;
    3501                 :           7 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk-extern") == 0)
    3502                 :           7 :             cfun->machine->indirect_branch_type = indirect_branch_thunk_extern;
    3503                 :             :           else
    3504                 :           0 :             gcc_unreachable ();
    3505                 :             :         }
    3506                 :             :       else
    3507                 :   168748774 :         cfun->machine->indirect_branch_type = ix86_indirect_branch;
    3508                 :             : 
    3509                 :             :       /* -mcmodel=large is not compatible with -mindirect-branch=thunk
    3510                 :             :          nor -mindirect-branch=thunk-extern.  */
    3511                 :   168748791 :       if ((ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
    3512                 :        7752 :           && ((cfun->machine->indirect_branch_type
    3513                 :        7752 :                == indirect_branch_thunk_extern)
    3514                 :        7750 :               || (cfun->machine->indirect_branch_type
    3515                 :             :                   == indirect_branch_thunk)))
    3516                 :           6 :         error ("%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not "
    3517                 :             :                "compatible",
    3518                 :             :                ((cfun->machine->indirect_branch_type
    3519                 :             :                  == indirect_branch_thunk_extern)
    3520                 :             :                 ? "thunk-extern" : "thunk"));
    3521                 :             : 
    3522                 :   168748791 :       if (cfun->machine->indirect_branch_type != indirect_branch_keep
    3523                 :          78 :           && (cfun->machine->indirect_branch_type
    3524                 :             :               != indirect_branch_thunk_extern)
    3525                 :          52 :           && (flag_cf_protection & CF_RETURN))
    3526                 :           3 :         error ("%<-mindirect-branch%> and %<-fcf-protection%> are not "
    3527                 :             :                "compatible");
    3528                 :             :     }
    3529                 :             : 
    3530                 :   327729084 :   if (cfun->machine->function_return_type == indirect_branch_unset)
    3531                 :             :     {
    3532                 :   168748791 :       tree attr = lookup_attribute ("function_return",
    3533                 :   168748791 :                                     DECL_ATTRIBUTES (fndecl));
    3534                 :   168748791 :       if (attr != NULL)
    3535                 :             :         {
    3536                 :          12 :           tree args = TREE_VALUE (attr);
    3537                 :          12 :           if (args == NULL)
    3538                 :           0 :             gcc_unreachable ();
    3539                 :          12 :           tree cst = TREE_VALUE (args);
    3540                 :          12 :           if (strcmp (TREE_STRING_POINTER (cst), "keep") == 0)
    3541                 :           2 :             cfun->machine->function_return_type = indirect_branch_keep;
    3542                 :          10 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk") == 0)
    3543                 :           4 :             cfun->machine->function_return_type = indirect_branch_thunk;
    3544                 :           6 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk-inline") == 0)
    3545                 :           3 :             cfun->machine->function_return_type = indirect_branch_thunk_inline;
    3546                 :           3 :           else if (strcmp (TREE_STRING_POINTER (cst), "thunk-extern") == 0)
    3547                 :           3 :             cfun->machine->function_return_type = indirect_branch_thunk_extern;
    3548                 :             :           else
    3549                 :           0 :             gcc_unreachable ();
    3550                 :             :         }
    3551                 :             :       else
    3552                 :   168748779 :         cfun->machine->function_return_type = ix86_function_return;
    3553                 :             : 
    3554                 :             :       /* -mcmodel=large is not compatible with -mfunction-return=thunk
    3555                 :             :          nor -mfunction-return=thunk-extern.  */
    3556                 :   168748791 :       if ((ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
    3557                 :        7752 :           && ((cfun->machine->function_return_type
    3558                 :        7752 :                == indirect_branch_thunk_extern)
    3559                 :        7750 :               || (cfun->machine->function_return_type
    3560                 :             :                   == indirect_branch_thunk)))
    3561                 :           6 :         error ("%<-mfunction-return=%s%> and %<-mcmodel=large%> are not "
    3562                 :             :                "compatible",
    3563                 :             :                ((cfun->machine->function_return_type
    3564                 :             :                  == indirect_branch_thunk_extern)
    3565                 :             :                 ? "thunk-extern" : "thunk"));
    3566                 :             : 
    3567                 :   168748791 :       if (cfun->machine->function_return_type != indirect_branch_keep
    3568                 :          32 :           && (cfun->machine->function_return_type
    3569                 :             :               != indirect_branch_thunk_extern)
    3570                 :          24 :           && (flag_cf_protection & CF_RETURN))
    3571                 :           3 :         error ("%<-mfunction-return%> and %<-fcf-protection%> are not "
    3572                 :             :                "compatible");
    3573                 :             :     }
    3574                 :   327729084 : }
    3575                 :             : 
    3576                 :             : /* Establish appropriate back-end context for processing the function
    3577                 :             :    FNDECL.  The argument might be NULL to indicate processing at top
    3578                 :             :    level, outside of any function scope.  */
    3579                 :             : void
    3580                 :   651514509 : ix86_set_current_function (tree fndecl)
    3581                 :             : {
    3582                 :             :   /* Only change the context if the function changes.  This hook is called
    3583                 :             :      several times in the course of compiling a function, and we don't want to
    3584                 :             :      slow things down too much or call target_reinit when it isn't safe.  */
    3585                 :   651514509 :   if (fndecl == ix86_previous_fndecl)
    3586                 :             :     {
    3587                 :             :       /* There may be 2 function bodies for the same function FNDECL,
    3588                 :             :          one is extern inline and one isn't.  Call ix86_set_func_type
    3589                 :             :          to set the func_type field.  */
    3590                 :    63391434 :       if (fndecl != NULL_TREE)
    3591                 :             :         {
    3592                 :    63391415 :           ix86_set_func_type (fndecl);
    3593                 :    63391415 :           ix86_set_indirect_branch_type (fndecl);
    3594                 :             :         }
    3595                 :    63391434 :       return;
    3596                 :             :     }
    3597                 :             : 
    3598                 :   588123075 :   tree old_tree;
    3599                 :   588123075 :   if (ix86_previous_fndecl == NULL_TREE)
    3600                 :     4507620 :     old_tree = target_option_current_node;
    3601                 :   583615455 :   else if (DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl))
    3602                 :             :     old_tree = DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl);
    3603                 :             :   else
    3604                 :   517582860 :     old_tree = target_option_default_node;
    3605                 :             : 
    3606                 :   588123075 :   if (fndecl == NULL_TREE)
    3607                 :             :     {
    3608                 :   323785406 :       if (old_tree != target_option_current_node)
    3609                 :     3692705 :         ix86_reset_previous_fndecl ();
    3610                 :   323785406 :       return;
    3611                 :             :     }
    3612                 :             : 
    3613                 :   264337669 :   ix86_set_func_type (fndecl);
    3614                 :   264337669 :   ix86_set_indirect_branch_type (fndecl);
    3615                 :             : 
    3616                 :   264337669 :   tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET (fndecl);
    3617                 :   264337669 :   if (new_tree == NULL_TREE)
    3618                 :   229444666 :     new_tree = target_option_default_node;
    3619                 :             : 
    3620                 :   264337669 :   bool fp_flag_change
    3621                 :   264337669 :     = (flag_unsafe_math_optimizations
    3622                 :   264337669 :        != TREE_TARGET_OPTION (new_tree)->x_ix86_unsafe_math_optimizations
    3623                 :   264337669 :        || (flag_excess_precision
    3624                 :   264337556 :            != TREE_TARGET_OPTION (new_tree)->x_ix86_excess_precision));
    3625                 :   264337669 :   if (old_tree != new_tree || fp_flag_change)
    3626                 :             :     {
    3627                 :     3692772 :       cl_target_option_restore (&global_options, &global_options_set,
    3628                 :     3692772 :                                 TREE_TARGET_OPTION (new_tree));
    3629                 :     3692772 :       if (fp_flag_change)
    3630                 :             :         {
    3631                 :         113 :           ix86_excess_precision = flag_excess_precision;
    3632                 :         113 :           ix86_unsafe_math_optimizations = flag_unsafe_math_optimizations;
    3633                 :         113 :           DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_tree
    3634                 :         113 :             = build_target_option_node (&global_options, &global_options_set);
    3635                 :             :         }
    3636                 :     3692772 :       if (TREE_TARGET_GLOBALS (new_tree))
    3637                 :     3652388 :         restore_target_globals (TREE_TARGET_GLOBALS (new_tree));
    3638                 :       40384 :       else if (new_tree == target_option_default_node)
    3639                 :       19655 :         restore_target_globals (&default_target_globals);
    3640                 :             :       else
    3641                 :       20729 :         TREE_TARGET_GLOBALS (new_tree) = save_target_globals_default_opts ();
    3642                 :             :     }
    3643                 :   264337669 :   ix86_previous_fndecl = fndecl;
    3644                 :             : 
    3645                 :   264337669 :   static call_saved_registers_type prev_call_saved_registers;
    3646                 :             : 
    3647                 :             :   /* 64-bit MS and SYSV ABI have different set of call used registers.
    3648                 :             :      Avoid expensive re-initialization of init_regs each time we switch
    3649                 :             :      function context.  */
    3650                 :   264337669 :   if (TARGET_64BIT
    3651                 :   264337669 :       && (call_used_or_fixed_reg_p (SI_REG)
    3652                 :   256120747 :           == (cfun->machine->call_abi == MS_ABI)))
    3653                 :       36106 :     reinit_regs ();
    3654                 :             :   /* Need to re-initialize init_regs if caller-saved registers are
    3655                 :             :      changed.  */
    3656                 :   264301563 :   else if (prev_call_saved_registers
    3657                 :   264301563 :            != cfun->machine->call_saved_registers)
    3658                 :        9350 :     reinit_regs ();
    3659                 :             : 
    3660                 :   264337669 :   if (cfun->machine->func_type != TYPE_NORMAL
    3661                 :   264333829 :       || (cfun->machine->call_saved_registers
    3662                 :   264333829 :           == TYPE_NO_CALLER_SAVED_REGISTERS))
    3663                 :             :     {
    3664                 :             :       /* Don't allow SSE, MMX nor x87 instructions since they
    3665                 :             :          may change processor state.  */
    3666                 :        4433 :       const char *isa;
    3667                 :        4433 :       if (TARGET_SSE)
    3668                 :             :         isa = "SSE";
    3669                 :        4432 :       else if (TARGET_MMX)
    3670                 :             :         isa = "MMX/3Dnow";
    3671                 :        4429 :       else if (TARGET_80387)
    3672                 :             :         isa = "80387";
    3673                 :             :       else
    3674                 :             :         isa = NULL;
    3675                 :             :       if (isa != NULL)
    3676                 :             :         {
    3677                 :           7 :           if (cfun->machine->func_type != TYPE_NORMAL)
    3678                 :           7 :             sorry (cfun->machine->func_type == TYPE_EXCEPTION
    3679                 :             :                    ? G_("%s instructions aren%'t allowed in an"
    3680                 :             :                         " exception service routine")
    3681                 :             :                    : G_("%s instructions aren%'t allowed in an"
    3682                 :             :                         " interrupt service routine"),
    3683                 :             :                    isa);
    3684                 :             :           else
    3685                 :           2 :             sorry ("%s instructions aren%'t allowed in a function with "
    3686                 :             :                    "the %<no_caller_saved_registers%> attribute", isa);
    3687                 :             :           /* Don't issue the same error twice.  */
    3688                 :           7 :           cfun->machine->func_type = TYPE_NORMAL;
    3689                 :           7 :           cfun->machine->call_saved_registers
    3690                 :           7 :             = TYPE_DEFAULT_CALL_SAVED_REGISTERS;
    3691                 :             :         }
    3692                 :             :     }
    3693                 :             : 
    3694                 :   264337669 :   prev_call_saved_registers = cfun->machine->call_saved_registers;
    3695                 :             : }
    3696                 :             : 
    3697                 :             : /* Implement the TARGET_OFFLOAD_OPTIONS hook.  */
    3698                 :             : char *
    3699                 :           0 : ix86_offload_options (void)
    3700                 :             : {
    3701                 :           0 :   if (TARGET_LP64)
    3702                 :           0 :     return xstrdup ("-foffload-abi=lp64 -foffload-abi-host-opts=-m64");
    3703                 :           0 :   return xstrdup ("-foffload-abi=ilp32 -foffload-abi-host-opts=-m32");
    3704                 :             : }
    3705                 :             : 
    3706                 :             : /* Handle "cdecl", "stdcall", "fastcall", "regparm", "thiscall",
    3707                 :             :    and "sseregparm" calling convention attributes;
    3708                 :             :    arguments as in struct attribute_spec.handler.  */
    3709                 :             : 
    3710                 :             : static tree
    3711                 :       11725 : ix86_handle_cconv_attribute (tree *node, tree name, tree args, int,
    3712                 :             :                              bool *no_add_attrs)
    3713                 :             : {
    3714                 :       11725 :   if (TREE_CODE (*node) != FUNCTION_TYPE
    3715                 :       11725 :       && TREE_CODE (*node) != METHOD_TYPE
    3716                 :             :       && TREE_CODE (*node) != FIELD_DECL
    3717                 :             :       && TREE_CODE (*node) != TYPE_DECL)
    3718                 :             :     {
    3719                 :           0 :       warning (OPT_Wattributes, "%qE attribute only applies to functions",
    3720                 :             :                name);
    3721                 :           0 :       *no_add_attrs = true;
    3722                 :           0 :       return NULL_TREE;
    3723                 :             :     }
    3724                 :             : 
    3725                 :             :   /* Can combine regparm with all attributes but fastcall, and thiscall.  */
    3726                 :       11725 :   if (is_attribute_p ("regparm", name))
    3727                 :             :     {
    3728                 :       10938 :       tree cst;
    3729                 :             : 
    3730                 :       10938 :       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
    3731                 :             :         {
    3732                 :           0 :           error ("fastcall and regparm attributes are not compatible");
    3733                 :             :         }
    3734                 :             : 
    3735                 :       10938 :       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
    3736                 :             :         {
    3737                 :           0 :           error ("regparam and thiscall attributes are not compatible");
    3738                 :             :         }
    3739                 :             : 
    3740                 :       10938 :       cst = TREE_VALUE (args);
    3741                 :       10938 :       if (TREE_CODE (cst) != INTEGER_CST)
    3742                 :             :         {
    3743                 :           0 :           warning (OPT_Wattributes,
    3744                 :             :                    "%qE attribute requires an integer constant argument",
    3745                 :             :                    name);
    3746                 :           0 :           *no_add_attrs = true;
    3747                 :             :         }
    3748                 :       10954 :       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
    3749                 :             :         {
    3750                 :           0 :           warning (OPT_Wattributes, "argument to %qE attribute larger than %d",
    3751                 :           0 :                    name, REGPARM_MAX);
    3752                 :           0 :           *no_add_attrs = true;
    3753                 :             :         }
    3754                 :             : 
    3755                 :       10938 :       return NULL_TREE;
    3756                 :             :     }
    3757                 :             : 
    3758                 :         787 :   if (TARGET_64BIT)
    3759                 :             :     {
    3760                 :             :       /* Do not warn when emulating the MS ABI.  */
    3761                 :         785 :       if ((TREE_CODE (*node) != FUNCTION_TYPE
    3762                 :             :            && TREE_CODE (*node) != METHOD_TYPE)
    3763                 :         785 :           || ix86_function_type_abi (*node) != MS_ABI)
    3764                 :         782 :         warning (OPT_Wattributes, "%qE attribute ignored",
    3765                 :             :                  name);
    3766                 :         785 :       *no_add_attrs = true;
    3767                 :         785 :       return NULL_TREE;
    3768                 :             :     }
    3769                 :             : 
    3770                 :             :   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
    3771                 :           2 :   if (is_attribute_p ("fastcall", name))
    3772                 :             :     {
    3773                 :           2 :       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
    3774                 :             :         {
    3775                 :           0 :           error ("fastcall and cdecl attributes are not compatible");
    3776                 :             :         }
    3777                 :           2 :       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
    3778                 :             :         {
    3779                 :           0 :           error ("fastcall and stdcall attributes are not compatible");
    3780                 :             :         }
    3781                 :           2 :       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
    3782                 :             :         {
    3783                 :           0 :           error ("fastcall and regparm attributes are not compatible");
    3784                 :             :         }
    3785                 :           2 :       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
    3786                 :             :         {
    3787                 :           0 :           error ("fastcall and thiscall attributes are not compatible");
    3788                 :             :         }
    3789                 :             :     }
    3790                 :             : 
    3791                 :             :   /* Can combine stdcall with fastcall (redundant), regparm and
    3792                 :             :      sseregparm.  */
    3793                 :           0 :   else if (is_attribute_p ("stdcall", name))
    3794                 :             :     {
    3795                 :           0 :       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
    3796                 :             :         {
    3797                 :           0 :           error ("stdcall and cdecl attributes are not compatible");
    3798                 :             :         }
    3799                 :           0 :       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
    3800                 :             :         {
    3801                 :           0 :           error ("stdcall and fastcall attributes are not compatible");
    3802                 :             :         }
    3803                 :           0 :       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
    3804                 :             :         {
    3805                 :           0 :           error ("stdcall and thiscall attributes are not compatible");
    3806                 :             :         }
    3807                 :             :     }
    3808                 :             : 
    3809                 :             :   /* Can combine cdecl with regparm and sseregparm.  */
    3810                 :           0 :   else if (is_attribute_p ("cdecl", name))
    3811                 :             :     {
    3812                 :           0 :       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
    3813                 :             :         {
    3814                 :           0 :           error ("stdcall and cdecl attributes are not compatible");
    3815                 :             :         }
    3816                 :           0 :       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
    3817                 :             :         {
    3818                 :           0 :           error ("fastcall and cdecl attributes are not compatible");
    3819                 :             :         }
    3820                 :           0 :       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
    3821                 :             :         {
    3822                 :           0 :           error ("cdecl and thiscall attributes are not compatible");
    3823                 :             :         }
    3824                 :             :     }
    3825                 :           0 :   else if (is_attribute_p ("thiscall", name))
    3826                 :             :     {
    3827                 :           0 :       if (TREE_CODE (*node) != METHOD_TYPE && pedantic)
    3828                 :           0 :         warning (OPT_Wattributes, "%qE attribute is used for non-class method",
    3829                 :             :                  name);
    3830                 :           0 :       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
    3831                 :             :         {
    3832                 :           0 :           error ("stdcall and thiscall attributes are not compatible");
    3833                 :             :         }
    3834                 :           0 :       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
    3835                 :             :         {
    3836                 :           0 :           error ("fastcall and thiscall attributes are not compatible");
    3837                 :             :         }
    3838                 :           0 :       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
    3839                 :             :         {
    3840                 :           0 :           error ("cdecl and thiscall attributes are not compatible");
    3841                 :             :         }
    3842                 :             :     }
    3843                 :             : 
    3844                 :             :   /* Can combine sseregparm with all attributes.  */
    3845                 :             : 
    3846                 :             :   return NULL_TREE;
    3847                 :             : }
    3848                 :             : 
    3849                 :             : #ifndef CHECK_STACK_LIMIT
    3850                 :             : #define CHECK_STACK_LIMIT (-1)
    3851                 :             : #endif
    3852                 :             : 
    3853                 :             : /* The transactional memory builtins are implicitly regparm or fastcall
    3854                 :             :    depending on the ABI.  Override the generic do-nothing attribute that
    3855                 :             :    these builtins were declared with, and replace it with one of the two
    3856                 :             :    attributes that we expect elsewhere.  */
    3857                 :             : 
    3858                 :             : static tree
    3859                 :       35259 : ix86_handle_tm_regparm_attribute (tree *node, tree, tree,
    3860                 :             :                                   int flags, bool *no_add_attrs)
    3861                 :             : {
    3862                 :       35259 :   tree alt;
    3863                 :             : 
    3864                 :             :   /* In no case do we want to add the placeholder attribute.  */
    3865                 :       35259 :   *no_add_attrs = true;
    3866                 :             : 
    3867                 :             :   /* The 64-bit ABI is unchanged for transactional memory.  */
    3868                 :       35259 :   if (TARGET_64BIT)
    3869                 :             :     return NULL_TREE;
    3870                 :             : 
    3871                 :             :   /* ??? Is there a better way to validate 32-bit windows?  We have
    3872                 :             :      cfun->machine->call_abi, but that seems to be set only for 64-bit.  */
    3873                 :           0 :   if (CHECK_STACK_LIMIT > 0)
    3874                 :             :     alt = tree_cons (get_identifier ("fastcall"), NULL, NULL);
    3875                 :             :   else
    3876                 :             :     {
    3877                 :           0 :       alt = tree_cons (NULL, build_int_cst (NULL, 2), NULL);
    3878                 :           0 :       alt = tree_cons (get_identifier ("regparm"), alt, NULL);
    3879                 :             :     }
    3880                 :           0 :   decl_attributes (node, alt, flags);
    3881                 :             : 
    3882                 :           0 :   return NULL_TREE;
    3883                 :             : }
    3884                 :             : 
    3885                 :             : /* Handle a "force_align_arg_pointer" attribute.  */
    3886                 :             : 
    3887                 :             : static tree
    3888                 :        5131 : ix86_handle_force_align_arg_pointer_attribute (tree *node, tree name,
    3889                 :             :                                                tree, int, bool *no_add_attrs)
    3890                 :             : {
    3891                 :        5131 :   if (TREE_CODE (*node) != FUNCTION_TYPE
    3892                 :        5131 :       && TREE_CODE (*node) != METHOD_TYPE
    3893                 :             :       && TREE_CODE (*node) != FIELD_DECL
    3894                 :             :       && TREE_CODE (*node) != TYPE_DECL)
    3895                 :             :     {
    3896                 :           0 :       warning (OPT_Wattributes, "%qE attribute only applies to functions",
    3897                 :             :                name);
    3898                 :           0 :       *no_add_attrs = true;
    3899                 :             :     }
    3900                 :             : 
    3901                 :        5131 :   return NULL_TREE;
    3902                 :             : }
    3903                 :             : 
    3904                 :             : /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
    3905                 :             :    struct attribute_spec.handler.  */
    3906                 :             : 
    3907                 :             : static tree
    3908                 :          74 : ix86_handle_struct_attribute (tree *node, tree name, tree, int,
    3909                 :             :                               bool *no_add_attrs)
    3910                 :             : {
    3911                 :          74 :   tree *type = NULL;
    3912                 :          74 :   if (DECL_P (*node))
    3913                 :             :     {
    3914                 :           0 :       if (TREE_CODE (*node) == TYPE_DECL)
    3915                 :           0 :         type = &TREE_TYPE (*node);
    3916                 :             :     }
    3917                 :             :   else
    3918                 :             :     type = node;
    3919                 :             : 
    3920                 :          74 :   if (!(type && RECORD_OR_UNION_TYPE_P (*type)))
    3921                 :             :     {
    3922                 :           0 :       warning (OPT_Wattributes, "%qE attribute ignored",
    3923                 :             :                name);
    3924                 :           0 :       *no_add_attrs = true;
    3925                 :             :     }
    3926                 :             : 
    3927                 :          74 :   else if ((is_attribute_p ("ms_struct", name)
    3928                 :          62 :             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
    3929                 :         136 :            || ((is_attribute_p ("gcc_struct", name)
    3930                 :          12 :                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
    3931                 :             :     {
    3932                 :           0 :       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
    3933                 :             :                name);
    3934                 :           0 :       *no_add_attrs = true;
    3935                 :             :     }
    3936                 :             : 
    3937                 :          74 :   return NULL_TREE;
    3938                 :             : }
    3939                 :             : 
    3940                 :             : /* Handle a "callee_pop_aggregate_return" attribute; arguments as
    3941                 :             :    in struct attribute_spec handler.  */
    3942                 :             : 
    3943                 :             : static tree
    3944                 :           0 : ix86_handle_callee_pop_aggregate_return (tree *node, tree name, tree args, int,
    3945                 :             :                                          bool *no_add_attrs)
    3946                 :             : {
    3947                 :           0 :   if (TREE_CODE (*node) != FUNCTION_TYPE
    3948                 :           0 :       && TREE_CODE (*node) != METHOD_TYPE
    3949                 :             :       && TREE_CODE (*node) != FIELD_DECL
    3950                 :             :       && TREE_CODE (*node) != TYPE_DECL)
    3951                 :             :     {
    3952                 :           0 :       warning (OPT_Wattributes, "%qE attribute only applies to functions",
    3953                 :             :                name);
    3954                 :           0 :       *no_add_attrs = true;
    3955                 :           0 :       return NULL_TREE;
    3956                 :             :     }
    3957                 :           0 :   if (TARGET_64BIT)
    3958                 :             :     {
    3959                 :           0 :       warning (OPT_Wattributes, "%qE attribute only available for 32-bit",
    3960                 :             :                name);
    3961                 :           0 :       *no_add_attrs = true;
    3962                 :           0 :       return NULL_TREE;
    3963                 :             :     }
    3964                 :           0 :   if (is_attribute_p ("callee_pop_aggregate_return", name))
    3965                 :             :     {
    3966                 :           0 :       tree cst;
    3967                 :             : 
    3968                 :           0 :       cst = TREE_VALUE (args);
    3969                 :           0 :       if (TREE_CODE (cst) != INTEGER_CST)
    3970                 :             :         {
    3971                 :           0 :           warning (OPT_Wattributes,
    3972                 :             :                    "%qE attribute requires an integer constant argument",
    3973                 :             :                    name);
    3974                 :           0 :           *no_add_attrs = true;
    3975                 :             :         }
    3976                 :           0 :       else if (compare_tree_int (cst, 0) != 0
    3977                 :           0 :                && compare_tree_int (cst, 1) != 0)
    3978                 :             :         {
    3979                 :           0 :           warning (OPT_Wattributes,
    3980                 :             :                    "argument to %qE attribute is neither zero, nor one",
    3981                 :             :                    name);
    3982                 :           0 :           *no_add_attrs = true;
    3983                 :             :         }
    3984                 :             : 
    3985                 :           0 :       return NULL_TREE;
    3986                 :             :     }
    3987                 :             : 
    3988                 :             :   return NULL_TREE;
    3989                 :             : }
    3990                 :             : 
    3991                 :             : /* Handle a "ms_abi" or "sysv" attribute; arguments as in
    3992                 :             :    struct attribute_spec.handler.  */
    3993                 :             : 
    3994                 :             : static tree
    3995                 :     1548201 : ix86_handle_abi_attribute (tree *node, tree name, tree, int,
    3996                 :             :                            bool *no_add_attrs)
    3997                 :             : {
    3998                 :     1548201 :   if (TREE_CODE (*node) != FUNCTION_TYPE
    3999                 :     1548201 :       && TREE_CODE (*node) != METHOD_TYPE
    4000                 :             :       && TREE_CODE (*node) != FIELD_DECL
    4001                 :             :       && TREE_CODE (*node) != TYPE_DECL)
    4002                 :             :     {
    4003                 :           0 :       warning (OPT_Wattributes, "%qE attribute only applies to functions",
    4004                 :             :                name);
    4005                 :           0 :       *no_add_attrs = true;
    4006                 :           0 :       return NULL_TREE;
    4007                 :             :     }
    4008                 :             : 
    4009                 :             :   /* Can combine regparm with all attributes but fastcall.  */
    4010                 :     1548201 :   if (is_attribute_p ("ms_abi", name))
    4011                 :             :     {
    4012                 :      794331 :       if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
    4013                 :             :         {
    4014                 :           0 :           error ("%qs and %qs attributes are not compatible",
    4015                 :             :                  "ms_abi", "sysv_abi");
    4016                 :             :         }
    4017                 :             : 
    4018                 :      794331 :       return NULL_TREE;
    4019                 :             :     }
    4020                 :      753870 :   else if (is_attribute_p ("sysv_abi", name))
    4021                 :             :     {
    4022                 :      753870 :       if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
    4023                 :             :         {
    4024                 :           0 :           error ("%qs and %qs attributes are not compatible",
    4025                 :             :                  "ms_abi", "sysv_abi");
    4026                 :             :         }
    4027                 :             : 
    4028                 :      753870 :       return NULL_TREE;
    4029                 :             :     }
    4030                 :             : 
    4031                 :             :   return NULL_TREE;
    4032                 :             : }
    4033                 :             : 
    4034                 :             : static tree
    4035                 :         121 : ix86_handle_fndecl_attribute (tree *node, tree name, tree args, int,
    4036                 :             :                               bool *no_add_attrs)
    4037                 :             : {
    4038                 :         121 :   if (TREE_CODE (*node) != FUNCTION_DECL)
    4039                 :             :     {
    4040                 :           0 :       warning (OPT_Wattributes, "%qE attribute only applies to functions",
    4041                 :             :                name);
    4042                 :           0 :       *no_add_attrs = true;
    4043                 :             :     }
    4044                 :             : 
    4045                 :         121 :   if (is_attribute_p ("indirect_branch", name))
    4046                 :             :     {
    4047                 :          17 :       tree cst = TREE_VALUE (args);
    4048                 :          17 :       if (TREE_CODE (cst) != STRING_CST)
    4049                 :             :         {
    4050                 :           0 :           warning (OPT_Wattributes,
    4051                 :             :                    "%qE attribute requires a string constant argument",
    4052                 :             :                    name);
    4053                 :           0 :           *no_add_attrs = true;
    4054                 :             :         }
    4055                 :          17 :       else if (strcmp (TREE_STRING_POINTER (cst), "keep") != 0
    4056                 :          15 :                && strcmp (TREE_STRING_POINTER (cst), "thunk") != 0
    4057                 :          10 :                && strcmp (TREE_STRING_POINTER (cst), "thunk-inline") != 0
    4058                 :          24 :                && strcmp (TREE_STRING_POINTER (cst), "thunk-extern") != 0)
    4059                 :             :         {
    4060                 :           0 :           warning (OPT_Wattributes,
    4061                 :             :                    "argument to %qE attribute is not "
    4062                 :             :                    "(keep|thunk|thunk-inline|thunk-extern)", name);
    4063                 :           0 :           *no_add_attrs = true;
    4064                 :             :         }
    4065                 :             :     }
    4066                 :             : 
    4067                 :         121 :   if (is_attribute_p ("function_return", name))
    4068                 :             :     {
    4069                 :          12 :       tree cst = TREE_VALUE (args);
    4070                 :          12 :       if (TREE_CODE (cst) != STRING_CST)
    4071                 :             :         {
    4072                 :           0 :           warning (OPT_Wattributes,
    4073                 :             :                    "%qE attribute requires a string constant argument",
    4074                 :             :                    name);
    4075                 :           0 :           *no_add_attrs = true;
    4076                 :             :         }
    4077                 :          12 :       else if (strcmp (TREE_STRING_POINTER (cst), "keep") != 0
    4078                 :          10 :                && strcmp (TREE_STRING_POINTER (cst), "thunk") != 0
    4079                 :           6 :                && strcmp (TREE_STRING_POINTER (cst), "thunk-inline") != 0
    4080                 :          15 :                && strcmp (TREE_STRING_POINTER (cst), "thunk-extern") != 0)
    4081                 :             :         {
    4082                 :           0 :           warning (OPT_Wattributes,
    4083                 :             :                    "argument to %qE attribute is not "
    4084                 :             :                    "(keep|thunk|thunk-inline|thunk-extern)", name);
    4085                 :           0 :           *no_add_attrs = true;
    4086                 :             :         }
    4087                 :             :     }
    4088                 :             : 
    4089                 :         121 :   return NULL_TREE;
    4090                 :             : }
    4091                 :             : 
    4092                 :             : static tree
    4093                 :          86 : ix86_handle_call_saved_registers_attribute (tree *, tree, tree,
    4094                 :             :                                             int, bool *)
    4095                 :             : {
    4096                 :          86 :   return NULL_TREE;
    4097                 :             : }
    4098                 :             : 
    4099                 :             : static tree
    4100                 :         124 : ix86_handle_interrupt_attribute (tree *node, tree, tree, int, bool *)
    4101                 :             : {
    4102                 :             :   /* DECL_RESULT and DECL_ARGUMENTS do not exist there yet,
    4103                 :             :      but the function type contains args and return type data.  */
    4104                 :         124 :   tree func_type = *node;
    4105                 :         124 :   tree return_type = TREE_TYPE (func_type);
    4106                 :             : 
    4107                 :         124 :   int nargs = 0;
    4108                 :         124 :   tree current_arg_type = TYPE_ARG_TYPES (func_type);
    4109                 :         124 :   while (current_arg_type
    4110                 :         618 :          && ! VOID_TYPE_P (TREE_VALUE (current_arg_type)))
    4111                 :             :     {
    4112                 :         185 :       if (nargs == 0)
    4113                 :             :         {
    4114                 :         123 :           if (! POINTER_TYPE_P (TREE_VALUE (current_arg_type)))
    4115                 :           2 :             error ("interrupt service routine should have a pointer "
    4116                 :             :                    "as the first argument");
    4117                 :             :         }
    4118                 :          62 :       else if (nargs == 1)
    4119                 :             :         {
    4120                 :          62 :           if (TREE_CODE (TREE_VALUE (current_arg_type)) != INTEGER_TYPE
    4121                 :          62 :               || TYPE_MODE (TREE_VALUE (current_arg_type)) != word_mode)
    4122                 :           2 :             error ("interrupt service routine should have %qs "
    4123                 :             :                    "as the second argument",
    4124                 :           2 :                    TARGET_64BIT
    4125                 :           2 :                    ? (TARGET_X32 ? "unsigned long long int"
    4126                 :             :                                  : "unsigned long int")
    4127                 :             :                    : "unsigned int");
    4128                 :             :         }
    4129                 :         185 :       nargs++;
    4130                 :         185 :       current_arg_type = TREE_CHAIN (current_arg_type);
    4131                 :             :     }
    4132                 :         124 :   if (!nargs || nargs > 2)
    4133                 :           1 :     error ("interrupt service routine can only have a pointer argument "
    4134                 :             :            "and an optional integer argument");
    4135                 :         124 :   if (! VOID_TYPE_P (return_type))
    4136                 :           1 :     error ("interrupt service routine must return %<void%>");
    4137                 :             : 
    4138                 :         124 :   return NULL_TREE;
    4139                 :             : }
    4140                 :             : 
    4141                 :             : /* Handle fentry_name / fentry_section attribute.  */
    4142                 :             : 
    4143                 :             : static tree
    4144                 :           4 : ix86_handle_fentry_name (tree *node, tree name, tree args,
    4145                 :             :                          int, bool *no_add_attrs)
    4146                 :             : {
    4147                 :           4 :   if (TREE_CODE (*node) == FUNCTION_DECL
    4148                 :           8 :       && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
    4149                 :             :     /* Do nothing else, just set the attribute.  We'll get at
    4150                 :             :        it later with lookup_attribute.  */
    4151                 :             :     ;
    4152                 :             :   else
    4153                 :             :     {
    4154                 :           0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4155                 :           0 :       *no_add_attrs = true;
    4156                 :             :     }
    4157                 :             : 
    4158                 :           4 :   return NULL_TREE;
    4159                 :             : }
    4160                 :             : 
    4161                 :             : /* Handle a "nodirect_extern_access" attribute; arguments as in
    4162                 :             :    struct attribute_spec.handler.  */
    4163                 :             : 
    4164                 :             : static tree
    4165                 :          11 : handle_nodirect_extern_access_attribute (tree *pnode, tree name,
    4166                 :             :                                          tree ARG_UNUSED (args),
    4167                 :             :                                          int ARG_UNUSED (flags),
    4168                 :             :                                          bool *no_add_attrs)
    4169                 :             : {
    4170                 :          11 :   tree node = *pnode;
    4171                 :             : 
    4172                 :          11 :   if (VAR_OR_FUNCTION_DECL_P (node))
    4173                 :             :     {
    4174                 :           7 :       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
    4175                 :          18 :            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
    4176                 :             :         {
    4177                 :           0 :           warning (OPT_Wattributes,
    4178                 :             :                    "%qE attribute have effect only on public objects", name);
    4179                 :           0 :           *no_add_attrs = true;
    4180                 :             :         }
    4181                 :             :     }
    4182                 :             :   else
    4183                 :             :     {
    4184                 :           0 :       warning (OPT_Wattributes, "%qE attribute ignored", name);
    4185                 :           0 :       *no_add_attrs = true;
    4186                 :             :     }
    4187                 :             : 
    4188                 :          11 :   return NULL_TREE;
    4189                 :             : }
    4190                 :             : 
    4191                 :             : /* Table of valid machine attributes.  */
    4192                 :             : static const attribute_spec ix86_gnu_attributes[] =
    4193                 :             : {
    4194                 :             :   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
    4195                 :             :        affects_type_identity, handler, exclude } */
    4196                 :             :   /* Stdcall attribute says callee is responsible for popping arguments
    4197                 :             :      if they are not variable.  */
    4198                 :             :   { "stdcall",   0, 0, false, true,  true,  true, ix86_handle_cconv_attribute,
    4199                 :             :     NULL },
    4200                 :             :   /* Fastcall attribute says callee is responsible for popping arguments
    4201                 :             :      if they are not variable.  */
    4202                 :             :   { "fastcall",  0, 0, false, true,  true,  true, ix86_handle_cconv_attribute,
    4203                 :             :     NULL },
    4204                 :             :   /* Thiscall attribute says callee is responsible for popping arguments
    4205                 :             :      if they are not variable.  */
    4206                 :             :   { "thiscall",  0, 0, false, true,  true,  true, ix86_handle_cconv_attribute,
    4207                 :             :     NULL },
    4208                 :             :   /* Cdecl attribute says the callee is a normal C declaration */
    4209                 :             :   { "cdecl",     0, 0, false, true,  true,  true, ix86_handle_cconv_attribute,
    4210                 :             :     NULL },
    4211                 :             :   /* Regparm attribute specifies how many integer arguments are to be
    4212                 :             :      passed in registers.  */
    4213                 :             :   { "regparm",   1, 1, false, true,  true,  true, ix86_handle_cconv_attribute,
    4214                 :             :     NULL },
    4215                 :             :   /* Sseregparm attribute says we are using x86_64 calling conventions
    4216                 :             :      for FP arguments.  */
    4217                 :             :   { "sseregparm", 0, 0, false, true, true,  true, ix86_handle_cconv_attribute,
    4218                 :             :     NULL },
    4219                 :             :   /* The transactional memory builtins are implicitly regparm or fastcall
    4220                 :             :      depending on the ABI.  Override the generic do-nothing attribute that
    4221                 :             :      these builtins were declared with.  */
    4222                 :             :   { "*tm regparm", 0, 0, false, true, true, true,
    4223                 :             :     ix86_handle_tm_regparm_attribute, NULL },
    4224                 :             :   /* force_align_arg_pointer says this function realigns the stack at entry.  */
    4225                 :             :   { "force_align_arg_pointer", 0, 0,
    4226                 :             :     false, true,  true, false, ix86_handle_force_align_arg_pointer_attribute,
    4227                 :             :     NULL },
    4228                 :             : #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
    4229                 :             :   { "dllimport", 0, 0, false, false, false, false, handle_dll_attribute,
    4230                 :             :     NULL },
    4231                 :             :   { "dllexport", 0, 0, false, false, false, false, handle_dll_attribute,
    4232                 :             :     NULL },
    4233                 :             :   { "shared",    0, 0, true,  false, false, false,
    4234                 :             :     ix86_handle_shared_attribute, NULL },
    4235                 :             : #endif
    4236                 :             :   { "ms_struct", 0, 0, false, false,  false, false,
    4237                 :             :     ix86_handle_struct_attribute, NULL },
    4238                 :             :   { "gcc_struct", 0, 0, false, false,  false, false,
    4239                 :             :     ix86_handle_struct_attribute, NULL },
    4240                 :             : #ifdef SUBTARGET_ATTRIBUTE_TABLE
    4241                 :             :   SUBTARGET_ATTRIBUTE_TABLE,
    4242                 :             : #endif
    4243                 :             :   /* ms_abi and sysv_abi calling convention function attributes.  */
    4244                 :             :   { "ms_abi", 0, 0, false, true, true, true, ix86_handle_abi_attribute, NULL },
    4245                 :             :   { "sysv_abi", 0, 0, false, true, true, true, ix86_handle_abi_attribute,
    4246                 :             :     NULL },
    4247                 :             :   { "ms_abi va_list", 0, 0, false, false, false, false, NULL, NULL },
    4248                 :             :   { "sysv_abi va_list", 0, 0, false, false, false, false, NULL, NULL },
    4249                 :             :   { "ms_hook_prologue", 0, 0, true, false, false, false,
    4250                 :             :     ix86_handle_fndecl_attribute, NULL },
    4251                 :             :   { "callee_pop_aggregate_return", 1, 1, false, true, true, true,
    4252                 :             :     ix86_handle_callee_pop_aggregate_return, NULL },
    4253                 :             :   { "interrupt", 0, 0, false, true, true, false,
    4254                 :             :     ix86_handle_interrupt_attribute, NULL },
    4255                 :             :   { "no_caller_saved_registers", 0, 0, false, true, true, false,
    4256                 :             :     ix86_handle_call_saved_registers_attribute, NULL },
    4257                 :             :   { "no_callee_saved_registers", 0, 0, false, true, true, true,
    4258                 :             :     ix86_handle_call_saved_registers_attribute, NULL },
    4259                 :             :   { "naked", 0, 0, true, false, false, false,
    4260                 :             :     ix86_handle_fndecl_attribute, NULL },
    4261                 :             :   { "indirect_branch", 1, 1, true, false, false, false,
    4262                 :             :     ix86_handle_fndecl_attribute, NULL },
    4263                 :             :   { "function_return", 1, 1, true, false, false, false,
    4264                 :             :     ix86_handle_fndecl_attribute, NULL },
    4265                 :             :   { "indirect_return", 0, 0, false, true, true, false,
    4266                 :             :     NULL, NULL },
    4267                 :             :   { "fentry_name", 1, 1, true, false, false, false,
    4268                 :             :     ix86_handle_fentry_name, NULL },
    4269                 :             :   { "fentry_section", 1, 1, true, false, false, false,
    4270                 :             :     ix86_handle_fentry_name, NULL },
    4271                 :             :   { "cf_check", 0, 0, true, false, false, false,
    4272                 :             :     ix86_handle_fndecl_attribute, NULL },
    4273                 :             :   { "nodirect_extern_access", 0, 0, true, false, false, false,
    4274                 :             :     handle_nodirect_extern_access_attribute, NULL }
    4275                 :             : };
    4276                 :             : 
    4277                 :             : const scoped_attribute_specs ix86_gnu_attribute_table =
    4278                 :             : {
    4279                 :             :   "gnu", { ix86_gnu_attributes }
    4280                 :             : };
    4281                 :             : 
    4282                 :             : #include "gt-i386-options.h"
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.