6a2141e48dbd4f44bbd0efc9967d1afa3bf81725
[dragonfly.git] / contrib / gcc-8.0 / gcc / config / i386 / i386.c
1 /* Subroutines used for code generation on IA-32.
2    Copyright (C) 1988-2018 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #define IN_TARGET_CODE 1
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "memmodel.h"
29 #include "gimple.h"
30 #include "cfghooks.h"
31 #include "cfgloop.h"
32 #include "df.h"
33 #include "tm_p.h"
34 #include "stringpool.h"
35 #include "expmed.h"
36 #include "optabs.h"
37 #include "regs.h"
38 #include "emit-rtl.h"
39 #include "recog.h"
40 #include "cgraph.h"
41 #include "diagnostic.h"
42 #include "cfgbuild.h"
43 #include "alias.h"
44 #include "fold-const.h"
45 #include "attribs.h"
46 #include "calls.h"
47 #include "stor-layout.h"
48 #include "varasm.h"
49 #include "output.h"
50 #include "insn-attr.h"
51 #include "flags.h"
52 #include "except.h"
53 #include "explow.h"
54 #include "expr.h"
55 #include "cfgrtl.h"
56 #include "common/common-target.h"
57 #include "langhooks.h"
58 #include "reload.h"
59 #include "gimplify.h"
60 #include "dwarf2.h"
61 #include "tm-constrs.h"
62 #include "params.h"
63 #include "cselib.h"
64 #include "sched-int.h"
65 #include "opts.h"
66 #include "tree-pass.h"
67 #include "context.h"
68 #include "pass_manager.h"
69 #include "target-globals.h"
70 #include "gimple-iterator.h"
71 #include "tree-vectorizer.h"
72 #include "shrink-wrap.h"
73 #include "builtins.h"
74 #include "rtl-iter.h"
75 #include "tree-iterator.h"
76 #include "tree-chkp.h"
77 #include "rtl-chkp.h"
78 #include "dbgcnt.h"
79 #include "case-cfn-macros.h"
80 #include "regrename.h"
81 #include "dojump.h"
82 #include "fold-const-call.h"
83 #include "tree-vrp.h"
84 #include "tree-ssanames.h"
85 #include "selftest.h"
86 #include "selftest-rtl.h"
87 #include "print-rtl.h"
88 #include "intl.h"
89 #include "ifcvt.h"
90 #include "symbol-summary.h"
91 #include "ipa-prop.h"
92 #include "ipa-fnsummary.h"
93 #include "wide-int-bitmask.h"
94
95 /* This file should be included last.  */
96 #include "target-def.h"
97
98 #include "x86-tune-costs.h"
99
100 static rtx legitimize_dllimport_symbol (rtx, bool);
101 static rtx legitimize_pe_coff_extern_decl (rtx, bool);
102 static rtx legitimize_pe_coff_symbol (rtx, bool);
103 static void ix86_print_operand_address_as (FILE *, rtx, addr_space_t, bool);
104 static bool ix86_save_reg (unsigned int, bool, bool);
105 static bool ix86_function_naked (const_tree);
106 static bool ix86_notrack_prefixed_insn_p (rtx);
107 static void ix86_emit_restore_reg_using_pop (rtx);
108
109
110 #ifndef CHECK_STACK_LIMIT
111 #define CHECK_STACK_LIMIT (-1)
112 #endif
113
114 /* Return index of given mode in mult and division cost tables.  */
115 #define MODE_INDEX(mode)                                        \
116   ((mode) == QImode ? 0                                         \
117    : (mode) == HImode ? 1                                       \
118    : (mode) == SImode ? 2                                       \
119    : (mode) == DImode ? 3                                       \
120    : 4)
121
122
123 /* Set by -mtune.  */
124 const struct processor_costs *ix86_tune_cost = NULL;
125
126 /* Set by -mtune or -Os.  */
127 const struct processor_costs *ix86_cost = NULL;
128
129 /* Processor feature/optimization bitmasks.  */
130 #define m_386 (HOST_WIDE_INT_1U<<PROCESSOR_I386)
131 #define m_486 (HOST_WIDE_INT_1U<<PROCESSOR_I486)
132 #define m_PENT (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUM)
133 #define m_LAKEMONT (HOST_WIDE_INT_1U<<PROCESSOR_LAKEMONT)
134 #define m_PPRO (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUMPRO)
135 #define m_PENT4 (HOST_WIDE_INT_1U<<PROCESSOR_PENTIUM4)
136 #define m_NOCONA (HOST_WIDE_INT_1U<<PROCESSOR_NOCONA)
137 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
138 #define m_CORE2 (HOST_WIDE_INT_1U<<PROCESSOR_CORE2)
139 #define m_NEHALEM (HOST_WIDE_INT_1U<<PROCESSOR_NEHALEM)
140 #define m_SANDYBRIDGE (HOST_WIDE_INT_1U<<PROCESSOR_SANDYBRIDGE)
141 #define m_HASWELL (HOST_WIDE_INT_1U<<PROCESSOR_HASWELL)
142 #define m_CORE_ALL (m_CORE2 | m_NEHALEM  | m_SANDYBRIDGE | m_HASWELL)
143 #define m_BONNELL (HOST_WIDE_INT_1U<<PROCESSOR_BONNELL)
144 #define m_SILVERMONT (HOST_WIDE_INT_1U<<PROCESSOR_SILVERMONT)
145 #define m_KNL (HOST_WIDE_INT_1U<<PROCESSOR_KNL)
146 #define m_KNM (HOST_WIDE_INT_1U<<PROCESSOR_KNM)
147 #define m_SKYLAKE (HOST_WIDE_INT_1U<<PROCESSOR_SKYLAKE)
148 #define m_SKYLAKE_AVX512 (HOST_WIDE_INT_1U<<PROCESSOR_SKYLAKE_AVX512)
149 #define m_CANNONLAKE (HOST_WIDE_INT_1U<<PROCESSOR_CANNONLAKE)
150 #define m_ICELAKE_CLIENT (HOST_WIDE_INT_1U<<PROCESSOR_ICELAKE_CLIENT)
151 #define m_ICELAKE_SERVER (HOST_WIDE_INT_1U<<PROCESSOR_ICELAKE_SERVER)
152 #define m_INTEL (HOST_WIDE_INT_1U<<PROCESSOR_INTEL)
153
154 #define m_GEODE (HOST_WIDE_INT_1U<<PROCESSOR_GEODE)
155 #define m_K6 (HOST_WIDE_INT_1U<<PROCESSOR_K6)
156 #define m_K6_GEODE (m_K6 | m_GEODE)
157 #define m_K8 (HOST_WIDE_INT_1U<<PROCESSOR_K8)
158 #define m_ATHLON (HOST_WIDE_INT_1U<<PROCESSOR_ATHLON)
159 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
160 #define m_AMDFAM10 (HOST_WIDE_INT_1U<<PROCESSOR_AMDFAM10)
161 #define m_BDVER1 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER1)
162 #define m_BDVER2 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER2)
163 #define m_BDVER3 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER3)
164 #define m_BDVER4 (HOST_WIDE_INT_1U<<PROCESSOR_BDVER4)
165 #define m_ZNVER1 (HOST_WIDE_INT_1U<<PROCESSOR_ZNVER1)
166 #define m_BTVER1 (HOST_WIDE_INT_1U<<PROCESSOR_BTVER1)
167 #define m_BTVER2 (HOST_WIDE_INT_1U<<PROCESSOR_BTVER2)
168 #define m_BDVER (m_BDVER1 | m_BDVER2 | m_BDVER3 | m_BDVER4)
169 #define m_BTVER (m_BTVER1 | m_BTVER2)
170 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER \
171                         | m_ZNVER1)
172
173 #define m_GENERIC (HOST_WIDE_INT_1U<<PROCESSOR_GENERIC)
174
175 const char* ix86_tune_feature_names[X86_TUNE_LAST] = {
176 #undef DEF_TUNE
177 #define DEF_TUNE(tune, name, selector) name,
178 #include "x86-tune.def"
179 #undef DEF_TUNE
180 };
181
182 /* Feature tests against the various tunings.  */
183 unsigned char ix86_tune_features[X86_TUNE_LAST];
184
185 /* Feature tests against the various tunings used to create ix86_tune_features
186    based on the processor mask.  */
187 static unsigned HOST_WIDE_INT initial_ix86_tune_features[X86_TUNE_LAST] = {
188 #undef DEF_TUNE
189 #define DEF_TUNE(tune, name, selector) selector,
190 #include "x86-tune.def"
191 #undef DEF_TUNE
192 };
193
194 /* Feature tests against the various architecture variations.  */
195 unsigned char ix86_arch_features[X86_ARCH_LAST];
196
197 /* Feature tests against the various architecture variations, used to create
198    ix86_arch_features based on the processor mask.  */
199 static unsigned HOST_WIDE_INT initial_ix86_arch_features[X86_ARCH_LAST] = {
200   /* X86_ARCH_CMOV: Conditional move was added for pentiumpro.  */
201   ~(m_386 | m_486 | m_PENT | m_LAKEMONT | m_K6),
202
203   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
204   ~m_386,
205
206   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
207   ~(m_386 | m_486),
208
209   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
210   ~m_386,
211
212   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
213   ~m_386,
214 };
215
216 /* In case the average insn count for single function invocation is
217    lower than this constant, emit fast (but longer) prologue and
218    epilogue code.  */
219 #define FAST_PROLOGUE_INSN_COUNT 20
220
221 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
222 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
223 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
224 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
225
226 /* Array of the smallest class containing reg number REGNO, indexed by
227    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
228
229 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
230 {
231   /* ax, dx, cx, bx */
232   AREG, DREG, CREG, BREG,
233   /* si, di, bp, sp */
234   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
235   /* FP registers */
236   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
237   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
238   /* arg pointer */
239   NON_Q_REGS,
240   /* flags, fpsr, fpcr, frame */
241   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
242   /* SSE registers */
243   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
244   SSE_REGS, SSE_REGS,
245   /* MMX registers */
246   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
247   MMX_REGS, MMX_REGS,
248   /* REX registers */
249   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
250   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
251   /* SSE REX registers */
252   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
253   SSE_REGS, SSE_REGS,
254   /* AVX-512 SSE registers */
255   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
256   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
257   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
258   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
259   /* Mask registers.  */
260   MASK_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS,
261   MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS,
262   /* MPX bound registers */
263   BND_REGS, BND_REGS, BND_REGS, BND_REGS,
264 };
265
266 /* The "default" register map used in 32bit mode.  */
267
268 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
269 {
270   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
271   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
272   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
273   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
274   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
275   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
276   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
277   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 16-23*/
278   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 24-31*/
279   93, 94, 95, 96, 97, 98, 99, 100,      /* Mask registers */
280   101, 102, 103, 104,                   /* bound registers */
281 };
282
283 /* The "default" register map used in 64bit mode.  */
284
285 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
286 {
287   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
288   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
289   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
290   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
291   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
292   8,9,10,11,12,13,14,15,                /* extended integer registers */
293   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
294   67, 68, 69, 70, 71, 72, 73, 74,       /* AVX-512 registers 16-23 */
295   75, 76, 77, 78, 79, 80, 81, 82,       /* AVX-512 registers 24-31 */
296   118, 119, 120, 121, 122, 123, 124, 125, /* Mask registers */
297   126, 127, 128, 129,                   /* bound registers */
298 };
299
300 /* Define the register numbers to be used in Dwarf debugging information.
301    The SVR4 reference port C compiler uses the following register numbers
302    in its Dwarf output code:
303         0 for %eax (gcc regno = 0)
304         1 for %ecx (gcc regno = 2)
305         2 for %edx (gcc regno = 1)
306         3 for %ebx (gcc regno = 3)
307         4 for %esp (gcc regno = 7)
308         5 for %ebp (gcc regno = 6)
309         6 for %esi (gcc regno = 4)
310         7 for %edi (gcc regno = 5)
311    The following three DWARF register numbers are never generated by
312    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
313    believed these numbers have these meanings.
314         8  for %eip    (no gcc equivalent)
315         9  for %eflags (gcc regno = 17)
316         10 for %trapno (no gcc equivalent)
317    It is not at all clear how we should number the FP stack registers
318    for the x86 architecture.  If the version of SDB on x86/svr4 were
319    a bit less brain dead with respect to floating-point then we would
320    have a precedent to follow with respect to DWARF register numbers
321    for x86 FP registers, but the SDB on x86/svr4 was so completely
322    broken with respect to FP registers that it is hardly worth thinking
323    of it as something to strive for compatibility with.
324    The version of x86/svr4 SDB I had does (partially)
325    seem to believe that DWARF register number 11 is associated with
326    the x86 register %st(0), but that's about all.  Higher DWARF
327    register numbers don't seem to be associated with anything in
328    particular, and even for DWARF regno 11, SDB only seemed to under-
329    stand that it should say that a variable lives in %st(0) (when
330    asked via an `=' command) if we said it was in DWARF regno 11,
331    but SDB still printed garbage when asked for the value of the
332    variable in question (via a `/' command).
333    (Also note that the labels SDB printed for various FP stack regs
334    when doing an `x' command were all wrong.)
335    Note that these problems generally don't affect the native SVR4
336    C compiler because it doesn't allow the use of -O with -g and
337    because when it is *not* optimizing, it allocates a memory
338    location for each floating-point variable, and the memory
339    location is what gets described in the DWARF AT_location
340    attribute for the variable in question.
341    Regardless of the severe mental illness of the x86/svr4 SDB, we
342    do something sensible here and we use the following DWARF
343    register numbers.  Note that these are all stack-top-relative
344    numbers.
345         11 for %st(0) (gcc regno = 8)
346         12 for %st(1) (gcc regno = 9)
347         13 for %st(2) (gcc regno = 10)
348         14 for %st(3) (gcc regno = 11)
349         15 for %st(4) (gcc regno = 12)
350         16 for %st(5) (gcc regno = 13)
351         17 for %st(6) (gcc regno = 14)
352         18 for %st(7) (gcc regno = 15)
353 */
354 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
355 {
356   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
357   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
358   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
359   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
360   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
361   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
362   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
363   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 16-23*/
364   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 24-31*/
365   93, 94, 95, 96, 97, 98, 99, 100,      /* Mask registers */
366   101, 102, 103, 104,                   /* bound registers */
367 };
368
369 /* Define parameter passing and return registers.  */
370
371 static int const x86_64_int_parameter_registers[6] =
372 {
373   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
374 };
375
376 static int const x86_64_ms_abi_int_parameter_registers[4] =
377 {
378   CX_REG, DX_REG, R8_REG, R9_REG
379 };
380
381 static int const x86_64_int_return_registers[4] =
382 {
383   AX_REG, DX_REG, DI_REG, SI_REG
384 };
385
386 /* Additional registers that are clobbered by SYSV calls.  */
387
388 #define NUM_X86_64_MS_CLOBBERED_REGS 12
389 static int const x86_64_ms_sysv_extra_clobbered_registers
390                  [NUM_X86_64_MS_CLOBBERED_REGS] =
391 {
392   SI_REG, DI_REG,
393   XMM6_REG, XMM7_REG,
394   XMM8_REG, XMM9_REG, XMM10_REG, XMM11_REG,
395   XMM12_REG, XMM13_REG, XMM14_REG, XMM15_REG
396 };
397
398 enum xlogue_stub {
399   XLOGUE_STUB_SAVE,
400   XLOGUE_STUB_RESTORE,
401   XLOGUE_STUB_RESTORE_TAIL,
402   XLOGUE_STUB_SAVE_HFP,
403   XLOGUE_STUB_RESTORE_HFP,
404   XLOGUE_STUB_RESTORE_HFP_TAIL,
405
406   XLOGUE_STUB_COUNT
407 };
408
409 enum xlogue_stub_sets {
410   XLOGUE_SET_ALIGNED,
411   XLOGUE_SET_ALIGNED_PLUS_8,
412   XLOGUE_SET_HFP_ALIGNED_OR_REALIGN,
413   XLOGUE_SET_HFP_ALIGNED_PLUS_8,
414
415   XLOGUE_SET_COUNT
416 };
417
418 /* Register save/restore layout used by out-of-line stubs.  */
419 class xlogue_layout {
420 public:
421   struct reginfo
422   {
423     unsigned regno;
424     HOST_WIDE_INT offset;       /* Offset used by stub base pointer (rax or
425                                    rsi) to where each register is stored.  */
426   };
427
428   unsigned get_nregs () const                   {return m_nregs;}
429   HOST_WIDE_INT get_stack_align_off_in () const {return m_stack_align_off_in;}
430
431   const reginfo &get_reginfo (unsigned reg) const
432   {
433     gcc_assert (reg < m_nregs);
434     return m_regs[reg];
435   }
436
437   static const char *get_stub_name (enum xlogue_stub stub,
438                                     unsigned n_extra_args);
439
440   /* Returns an rtx for the stub's symbol based upon
441        1.) the specified stub (save, restore or restore_ret) and
442        2.) the value of cfun->machine->call_ms2sysv_extra_regs and
443        3.) rather or not stack alignment is being performed.  */
444   static rtx get_stub_rtx (enum xlogue_stub stub);
445
446   /* Returns the amount of stack space (including padding) that the stub
447      needs to store registers based upon data in the machine_function.  */
448   HOST_WIDE_INT get_stack_space_used () const
449   {
450     const struct machine_function *m = cfun->machine;
451     unsigned last_reg = m->call_ms2sysv_extra_regs + MIN_REGS - 1;
452
453     gcc_assert (m->call_ms2sysv_extra_regs <= MAX_EXTRA_REGS);
454     return m_regs[last_reg].offset + STUB_INDEX_OFFSET;
455   }
456
457   /* Returns the offset for the base pointer used by the stub.  */
458   HOST_WIDE_INT get_stub_ptr_offset () const
459   {
460     return STUB_INDEX_OFFSET + m_stack_align_off_in;
461   }
462
463   static const struct xlogue_layout &get_instance ();
464   static unsigned count_stub_managed_regs ();
465   static bool is_stub_managed_reg (unsigned regno, unsigned count);
466
467   static const HOST_WIDE_INT STUB_INDEX_OFFSET = 0x70;
468   static const unsigned MIN_REGS = NUM_X86_64_MS_CLOBBERED_REGS;
469   static const unsigned MAX_REGS = 18;
470   static const unsigned MAX_EXTRA_REGS = MAX_REGS - MIN_REGS;
471   static const unsigned VARIANT_COUNT = MAX_EXTRA_REGS + 1;
472   static const unsigned STUB_NAME_MAX_LEN = 20;
473   static const char * const STUB_BASE_NAMES[XLOGUE_STUB_COUNT];
474   static const unsigned REG_ORDER[MAX_REGS];
475   static const unsigned REG_ORDER_REALIGN[MAX_REGS];
476
477 private:
478   xlogue_layout ();
479   xlogue_layout (HOST_WIDE_INT stack_align_off_in, bool hfp);
480   xlogue_layout (const xlogue_layout &);
481
482   /* True if hard frame pointer is used.  */
483   bool m_hfp;
484
485   /* Max number of register this layout manages.  */
486   unsigned m_nregs;
487
488   /* Incoming offset from 16-byte alignment.  */
489   HOST_WIDE_INT m_stack_align_off_in;
490
491   /* Register order and offsets.  */
492   struct reginfo m_regs[MAX_REGS];
493
494   /* Lazy-inited cache of symbol names for stubs.  */
495   static char s_stub_names[2][XLOGUE_STUB_COUNT][VARIANT_COUNT]
496                           [STUB_NAME_MAX_LEN];
497
498   static const xlogue_layout s_instances[XLOGUE_SET_COUNT];
499 };
500
501 const char * const xlogue_layout::STUB_BASE_NAMES[XLOGUE_STUB_COUNT] = {
502   "savms64",
503   "resms64",
504   "resms64x",
505   "savms64f",
506   "resms64f",
507   "resms64fx"
508 };
509
510 const unsigned xlogue_layout::REG_ORDER[xlogue_layout::MAX_REGS] = {
511 /* The below offset values are where each register is stored for the layout
512    relative to incoming stack pointer.  The value of each m_regs[].offset will
513    be relative to the incoming base pointer (rax or rsi) used by the stub.
514
515     s_instances:   0            1               2               3
516     Offset:                                     realigned or    aligned + 8
517     Register       aligned      aligned + 8     aligned w/HFP   w/HFP   */
518     XMM15_REG,  /* 0x10         0x18            0x10            0x18    */
519     XMM14_REG,  /* 0x20         0x28            0x20            0x28    */
520     XMM13_REG,  /* 0x30         0x38            0x30            0x38    */
521     XMM12_REG,  /* 0x40         0x48            0x40            0x48    */
522     XMM11_REG,  /* 0x50         0x58            0x50            0x58    */
523     XMM10_REG,  /* 0x60         0x68            0x60            0x68    */
524     XMM9_REG,   /* 0x70         0x78            0x70            0x78    */
525     XMM8_REG,   /* 0x80         0x88            0x80            0x88    */
526     XMM7_REG,   /* 0x90         0x98            0x90            0x98    */
527     XMM6_REG,   /* 0xa0         0xa8            0xa0            0xa8    */
528     SI_REG,     /* 0xa8         0xb0            0xa8            0xb0    */
529     DI_REG,     /* 0xb0         0xb8            0xb0            0xb8    */
530     BX_REG,     /* 0xb8         0xc0            0xb8            0xc0    */
531     BP_REG,     /* 0xc0         0xc8            N/A             N/A     */
532     R12_REG,    /* 0xc8         0xd0            0xc0            0xc8    */
533     R13_REG,    /* 0xd0         0xd8            0xc8            0xd0    */
534     R14_REG,    /* 0xd8         0xe0            0xd0            0xd8    */
535     R15_REG,    /* 0xe0         0xe8            0xd8            0xe0    */
536 };
537
538 /* Instantiate static const values.  */
539 const HOST_WIDE_INT xlogue_layout::STUB_INDEX_OFFSET;
540 const unsigned xlogue_layout::MIN_REGS;
541 const unsigned xlogue_layout::MAX_REGS;
542 const unsigned xlogue_layout::MAX_EXTRA_REGS;
543 const unsigned xlogue_layout::VARIANT_COUNT;
544 const unsigned xlogue_layout::STUB_NAME_MAX_LEN;
545
546 /* Initialize xlogue_layout::s_stub_names to zero.  */
547 char xlogue_layout::s_stub_names[2][XLOGUE_STUB_COUNT][VARIANT_COUNT]
548                                 [STUB_NAME_MAX_LEN];
549
550 /* Instantiates all xlogue_layout instances.  */
551 const xlogue_layout xlogue_layout::s_instances[XLOGUE_SET_COUNT] = {
552   xlogue_layout (0, false),
553   xlogue_layout (8, false),
554   xlogue_layout (0, true),
555   xlogue_layout (8, true)
556 };
557
558 /* Return an appropriate const instance of xlogue_layout based upon values
559    in cfun->machine and crtl.  */
560 const struct xlogue_layout &
561 xlogue_layout::get_instance ()
562 {
563   enum xlogue_stub_sets stub_set;
564   bool aligned_plus_8 = cfun->machine->call_ms2sysv_pad_in;
565
566   if (stack_realign_fp)
567     stub_set = XLOGUE_SET_HFP_ALIGNED_OR_REALIGN;
568   else if (frame_pointer_needed)
569     stub_set = aligned_plus_8
570               ? XLOGUE_SET_HFP_ALIGNED_PLUS_8
571               : XLOGUE_SET_HFP_ALIGNED_OR_REALIGN;
572   else
573     stub_set = aligned_plus_8 ? XLOGUE_SET_ALIGNED_PLUS_8 : XLOGUE_SET_ALIGNED;
574
575   return s_instances[stub_set];
576 }
577
578 /* Determine how many clobbered registers can be saved by the stub.
579    Returns the count of registers the stub will save and restore.  */
580 unsigned
581 xlogue_layout::count_stub_managed_regs ()
582 {
583   bool hfp = frame_pointer_needed || stack_realign_fp;
584   unsigned i, count;
585   unsigned regno;
586
587   for (count = i = MIN_REGS; i < MAX_REGS; ++i)
588     {
589       regno = REG_ORDER[i];
590       if (regno == BP_REG && hfp)
591         continue;
592       if (!ix86_save_reg (regno, false, false))
593         break;
594       ++count;
595     }
596   return count;
597 }
598
599 /* Determine if register REGNO is a stub managed register given the
600    total COUNT of stub managed registers.  */
601 bool
602 xlogue_layout::is_stub_managed_reg (unsigned regno, unsigned count)
603 {
604   bool hfp = frame_pointer_needed || stack_realign_fp;
605   unsigned i;
606
607   for (i = 0; i < count; ++i)
608     {
609       gcc_assert (i < MAX_REGS);
610       if (REG_ORDER[i] == BP_REG && hfp)
611         ++count;
612       else if (REG_ORDER[i] == regno)
613         return true;
614     }
615   return false;
616 }
617
618 /* Constructor for xlogue_layout.  */
619 xlogue_layout::xlogue_layout (HOST_WIDE_INT stack_align_off_in, bool hfp)
620   : m_hfp (hfp) , m_nregs (hfp ? 17 : 18),
621     m_stack_align_off_in (stack_align_off_in)
622 {
623   HOST_WIDE_INT offset = stack_align_off_in;
624   unsigned i, j;
625
626   for (i = j = 0; i < MAX_REGS; ++i)
627     {
628       unsigned regno = REG_ORDER[i];
629
630       if (regno == BP_REG && hfp)
631         continue;
632       if (SSE_REGNO_P (regno))
633         {
634           offset += 16;
635           /* Verify that SSE regs are always aligned.  */
636           gcc_assert (!((stack_align_off_in + offset) & 15));
637         }
638       else
639         offset += 8;
640
641       m_regs[j].regno    = regno;
642       m_regs[j++].offset = offset - STUB_INDEX_OFFSET;
643     }
644   gcc_assert (j == m_nregs);
645 }
646
647 const char *
648 xlogue_layout::get_stub_name (enum xlogue_stub stub,
649                               unsigned n_extra_regs)
650 {
651   const int have_avx = TARGET_AVX;
652   char *name = s_stub_names[!!have_avx][stub][n_extra_regs];
653
654   /* Lazy init */
655   if (!*name)
656     {
657       int res = snprintf (name, STUB_NAME_MAX_LEN, "__%s_%s_%u",
658                           (have_avx ? "avx" : "sse"),
659                           STUB_BASE_NAMES[stub],
660                           MIN_REGS + n_extra_regs);
661       gcc_checking_assert (res < (int)STUB_NAME_MAX_LEN);
662     }
663
664   return name;
665 }
666
667 /* Return rtx of a symbol ref for the entry point (based upon
668    cfun->machine->call_ms2sysv_extra_regs) of the specified stub.  */
669 rtx
670 xlogue_layout::get_stub_rtx (enum xlogue_stub stub)
671 {
672   const unsigned n_extra_regs = cfun->machine->call_ms2sysv_extra_regs;
673   gcc_checking_assert (n_extra_regs <= MAX_EXTRA_REGS);
674   gcc_assert (stub < XLOGUE_STUB_COUNT);
675   gcc_assert (crtl->stack_realign_finalized);
676
677   return gen_rtx_SYMBOL_REF (Pmode, get_stub_name (stub, n_extra_regs));
678 }
679
680 /* Define the structure for the machine field in struct function.  */
681
682 struct GTY(()) stack_local_entry {
683   unsigned short mode;
684   unsigned short n;
685   rtx rtl;
686   struct stack_local_entry *next;
687 };
688
689 /* Which cpu are we scheduling for.  */
690 enum attr_cpu ix86_schedule;
691
692 /* Which cpu are we optimizing for.  */
693 enum processor_type ix86_tune;
694
695 /* Which instruction set architecture to use.  */
696 enum processor_type ix86_arch;
697
698 /* True if processor has SSE prefetch instruction.  */
699 unsigned char x86_prefetch_sse;
700
701 /* -mstackrealign option */
702 static const char ix86_force_align_arg_pointer_string[]
703   = "force_align_arg_pointer";
704
705 static rtx (*ix86_gen_leave) (void);
706 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
707 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
708 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
709 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
710 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
711 static rtx (*ix86_gen_monitorx) (rtx, rtx, rtx);
712 static rtx (*ix86_gen_clzero) (rtx);
713 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
714 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
715 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
716 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
717 static rtx (*ix86_gen_tls_global_dynamic_64) (rtx, rtx, rtx);
718 static rtx (*ix86_gen_tls_local_dynamic_base_64) (rtx, rtx);
719
720 /* Preferred alignment for stack boundary in bits.  */
721 unsigned int ix86_preferred_stack_boundary;
722
723 /* Alignment for incoming stack boundary in bits specified at
724    command line.  */
725 static unsigned int ix86_user_incoming_stack_boundary;
726
727 /* Default alignment for incoming stack boundary in bits.  */
728 static unsigned int ix86_default_incoming_stack_boundary;
729
730 /* Alignment for incoming stack boundary in bits.  */
731 unsigned int ix86_incoming_stack_boundary;
732
733 /* Calling abi specific va_list type nodes.  */
734 static GTY(()) tree sysv_va_list_type_node;
735 static GTY(()) tree ms_va_list_type_node;
736
737 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
738 char internal_label_prefix[16];
739 int internal_label_prefix_len;
740
741 /* Fence to use after loop using movnt.  */
742 tree x86_mfence;
743
744 /* Register class used for passing given 64bit part of the argument.
745    These represent classes as documented by the PS ABI, with the exception
746    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
747    use SF or DFmode move instead of DImode to avoid reformatting penalties.
748
749    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
750    whenever possible (upper half does contain padding).  */
751 enum x86_64_reg_class
752   {
753     X86_64_NO_CLASS,
754     X86_64_INTEGER_CLASS,
755     X86_64_INTEGERSI_CLASS,
756     X86_64_SSE_CLASS,
757     X86_64_SSESF_CLASS,
758     X86_64_SSEDF_CLASS,
759     X86_64_SSEUP_CLASS,
760     X86_64_X87_CLASS,
761     X86_64_X87UP_CLASS,
762     X86_64_COMPLEX_X87_CLASS,
763     X86_64_MEMORY_CLASS
764   };
765
766 #define MAX_CLASSES 8
767
768 /* Table of constants used by fldpi, fldln2, etc....  */
769 static REAL_VALUE_TYPE ext_80387_constants_table [5];
770 static bool ext_80387_constants_init;
771
772 \f
773 static struct machine_function * ix86_init_machine_status (void);
774 static rtx ix86_function_value (const_tree, const_tree, bool);
775 static bool ix86_function_value_regno_p (const unsigned int);
776 static unsigned int ix86_function_arg_boundary (machine_mode,
777                                                 const_tree);
778 static rtx ix86_static_chain (const_tree, bool);
779 static int ix86_function_regparm (const_tree, const_tree);
780 static void ix86_compute_frame_layout (void);
781 static bool ix86_expand_vector_init_one_nonzero (bool, machine_mode,
782                                                  rtx, rtx, int);
783 static void ix86_add_new_builtins (HOST_WIDE_INT, HOST_WIDE_INT);
784 static tree ix86_canonical_va_list_type (tree);
785 static void predict_jump (int);
786 static unsigned int split_stack_prologue_scratch_regno (void);
787 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
788
789 enum ix86_function_specific_strings
790 {
791   IX86_FUNCTION_SPECIFIC_ARCH,
792   IX86_FUNCTION_SPECIFIC_TUNE,
793   IX86_FUNCTION_SPECIFIC_MAX
794 };
795
796 static char *ix86_target_string (HOST_WIDE_INT, HOST_WIDE_INT, int, int,
797                                  const char *, const char *, enum fpmath_unit,
798                                  bool);
799 static void ix86_function_specific_save (struct cl_target_option *,
800                                          struct gcc_options *opts);
801 static void ix86_function_specific_restore (struct gcc_options *opts,
802                                             struct cl_target_option *);
803 static void ix86_function_specific_post_stream_in (struct cl_target_option *);
804 static void ix86_function_specific_print (FILE *, int,
805                                           struct cl_target_option *);
806 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
807 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
808                                                  struct gcc_options *,
809                                                  struct gcc_options *,
810                                                  struct gcc_options *);
811 static bool ix86_can_inline_p (tree, tree);
812 static void ix86_set_current_function (tree);
813 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
814
815 static enum calling_abi ix86_function_abi (const_tree);
816
817 \f
818 #ifndef SUBTARGET32_DEFAULT_CPU
819 #define SUBTARGET32_DEFAULT_CPU "i386"
820 #endif
821
822 /* Whether -mtune= or -march= were specified */
823 static int ix86_tune_defaulted;
824 static int ix86_arch_specified;
825
826 /* Vectorization library interface and handlers.  */
827 static tree (*ix86_veclib_handler) (combined_fn, tree, tree);
828
829 static tree ix86_veclibabi_svml (combined_fn, tree, tree);
830 static tree ix86_veclibabi_acml (combined_fn, tree, tree);
831
832 /* Processor target table, indexed by processor number */
833 struct ptt
834 {
835   const char *const name;                       /* processor name  */
836   const struct processor_costs *cost;           /* Processor costs */
837   const int align_loop;                         /* Default alignments.  */
838   const int align_loop_max_skip;
839   const int align_jump;
840   const int align_jump_max_skip;
841   const int align_func;
842 };
843
844 /* This table must be in sync with enum processor_type in i386.h.  */ 
845 static const struct ptt processor_target_table[PROCESSOR_max] =
846 {
847   {"generic", &generic_cost, 16, 10, 16, 10, 16},
848   {"i386", &i386_cost, 4, 3, 4, 3, 4},
849   {"i486", &i486_cost, 16, 15, 16, 15, 16},
850   {"pentium", &pentium_cost, 16, 7, 16, 7, 16},
851   {"lakemont", &lakemont_cost, 16, 7, 16, 7, 16},
852   {"pentiumpro", &pentiumpro_cost, 16, 15, 16, 10, 16},
853   {"pentium4", &pentium4_cost, 0, 0, 0, 0, 0},
854   {"nocona", &nocona_cost, 0, 0, 0, 0, 0},
855   {"core2", &core_cost, 16, 10, 16, 10, 16},
856   {"nehalem", &core_cost, 16, 10, 16, 10, 16},
857   {"sandybridge", &core_cost, 16, 10, 16, 10, 16},
858   {"haswell", &core_cost, 16, 10, 16, 10, 16},
859   {"bonnell", &atom_cost, 16, 15, 16, 7, 16},
860   {"silvermont", &slm_cost, 16, 15, 16, 7, 16},
861   {"knl", &slm_cost, 16, 15, 16, 7, 16},
862   {"knm", &slm_cost, 16, 15, 16, 7, 16},
863   {"skylake", &skylake_cost, 16, 10, 16, 10, 16},
864   {"skylake-avx512", &skylake_cost, 16, 10, 16, 10, 16},
865   {"cannonlake", &skylake_cost, 16, 10, 16, 10, 16},
866   {"icelake-client", &skylake_cost, 16, 10, 16, 10, 16},
867   {"icelake-server", &skylake_cost, 16, 10, 16, 10, 16},
868   {"intel", &intel_cost, 16, 15, 16, 7, 16},
869   {"geode", &geode_cost, 0, 0, 0, 0, 0},
870   {"k6", &k6_cost, 32, 7, 32, 7, 32},
871   {"athlon", &athlon_cost, 16, 7, 16, 7, 16},
872   {"k8", &k8_cost, 16, 7, 16, 7, 16},
873   {"amdfam10", &amdfam10_cost, 32, 24, 32, 7, 32},
874   {"bdver1", &bdver1_cost, 16, 10, 16, 7, 11},
875   {"bdver2", &bdver2_cost, 16, 10, 16, 7, 11},
876   {"bdver3", &bdver3_cost, 16, 10, 16, 7, 11},
877   {"bdver4", &bdver4_cost, 16, 10, 16, 7, 11},
878   {"btver1", &btver1_cost, 16, 10, 16, 7, 11},
879   {"btver2", &btver2_cost, 16, 10, 16, 7, 11},
880   {"znver1", &znver1_cost, 16, 15, 16, 15, 16}
881 };
882 \f
883 static unsigned int
884 rest_of_handle_insert_vzeroupper (void)
885 {
886   int i;
887
888   /* vzeroupper instructions are inserted immediately after reload to
889      account for possible spills from 256bit or 512bit registers.  The pass
890      reuses mode switching infrastructure by re-running mode insertion
891      pass, so disable entities that have already been processed.  */
892   for (i = 0; i < MAX_386_ENTITIES; i++)
893     ix86_optimize_mode_switching[i] = 0;
894
895   ix86_optimize_mode_switching[AVX_U128] = 1;
896
897   /* Call optimize_mode_switching.  */
898   g->get_passes ()->execute_pass_mode_switching ();
899   return 0;
900 }
901
902 /* Return 1 if INSN uses or defines a hard register.
903    Hard register uses in a memory address are ignored.
904    Clobbers and flags definitions are ignored.  */
905
906 static bool
907 has_non_address_hard_reg (rtx_insn *insn)
908 {
909   df_ref ref;
910   FOR_EACH_INSN_DEF (ref, insn)
911     if (HARD_REGISTER_P (DF_REF_REAL_REG (ref))
912         && !DF_REF_FLAGS_IS_SET (ref, DF_REF_MUST_CLOBBER)
913         && DF_REF_REGNO (ref) != FLAGS_REG)
914       return true;
915
916   FOR_EACH_INSN_USE (ref, insn)
917     if (!DF_REF_REG_MEM_P (ref) && HARD_REGISTER_P (DF_REF_REAL_REG (ref)))
918       return true;
919
920   return false;
921 }
922
923 /* Check if comparison INSN may be transformed
924    into vector comparison.  Currently we transform
925    zero checks only which look like:
926
927    (set (reg:CCZ 17 flags)
928         (compare:CCZ (ior:SI (subreg:SI (reg:DI x) 4)
929                              (subreg:SI (reg:DI x) 0))
930                      (const_int 0 [0])))  */
931
932 static bool
933 convertible_comparison_p (rtx_insn *insn)
934 {
935   if (!TARGET_SSE4_1)
936     return false;
937
938   rtx def_set = single_set (insn);
939
940   gcc_assert (def_set);
941
942   rtx src = SET_SRC (def_set);
943   rtx dst = SET_DEST (def_set);
944
945   gcc_assert (GET_CODE (src) == COMPARE);
946
947   if (GET_CODE (dst) != REG
948       || REGNO (dst) != FLAGS_REG
949       || GET_MODE (dst) != CCZmode)
950     return false;
951
952   rtx op1 = XEXP (src, 0);
953   rtx op2 = XEXP (src, 1);
954
955   if (op2 != CONST0_RTX (GET_MODE (op2)))
956     return false;
957
958   if (GET_CODE (op1) != IOR)
959     return false;
960
961   op2 = XEXP (op1, 1);
962   op1 = XEXP (op1, 0);
963
964   if (!SUBREG_P (op1)
965       || !SUBREG_P (op2)
966       || GET_MODE (op1) != SImode
967       || GET_MODE (op2) != SImode
968       || ((SUBREG_BYTE (op1) != 0
969            || SUBREG_BYTE (op2) != GET_MODE_SIZE (SImode))
970           && (SUBREG_BYTE (op2) != 0
971               || SUBREG_BYTE (op1) != GET_MODE_SIZE (SImode))))
972     return false;
973
974   op1 = SUBREG_REG (op1);
975   op2 = SUBREG_REG (op2);
976
977   if (op1 != op2
978       || !REG_P (op1)
979       || GET_MODE (op1) != DImode)
980     return false;
981
982   return true;
983 }
984
985 /* The DImode version of scalar_to_vector_candidate_p.  */
986
987 static bool
988 dimode_scalar_to_vector_candidate_p (rtx_insn *insn)
989 {
990   rtx def_set = single_set (insn);
991
992   if (!def_set)
993     return false;
994
995   if (has_non_address_hard_reg (insn))
996     return false;
997
998   rtx src = SET_SRC (def_set);
999   rtx dst = SET_DEST (def_set);
1000
1001   if (GET_CODE (src) == COMPARE)
1002     return convertible_comparison_p (insn);
1003
1004   /* We are interested in DImode promotion only.  */
1005   if ((GET_MODE (src) != DImode
1006        && !CONST_INT_P (src))
1007       || GET_MODE (dst) != DImode)
1008     return false;
1009
1010   if (!REG_P (dst) && !MEM_P (dst))
1011     return false;
1012
1013   switch (GET_CODE (src))
1014     {
1015     case ASHIFTRT:
1016       if (!TARGET_AVX512VL)
1017         return false;
1018       /* FALLTHRU */
1019
1020     case ASHIFT:
1021     case LSHIFTRT:
1022       if (!REG_P (XEXP (src, 1))
1023           && (!SUBREG_P (XEXP (src, 1))
1024               || SUBREG_BYTE (XEXP (src, 1)) != 0
1025               || !REG_P (SUBREG_REG (XEXP (src, 1))))
1026           && (!CONST_INT_P (XEXP (src, 1))
1027               || !IN_RANGE (INTVAL (XEXP (src, 1)), 0, 63)))
1028         return false;
1029
1030       if (GET_MODE (XEXP (src, 1)) != QImode
1031           && !CONST_INT_P (XEXP (src, 1)))
1032         return false;
1033       break;
1034
1035     case PLUS:
1036     case MINUS:
1037     case IOR:
1038     case XOR:
1039     case AND:
1040       if (!REG_P (XEXP (src, 1))
1041           && !MEM_P (XEXP (src, 1))
1042           && !CONST_INT_P (XEXP (src, 1)))
1043         return false;
1044
1045       if (GET_MODE (XEXP (src, 1)) != DImode
1046           && !CONST_INT_P (XEXP (src, 1)))
1047         return false;
1048       break;
1049
1050     case NEG:
1051     case NOT:
1052       break;
1053
1054     case REG:
1055       return true;
1056
1057     case MEM:
1058     case CONST_INT:
1059       return REG_P (dst);
1060
1061     default:
1062       return false;
1063     }
1064
1065   if (!REG_P (XEXP (src, 0))
1066       && !MEM_P (XEXP (src, 0))
1067       && !CONST_INT_P (XEXP (src, 0))
1068       /* Check for andnot case.  */
1069       && (GET_CODE (src) != AND
1070           || GET_CODE (XEXP (src, 0)) != NOT
1071           || !REG_P (XEXP (XEXP (src, 0), 0))))
1072       return false;
1073
1074   if (GET_MODE (XEXP (src, 0)) != DImode
1075       && !CONST_INT_P (XEXP (src, 0)))
1076     return false;
1077
1078   return true;
1079 }
1080
1081 /* The TImode version of scalar_to_vector_candidate_p.  */
1082
1083 static bool
1084 timode_scalar_to_vector_candidate_p (rtx_insn *insn)
1085 {
1086   rtx def_set = single_set (insn);
1087
1088   if (!def_set)
1089     return false;
1090
1091   if (has_non_address_hard_reg (insn))
1092     return false;
1093
1094   rtx src = SET_SRC (def_set);
1095   rtx dst = SET_DEST (def_set);
1096
1097   /* Only TImode load and store are allowed.  */
1098   if (GET_MODE (dst) != TImode)
1099     return false;
1100
1101   if (MEM_P (dst))
1102     {
1103       /* Check for store.  Memory must be aligned or unaligned store
1104          is optimal.  Only support store from register, standard SSE
1105          constant or CONST_WIDE_INT generated from piecewise store.
1106
1107          ??? Verify performance impact before enabling CONST_INT for
1108          __int128 store.  */
1109       if (misaligned_operand (dst, TImode)
1110           && !TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
1111         return false;
1112
1113       switch (GET_CODE (src))
1114         {
1115         default:
1116           return false;
1117
1118         case REG:
1119         case CONST_WIDE_INT:
1120           return true;
1121
1122         case CONST_INT:
1123           return standard_sse_constant_p (src, TImode);
1124         }
1125     }
1126   else if (MEM_P (src))
1127     {
1128       /* Check for load.  Memory must be aligned or unaligned load is
1129          optimal.  */
1130       return (REG_P (dst)
1131               && (!misaligned_operand (src, TImode)
1132                   || TARGET_SSE_UNALIGNED_LOAD_OPTIMAL));
1133     }
1134
1135   return false;
1136 }
1137
1138 /* Return 1 if INSN may be converted into vector
1139    instruction.  */
1140
1141 static bool
1142 scalar_to_vector_candidate_p (rtx_insn *insn)
1143 {
1144   if (TARGET_64BIT)
1145     return timode_scalar_to_vector_candidate_p (insn);
1146   else
1147     return dimode_scalar_to_vector_candidate_p (insn);
1148 }
1149
1150 /* The DImode version of remove_non_convertible_regs.  */
1151
1152 static void
1153 dimode_remove_non_convertible_regs (bitmap candidates)
1154 {
1155   bitmap_iterator bi;
1156   unsigned id;
1157   bitmap regs = BITMAP_ALLOC (NULL);
1158
1159   EXECUTE_IF_SET_IN_BITMAP (candidates, 0, id, bi)
1160     {
1161       rtx def_set = single_set (DF_INSN_UID_GET (id)->insn);
1162       rtx reg = SET_DEST (def_set);
1163
1164       if (!REG_P (reg)
1165           || bitmap_bit_p (regs, REGNO (reg))
1166           || HARD_REGISTER_P (reg))
1167         continue;
1168
1169       for (df_ref def = DF_REG_DEF_CHAIN (REGNO (reg));
1170            def;
1171            def = DF_REF_NEXT_REG (def))
1172         {
1173           if (!bitmap_bit_p (candidates, DF_REF_INSN_UID (def)))
1174             {
1175               if (dump_file)
1176                 fprintf (dump_file,
1177                          "r%d has non convertible definition in insn %d\n",
1178                          REGNO (reg), DF_REF_INSN_UID (def));
1179
1180               bitmap_set_bit (regs, REGNO (reg));
1181               break;
1182             }
1183         }
1184     }
1185
1186   EXECUTE_IF_SET_IN_BITMAP (regs, 0, id, bi)
1187     {
1188       for (df_ref def = DF_REG_DEF_CHAIN (id);
1189            def;
1190            def = DF_REF_NEXT_REG (def))
1191         if (bitmap_bit_p (candidates, DF_REF_INSN_UID (def)))
1192           {
1193             if (dump_file)
1194               fprintf (dump_file, "Removing insn %d from candidates list\n",
1195                        DF_REF_INSN_UID (def));
1196
1197             bitmap_clear_bit (candidates, DF_REF_INSN_UID (def));
1198           }
1199     }
1200
1201   BITMAP_FREE (regs);
1202 }
1203
1204 /* For a register REGNO, scan instructions for its defs and uses.
1205    Put REGNO in REGS if a def or use isn't in CANDIDATES.  */
1206
1207 static void
1208 timode_check_non_convertible_regs (bitmap candidates, bitmap regs,
1209                                    unsigned int regno)
1210 {
1211   for (df_ref def = DF_REG_DEF_CHAIN (regno);
1212        def;
1213        def = DF_REF_NEXT_REG (def))
1214     {
1215       if (!bitmap_bit_p (candidates, DF_REF_INSN_UID (def)))
1216         {
1217           if (dump_file)
1218             fprintf (dump_file,
1219                      "r%d has non convertible def in insn %d\n",
1220                      regno, DF_REF_INSN_UID (def));
1221
1222           bitmap_set_bit (regs, regno);
1223           break;
1224         }
1225     }
1226
1227   for (df_ref ref = DF_REG_USE_CHAIN (regno);
1228        ref;
1229        ref = DF_REF_NEXT_REG (ref))
1230     {
1231       /* Debug instructions are skipped.  */
1232       if (NONDEBUG_INSN_P (DF_REF_INSN (ref))
1233           && !bitmap_bit_p (candidates, DF_REF_INSN_UID (ref)))
1234         {
1235           if (dump_file)
1236             fprintf (dump_file,
1237                      "r%d has non convertible use in insn %d\n",
1238                      regno, DF_REF_INSN_UID (ref));
1239
1240           bitmap_set_bit (regs, regno);
1241           break;
1242         }
1243     }
1244 }
1245
1246 /* The TImode version of remove_non_convertible_regs.  */
1247
1248 static void
1249 timode_remove_non_convertible_regs (bitmap candidates)
1250 {
1251   bitmap_iterator bi;
1252   unsigned id;
1253   bitmap regs = BITMAP_ALLOC (NULL);
1254
1255   EXECUTE_IF_SET_IN_BITMAP (candidates, 0, id, bi)
1256     {
1257       rtx def_set = single_set (DF_INSN_UID_GET (id)->insn);
1258       rtx dest = SET_DEST (def_set);
1259       rtx src = SET_SRC (def_set);
1260
1261       if ((!REG_P (dest)
1262            || bitmap_bit_p (regs, REGNO (dest))
1263            || HARD_REGISTER_P (dest))
1264           && (!REG_P (src)
1265               || bitmap_bit_p (regs, REGNO (src))
1266               || HARD_REGISTER_P (src)))
1267         continue;
1268
1269       if (REG_P (dest))
1270         timode_check_non_convertible_regs (candidates, regs,
1271                                            REGNO (dest));
1272
1273       if (REG_P (src))
1274         timode_check_non_convertible_regs (candidates, regs,
1275                                            REGNO (src));
1276     }
1277
1278   EXECUTE_IF_SET_IN_BITMAP (regs, 0, id, bi)
1279     {
1280       for (df_ref def = DF_REG_DEF_CHAIN (id);
1281            def;
1282            def = DF_REF_NEXT_REG (def))
1283         if (bitmap_bit_p (candidates, DF_REF_INSN_UID (def)))
1284           {
1285             if (dump_file)
1286               fprintf (dump_file, "Removing insn %d from candidates list\n",
1287                        DF_REF_INSN_UID (def));
1288
1289             bitmap_clear_bit (candidates, DF_REF_INSN_UID (def));
1290           }
1291
1292       for (df_ref ref = DF_REG_USE_CHAIN (id);
1293            ref;
1294            ref = DF_REF_NEXT_REG (ref))
1295         if (bitmap_bit_p (candidates, DF_REF_INSN_UID (ref)))
1296           {
1297             if (dump_file)
1298               fprintf (dump_file, "Removing insn %d from candidates list\n",
1299                        DF_REF_INSN_UID (ref));
1300
1301             bitmap_clear_bit (candidates, DF_REF_INSN_UID (ref));
1302           }
1303     }
1304
1305   BITMAP_FREE (regs);
1306 }
1307
1308 /* For a given bitmap of insn UIDs scans all instruction and
1309    remove insn from CANDIDATES in case it has both convertible
1310    and not convertible definitions.
1311
1312    All insns in a bitmap are conversion candidates according to
1313    scalar_to_vector_candidate_p.  Currently it implies all insns
1314    are single_set.  */
1315
1316 static void
1317 remove_non_convertible_regs (bitmap candidates)
1318 {
1319   if (TARGET_64BIT)
1320     timode_remove_non_convertible_regs (candidates);
1321   else
1322     dimode_remove_non_convertible_regs (candidates);
1323 }
1324
1325 class scalar_chain
1326 {
1327  public:
1328   scalar_chain ();
1329   virtual ~scalar_chain ();
1330
1331   static unsigned max_id;
1332
1333   /* ID of a chain.  */
1334   unsigned int chain_id;
1335   /* A queue of instructions to be included into a chain.  */
1336   bitmap queue;
1337   /* Instructions included into a chain.  */
1338   bitmap insns;
1339   /* All registers defined by a chain.  */
1340   bitmap defs;
1341   /* Registers used in both vector and sclar modes.  */
1342   bitmap defs_conv;
1343
1344   void build (bitmap candidates, unsigned insn_uid);
1345   virtual int compute_convert_gain () = 0;
1346   int convert ();
1347
1348  protected:
1349   void add_to_queue (unsigned insn_uid);
1350   void emit_conversion_insns (rtx insns, rtx_insn *pos);
1351
1352  private:
1353   void add_insn (bitmap candidates, unsigned insn_uid);
1354   void analyze_register_chain (bitmap candidates, df_ref ref);
1355   virtual void mark_dual_mode_def (df_ref def) = 0;
1356   virtual void convert_insn (rtx_insn *insn) = 0;
1357   virtual void convert_registers () = 0;
1358 };
1359
1360 class dimode_scalar_chain : public scalar_chain
1361 {
1362  public:
1363   int compute_convert_gain ();
1364  private:
1365   void mark_dual_mode_def (df_ref def);
1366   rtx replace_with_subreg (rtx x, rtx reg, rtx subreg);
1367   void replace_with_subreg_in_insn (rtx_insn *insn, rtx reg, rtx subreg);
1368   void convert_insn (rtx_insn *insn);
1369   void convert_op (rtx *op, rtx_insn *insn);
1370   void convert_reg (unsigned regno);
1371   void make_vector_copies (unsigned regno);
1372   void convert_registers ();
1373   int vector_const_cost (rtx exp);
1374 };
1375
1376 class timode_scalar_chain : public scalar_chain
1377 {
1378  public:
1379   /* Convert from TImode to V1TImode is always faster.  */
1380   int compute_convert_gain () { return 1; }
1381
1382  private:
1383   void mark_dual_mode_def (df_ref def);
1384   void fix_debug_reg_uses (rtx reg);
1385   void convert_insn (rtx_insn *insn);
1386   /* We don't convert registers to difference size.  */
1387   void convert_registers () {}
1388 };
1389
1390 unsigned scalar_chain::max_id = 0;
1391
1392 /* Initialize new chain.  */
1393
1394 scalar_chain::scalar_chain ()
1395 {
1396   chain_id = ++max_id;
1397
1398    if (dump_file)
1399     fprintf (dump_file, "Created a new instruction chain #%d\n", chain_id);
1400
1401   bitmap_obstack_initialize (NULL);
1402   insns = BITMAP_ALLOC (NULL);
1403   defs = BITMAP_ALLOC (NULL);
1404   defs_conv = BITMAP_ALLOC (NULL);
1405   queue = NULL;
1406 }
1407
1408 /* Free chain's data.  */
1409
1410 scalar_chain::~scalar_chain ()
1411 {
1412   BITMAP_FREE (insns);
1413   BITMAP_FREE (defs);
1414   BITMAP_FREE (defs_conv);
1415   bitmap_obstack_release (NULL);
1416 }
1417
1418 /* Add instruction into chains' queue.  */
1419
1420 void
1421 scalar_chain::add_to_queue (unsigned insn_uid)
1422 {
1423   if (bitmap_bit_p (insns, insn_uid)
1424       || bitmap_bit_p (queue, insn_uid))
1425     return;
1426
1427   if (dump_file)
1428     fprintf (dump_file, "  Adding insn %d into chain's #%d queue\n",
1429              insn_uid, chain_id);
1430   bitmap_set_bit (queue, insn_uid);
1431 }
1432
1433 /* For DImode conversion, mark register defined by DEF as requiring
1434    conversion.  */
1435
1436 void
1437 dimode_scalar_chain::mark_dual_mode_def (df_ref def)
1438 {
1439   gcc_assert (DF_REF_REG_DEF_P (def));
1440
1441   if (bitmap_bit_p (defs_conv, DF_REF_REGNO (def)))
1442     return;
1443
1444   if (dump_file)
1445     fprintf (dump_file,
1446              "  Mark r%d def in insn %d as requiring both modes in chain #%d\n",
1447              DF_REF_REGNO (def), DF_REF_INSN_UID (def), chain_id);
1448
1449   bitmap_set_bit (defs_conv, DF_REF_REGNO (def));
1450 }
1451
1452 /* For TImode conversion, it is unused.  */
1453
1454 void
1455 timode_scalar_chain::mark_dual_mode_def (df_ref)
1456 {
1457   gcc_unreachable ();
1458 }
1459
1460 /* Check REF's chain to add new insns into a queue
1461    and find registers requiring conversion.  */
1462
1463 void
1464 scalar_chain::analyze_register_chain (bitmap candidates, df_ref ref)
1465 {
1466   df_link *chain;
1467
1468   gcc_assert (bitmap_bit_p (insns, DF_REF_INSN_UID (ref))
1469               || bitmap_bit_p (candidates, DF_REF_INSN_UID (ref)));
1470   add_to_queue (DF_REF_INSN_UID (ref));
1471
1472   for (chain = DF_REF_CHAIN (ref); chain; chain = chain->next)
1473     {
1474       unsigned uid = DF_REF_INSN_UID (chain->ref);
1475
1476       if (!NONDEBUG_INSN_P (DF_REF_INSN (chain->ref)))
1477         continue;
1478
1479       if (!DF_REF_REG_MEM_P (chain->ref))
1480         {
1481           if (bitmap_bit_p (insns, uid))
1482             continue;
1483
1484           if (bitmap_bit_p (candidates, uid))
1485             {
1486               add_to_queue (uid);
1487               continue;
1488             }
1489         }
1490
1491       if (DF_REF_REG_DEF_P (chain->ref))
1492         {
1493           if (dump_file)
1494             fprintf (dump_file, "  r%d def in insn %d isn't convertible\n",
1495                      DF_REF_REGNO (chain->ref), uid);
1496           mark_dual_mode_def (chain->ref);
1497         }
1498       else
1499         {
1500           if (dump_file)
1501             fprintf (dump_file, "  r%d use in insn %d isn't convertible\n",
1502                      DF_REF_REGNO (chain->ref), uid);
1503           mark_dual_mode_def (ref);
1504         }
1505     }
1506 }
1507
1508 /* Add instruction into a chain.  */
1509
1510 void
1511 scalar_chain::add_insn (bitmap candidates, unsigned int insn_uid)
1512 {
1513   if (bitmap_bit_p (insns, insn_uid))
1514     return;
1515
1516   if (dump_file)
1517     fprintf (dump_file, "  Adding insn %d to chain #%d\n", insn_uid, chain_id);
1518
1519   bitmap_set_bit (insns, insn_uid);
1520
1521   rtx_insn *insn = DF_INSN_UID_GET (insn_uid)->insn;
1522   rtx def_set = single_set (insn);
1523   if (def_set && REG_P (SET_DEST (def_set))
1524       && !HARD_REGISTER_P (SET_DEST (def_set)))
1525     bitmap_set_bit (defs, REGNO (SET_DEST (def_set)));
1526
1527   df_ref ref;
1528   df_ref def;
1529   for (ref = DF_INSN_UID_DEFS (insn_uid); ref; ref = DF_REF_NEXT_LOC (ref))
1530     if (!HARD_REGISTER_P (DF_REF_REG (ref)))
1531       for (def = DF_REG_DEF_CHAIN (DF_REF_REGNO (ref));
1532            def;
1533            def = DF_REF_NEXT_REG (def))
1534         analyze_register_chain (candidates, def);
1535   for (ref = DF_INSN_UID_USES (insn_uid); ref; ref = DF_REF_NEXT_LOC (ref))
1536     if (!DF_REF_REG_MEM_P (ref))
1537       analyze_register_chain (candidates, ref);
1538 }
1539
1540 /* Build new chain starting from insn INSN_UID recursively
1541    adding all dependent uses and definitions.  */
1542
1543 void
1544 scalar_chain::build (bitmap candidates, unsigned insn_uid)
1545 {
1546   queue = BITMAP_ALLOC (NULL);
1547   bitmap_set_bit (queue, insn_uid);
1548
1549   if (dump_file)
1550     fprintf (dump_file, "Building chain #%d...\n", chain_id);
1551
1552   while (!bitmap_empty_p (queue))
1553     {
1554       insn_uid = bitmap_first_set_bit (queue);
1555       bitmap_clear_bit (queue, insn_uid);
1556       bitmap_clear_bit (candidates, insn_uid);
1557       add_insn (candidates, insn_uid);
1558     }
1559
1560   if (dump_file)
1561     {
1562       fprintf (dump_file, "Collected chain #%d...\n", chain_id);
1563       fprintf (dump_file, "  insns: ");
1564       dump_bitmap (dump_file, insns);
1565       if (!bitmap_empty_p (defs_conv))
1566         {
1567           bitmap_iterator bi;
1568           unsigned id;
1569           const char *comma = "";
1570           fprintf (dump_file, "  defs to convert: ");
1571           EXECUTE_IF_SET_IN_BITMAP (defs_conv, 0, id, bi)
1572             {
1573               fprintf (dump_file, "%sr%d", comma, id);
1574               comma = ", ";
1575             }
1576           fprintf (dump_file, "\n");
1577         }
1578     }
1579
1580   BITMAP_FREE (queue);
1581 }
1582
1583 /* Return a cost of building a vector costant
1584    instead of using a scalar one.  */
1585
1586 int
1587 dimode_scalar_chain::vector_const_cost (rtx exp)
1588 {
1589   gcc_assert (CONST_INT_P (exp));
1590
1591   if (standard_sse_constant_p (exp, V2DImode))
1592     return COSTS_N_INSNS (1);
1593   return ix86_cost->sse_load[1];
1594 }
1595
1596 /* Compute a gain for chain conversion.  */
1597
1598 int
1599 dimode_scalar_chain::compute_convert_gain ()
1600 {
1601   bitmap_iterator bi;
1602   unsigned insn_uid;
1603   int gain = 0;
1604   int cost = 0;
1605
1606   if (dump_file)
1607     fprintf (dump_file, "Computing gain for chain #%d...\n", chain_id);
1608
1609   EXECUTE_IF_SET_IN_BITMAP (insns, 0, insn_uid, bi)
1610     {
1611       rtx_insn *insn = DF_INSN_UID_GET (insn_uid)->insn;
1612       rtx def_set = single_set (insn);
1613       rtx src = SET_SRC (def_set);
1614       rtx dst = SET_DEST (def_set);
1615
1616       if (REG_P (src) && REG_P (dst))
1617         gain += COSTS_N_INSNS (2) - ix86_cost->xmm_move;
1618       else if (REG_P (src) && MEM_P (dst))
1619         gain += 2 * ix86_cost->int_store[2] - ix86_cost->sse_store[1];
1620       else if (MEM_P (src) && REG_P (dst))
1621         gain += 2 * ix86_cost->int_load[2] - ix86_cost->sse_load[1];
1622       else if (GET_CODE (src) == ASHIFT
1623                || GET_CODE (src) == ASHIFTRT
1624                || GET_CODE (src) == LSHIFTRT)
1625         {
1626           if (CONST_INT_P (XEXP (src, 0)))
1627             gain -= vector_const_cost (XEXP (src, 0));
1628           if (CONST_INT_P (XEXP (src, 1)))
1629             {
1630               gain += ix86_cost->shift_const;
1631               if (INTVAL (XEXP (src, 1)) >= 32)
1632                 gain -= COSTS_N_INSNS (1);
1633             }
1634           else
1635             /* Additional gain for omitting two CMOVs.  */
1636             gain += ix86_cost->shift_var + COSTS_N_INSNS (2);
1637         }
1638       else if (GET_CODE (src) == PLUS
1639                || GET_CODE (src) == MINUS
1640                || GET_CODE (src) == IOR
1641                || GET_CODE (src) == XOR
1642                || GET_CODE (src) == AND)
1643         {
1644           gain += ix86_cost->add;
1645           /* Additional gain for andnot for targets without BMI.  */
1646           if (GET_CODE (XEXP (src, 0)) == NOT
1647               && !TARGET_BMI)
1648             gain += 2 * ix86_cost->add;
1649
1650           if (CONST_INT_P (XEXP (src, 0)))
1651             gain -= vector_const_cost (XEXP (src, 0));
1652           if (CONST_INT_P (XEXP (src, 1)))
1653             gain -= vector_const_cost (XEXP (src, 1));
1654         }
1655       else if (GET_CODE (src) == NEG
1656                || GET_CODE (src) == NOT)
1657         gain += ix86_cost->add - COSTS_N_INSNS (1);
1658       else if (GET_CODE (src) == COMPARE)
1659         {
1660           /* Assume comparison cost is the same.  */
1661         }
1662       else if (CONST_INT_P (src))
1663         {
1664           if (REG_P (dst))
1665             gain += COSTS_N_INSNS (2);
1666           else if (MEM_P (dst))
1667             gain += 2 * ix86_cost->int_store[2] - ix86_cost->sse_store[1];
1668           gain -= vector_const_cost (src);
1669         }
1670       else
1671         gcc_unreachable ();
1672     }
1673
1674   if (dump_file)
1675     fprintf (dump_file, "  Instruction conversion gain: %d\n", gain);
1676
1677   EXECUTE_IF_SET_IN_BITMAP (defs_conv, 0, insn_uid, bi)
1678     cost += DF_REG_DEF_COUNT (insn_uid) * ix86_cost->mmxsse_to_integer;
1679
1680   if (dump_file)
1681     fprintf (dump_file, "  Registers conversion cost: %d\n", cost);
1682
1683   gain -= cost;
1684
1685   if (dump_file)
1686     fprintf (dump_file, "  Total gain: %d\n", gain);
1687
1688   return gain;
1689 }
1690
1691 /* Replace REG in X with a V2DI subreg of NEW_REG.  */
1692
1693 rtx
1694 dimode_scalar_chain::replace_with_subreg (rtx x, rtx reg, rtx new_reg)
1695 {
1696   if (x == reg)
1697     return gen_rtx_SUBREG (V2DImode, new_reg, 0);
1698
1699   const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
1700   int i, j;
1701   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1702     {
1703       if (fmt[i] == 'e')
1704         XEXP (x, i) = replace_with_subreg (XEXP (x, i), reg, new_reg);
1705       else if (fmt[i] == 'E')
1706         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1707           XVECEXP (x, i, j) = replace_with_subreg (XVECEXP (x, i, j),
1708                                                    reg, new_reg);
1709     }
1710
1711   return x;
1712 }
1713
1714 /* Replace REG in INSN with a V2DI subreg of NEW_REG.  */
1715
1716 void
1717 dimode_scalar_chain::replace_with_subreg_in_insn (rtx_insn *insn,
1718                                                   rtx reg, rtx new_reg)
1719 {
1720   replace_with_subreg (single_set (insn), reg, new_reg);
1721 }
1722
1723 /* Insert generated conversion instruction sequence INSNS
1724    after instruction AFTER.  New BB may be required in case
1725    instruction has EH region attached.  */
1726
1727 void
1728 scalar_chain::emit_conversion_insns (rtx insns, rtx_insn *after)
1729 {
1730   if (!control_flow_insn_p (after))
1731     {
1732       emit_insn_after (insns, after);
1733       return;
1734     }
1735
1736   basic_block bb = BLOCK_FOR_INSN (after);
1737   edge e = find_fallthru_edge (bb->succs);
1738   gcc_assert (e);
1739
1740   basic_block new_bb = split_edge (e);
1741   emit_insn_after (insns, BB_HEAD (new_bb));
1742 }
1743
1744 /* Make vector copies for all register REGNO definitions
1745    and replace its uses in a chain.  */
1746
1747 void
1748 dimode_scalar_chain::make_vector_copies (unsigned regno)
1749 {
1750   rtx reg = regno_reg_rtx[regno];
1751   rtx vreg = gen_reg_rtx (DImode);
1752   bool count_reg = false;
1753   df_ref ref;
1754
1755   for (ref = DF_REG_DEF_CHAIN (regno); ref; ref = DF_REF_NEXT_REG (ref))
1756     if (!bitmap_bit_p (insns, DF_REF_INSN_UID (ref)))
1757       {
1758         df_ref use;
1759
1760         /* Detect the count register of a shift instruction.  */
1761         for (use = DF_REG_USE_CHAIN (regno); use; use = DF_REF_NEXT_REG (use))
1762           if (bitmap_bit_p (insns, DF_REF_INSN_UID (use)))
1763             {
1764               rtx_insn *insn = DF_REF_INSN (use);
1765               rtx def_set = single_set (insn);
1766
1767               gcc_assert (def_set);
1768
1769               rtx src = SET_SRC (def_set);
1770
1771               if ((GET_CODE (src) == ASHIFT
1772                    || GET_CODE (src) == ASHIFTRT
1773                    || GET_CODE (src) == LSHIFTRT)
1774                   && !CONST_INT_P (XEXP (src, 1))
1775                   && reg_or_subregno (XEXP (src, 1)) == regno)
1776                 count_reg = true;
1777             }
1778
1779         start_sequence ();
1780         if (count_reg)
1781           {
1782             rtx qreg = gen_lowpart (QImode, reg);
1783             rtx tmp = gen_reg_rtx (SImode);
1784
1785             if (TARGET_ZERO_EXTEND_WITH_AND
1786                 && optimize_function_for_speed_p (cfun))
1787               {
1788                 emit_move_insn (tmp, const0_rtx);
1789                 emit_insn (gen_movstrictqi
1790                            (gen_lowpart (QImode, tmp), qreg));
1791               }
1792             else
1793               emit_insn (gen_rtx_SET
1794                          (tmp, gen_rtx_ZERO_EXTEND (SImode, qreg)));
1795
1796             if (!TARGET_INTER_UNIT_MOVES_TO_VEC)
1797               {
1798                 rtx slot = assign_386_stack_local (SImode, SLOT_STV_TEMP);
1799                 emit_move_insn (slot, tmp);
1800                 tmp = copy_rtx (slot);
1801               }
1802
1803             emit_insn (gen_zero_extendsidi2 (vreg, tmp));
1804           }
1805         else if (!TARGET_INTER_UNIT_MOVES_TO_VEC)
1806           {
1807             rtx tmp = assign_386_stack_local (DImode, SLOT_STV_TEMP);
1808             emit_move_insn (adjust_address (tmp, SImode, 0),
1809                             gen_rtx_SUBREG (SImode, reg, 0));
1810             emit_move_insn (adjust_address (tmp, SImode, 4),
1811                             gen_rtx_SUBREG (SImode, reg, 4));
1812             emit_move_insn (vreg, tmp);
1813           }
1814         else if (TARGET_SSE4_1)
1815           {
1816             emit_insn (gen_sse2_loadld (gen_rtx_SUBREG (V4SImode, vreg, 0),
1817                                         CONST0_RTX (V4SImode),
1818                                         gen_rtx_SUBREG (SImode, reg, 0)));
1819             emit_insn (gen_sse4_1_pinsrd (gen_rtx_SUBREG (V4SImode, vreg, 0),
1820                                           gen_rtx_SUBREG (V4SImode, vreg, 0),
1821                                           gen_rtx_SUBREG (SImode, reg, 4),
1822                                           GEN_INT (2)));
1823           }
1824         else
1825           {
1826             rtx tmp = gen_reg_rtx (DImode);
1827             emit_insn (gen_sse2_loadld (gen_rtx_SUBREG (V4SImode, vreg, 0),
1828                                         CONST0_RTX (V4SImode),
1829                                         gen_rtx_SUBREG (SImode, reg, 0)));
1830             emit_insn (gen_sse2_loadld (gen_rtx_SUBREG (V4SImode, tmp, 0),
1831                                         CONST0_RTX (V4SImode),
1832                                         gen_rtx_SUBREG (SImode, reg, 4)));
1833             emit_insn (gen_vec_interleave_lowv4si
1834                        (gen_rtx_SUBREG (V4SImode, vreg, 0),
1835                         gen_rtx_SUBREG (V4SImode, vreg, 0),
1836                         gen_rtx_SUBREG (V4SImode, tmp, 0)));
1837           }
1838         rtx_insn *seq = get_insns ();
1839         end_sequence ();
1840         rtx_insn *insn = DF_REF_INSN (ref);
1841         emit_conversion_insns (seq, insn);
1842
1843         if (dump_file)
1844           fprintf (dump_file,
1845                    "  Copied r%d to a vector register r%d for insn %d\n",
1846                    regno, REGNO (vreg), INSN_UID (insn));
1847       }
1848
1849   for (ref = DF_REG_USE_CHAIN (regno); ref; ref = DF_REF_NEXT_REG (ref))
1850     if (bitmap_bit_p (insns, DF_REF_INSN_UID (ref)))
1851       {
1852         rtx_insn *insn = DF_REF_INSN (ref);
1853         if (count_reg)
1854           {
1855             rtx def_set = single_set (insn);
1856             gcc_assert (def_set);
1857
1858             rtx src = SET_SRC (def_set);
1859
1860             if ((GET_CODE (src) == ASHIFT
1861                  || GET_CODE (src) == ASHIFTRT
1862                  || GET_CODE (src) == LSHIFTRT)
1863                 && !CONST_INT_P (XEXP (src, 1))
1864                 && reg_or_subregno (XEXP (src, 1)) == regno)
1865               XEXP (src, 1) = vreg;
1866           }
1867         else
1868           replace_with_subreg_in_insn (insn, reg, vreg);
1869
1870         if (dump_file)
1871           fprintf (dump_file, "  Replaced r%d with r%d in insn %d\n",
1872                    regno, REGNO (vreg), INSN_UID (insn));
1873       }
1874 }
1875
1876 /* Convert all definitions of register REGNO
1877    and fix its uses.  Scalar copies may be created
1878    in case register is used in not convertible insn.  */
1879
1880 void
1881 dimode_scalar_chain::convert_reg (unsigned regno)
1882 {
1883   bool scalar_copy = bitmap_bit_p (defs_conv, regno);
1884   rtx reg = regno_reg_rtx[regno];
1885   rtx scopy = NULL_RTX;
1886   df_ref ref;
1887   bitmap conv;
1888
1889   conv = BITMAP_ALLOC (NULL);
1890   bitmap_copy (conv, insns);
1891
1892   if (scalar_copy)
1893     scopy = gen_reg_rtx (DImode);
1894
1895   for (ref = DF_REG_DEF_CHAIN (regno); ref; ref = DF_REF_NEXT_REG (ref))
1896     {
1897       rtx_insn *insn = DF_REF_INSN (ref);
1898       rtx def_set = single_set (insn);
1899       rtx src = SET_SRC (def_set);
1900       rtx reg = DF_REF_REG (ref);
1901
1902       if (!MEM_P (src))
1903         {
1904           replace_with_subreg_in_insn (insn, reg, reg);
1905           bitmap_clear_bit (conv, INSN_UID (insn));
1906         }
1907
1908       if (scalar_copy)
1909         {
1910           start_sequence ();
1911           if (!TARGET_INTER_UNIT_MOVES_FROM_VEC)
1912             {
1913               rtx tmp = assign_386_stack_local (DImode, SLOT_STV_TEMP);
1914               emit_move_insn (tmp, reg);
1915               emit_move_insn (gen_rtx_SUBREG (SImode, scopy, 0),
1916                               adjust_address (tmp, SImode, 0));
1917               emit_move_insn (gen_rtx_SUBREG (SImode, scopy, 4),
1918                               adjust_address (tmp, SImode, 4));
1919             }
1920           else if (TARGET_SSE4_1)
1921             {
1922               rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
1923               emit_insn
1924                 (gen_rtx_SET
1925                  (gen_rtx_SUBREG (SImode, scopy, 0),
1926                   gen_rtx_VEC_SELECT (SImode,
1927                                       gen_rtx_SUBREG (V4SImode, reg, 0), tmp)));
1928
1929               tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const1_rtx));
1930               emit_insn
1931                 (gen_rtx_SET
1932                  (gen_rtx_SUBREG (SImode, scopy, 4),
1933                   gen_rtx_VEC_SELECT (SImode,
1934                                       gen_rtx_SUBREG (V4SImode, reg, 0), tmp)));
1935             }
1936           else
1937             {
1938               rtx vcopy = gen_reg_rtx (V2DImode);
1939               emit_move_insn (vcopy, gen_rtx_SUBREG (V2DImode, reg, 0));
1940               emit_move_insn (gen_rtx_SUBREG (SImode, scopy, 0),
1941                               gen_rtx_SUBREG (SImode, vcopy, 0));
1942               emit_move_insn (vcopy,
1943                               gen_rtx_LSHIFTRT (V2DImode, vcopy, GEN_INT (32)));
1944               emit_move_insn (gen_rtx_SUBREG (SImode, scopy, 4),
1945                               gen_rtx_SUBREG (SImode, vcopy, 0));
1946             }
1947           rtx_insn *seq = get_insns ();
1948           end_sequence ();
1949           emit_conversion_insns (seq, insn);
1950
1951           if (dump_file)
1952             fprintf (dump_file,
1953                      "  Copied r%d to a scalar register r%d for insn %d\n",
1954                      regno, REGNO (scopy), INSN_UID (insn));
1955         }
1956     }
1957
1958   for (ref = DF_REG_USE_CHAIN (regno); ref; ref = DF_REF_NEXT_REG (ref))
1959     if (bitmap_bit_p (insns, DF_REF_INSN_UID (ref)))
1960       {
1961         if (bitmap_bit_p (conv, DF_REF_INSN_UID (ref)))
1962           {
1963             rtx_insn *insn = DF_REF_INSN (ref);
1964
1965             rtx def_set = single_set (insn);
1966             gcc_assert (def_set);
1967
1968             rtx src = SET_SRC (def_set);
1969             rtx dst = SET_DEST (def_set);
1970
1971             if ((GET_CODE (src) == ASHIFT
1972                  || GET_CODE (src) == ASHIFTRT
1973                  || GET_CODE (src) == LSHIFTRT)
1974                 && !CONST_INT_P (XEXP (src, 1))
1975                 && reg_or_subregno (XEXP (src, 1)) == regno)
1976               {
1977                 rtx tmp2 = gen_reg_rtx (V2DImode);
1978
1979                 start_sequence ();
1980
1981                 if (TARGET_SSE4_1)
1982                   emit_insn (gen_sse4_1_zero_extendv2qiv2di2
1983                              (tmp2, gen_rtx_SUBREG (V16QImode, reg, 0)));
1984                 else
1985                   {
1986                     rtx vec_cst
1987                       = gen_rtx_CONST_VECTOR (V2DImode,
1988                                               gen_rtvec (2, GEN_INT (0xff),
1989                                                          const0_rtx));
1990                     vec_cst
1991                       = validize_mem (force_const_mem (V2DImode, vec_cst));
1992
1993                     emit_insn (gen_rtx_SET
1994                                (tmp2,
1995                                 gen_rtx_AND (V2DImode,
1996                                              gen_rtx_SUBREG (V2DImode, reg, 0),
1997                                              vec_cst)));
1998                   }
1999                 rtx_insn *seq = get_insns ();
2000                 end_sequence ();
2001
2002                 emit_insn_before (seq, insn);
2003
2004                 XEXP (src, 1) = gen_rtx_SUBREG (DImode, tmp2, 0);
2005               }
2006             else if (!MEM_P (dst) || !REG_P (src))
2007               replace_with_subreg_in_insn (insn, reg, reg);
2008
2009             bitmap_clear_bit (conv, INSN_UID (insn));
2010           }
2011       }
2012     /* Skip debug insns and uninitialized uses.  */
2013     else if (DF_REF_CHAIN (ref)
2014              && NONDEBUG_INSN_P (DF_REF_INSN (ref)))
2015       {
2016         gcc_assert (scopy);
2017         replace_rtx (DF_REF_INSN (ref), reg, scopy);
2018         df_insn_rescan (DF_REF_INSN (ref));
2019       }
2020
2021   BITMAP_FREE (conv);
2022 }
2023
2024 /* Convert operand OP in INSN.  We should handle
2025    memory operands and uninitialized registers.
2026    All other register uses are converted during
2027    registers conversion.  */
2028
2029 void
2030 dimode_scalar_chain::convert_op (rtx *op, rtx_insn *insn)
2031 {
2032   *op = copy_rtx_if_shared (*op);
2033
2034   if (GET_CODE (*op) == NOT)
2035     {
2036       convert_op (&XEXP (*op, 0), insn);
2037       PUT_MODE (*op, V2DImode);
2038     }
2039   else if (MEM_P (*op))
2040     {
2041       rtx tmp = gen_reg_rtx (DImode);
2042
2043       emit_insn_before (gen_move_insn (tmp, *op), insn);
2044       *op = gen_rtx_SUBREG (V2DImode, tmp, 0);
2045
2046       if (dump_file)
2047         fprintf (dump_file, "  Preloading operand for insn %d into r%d\n",
2048                  INSN_UID (insn), REGNO (tmp));
2049     }
2050   else if (REG_P (*op))
2051     {
2052       /* We may have not converted register usage in case
2053          this register has no definition.  Otherwise it
2054          should be converted in convert_reg.  */
2055       df_ref ref;
2056       FOR_EACH_INSN_USE (ref, insn)
2057         if (DF_REF_REGNO (ref) == REGNO (*op))
2058           {
2059             gcc_assert (!DF_REF_CHAIN (ref));
2060             break;
2061           }
2062       *op = gen_rtx_SUBREG (V2DImode, *op, 0);
2063     }
2064   else if (CONST_INT_P (*op))
2065     {
2066       rtx vec_cst;
2067       rtx tmp = gen_rtx_SUBREG (V2DImode, gen_reg_rtx (DImode), 0);
2068
2069       /* Prefer all ones vector in case of -1.  */
2070       if (constm1_operand (*op, GET_MODE (*op)))
2071         vec_cst = CONSTM1_RTX (V2DImode);
2072       else
2073         vec_cst = gen_rtx_CONST_VECTOR (V2DImode,
2074                                         gen_rtvec (2, *op, const0_rtx));
2075
2076       if (!standard_sse_constant_p (vec_cst, V2DImode))
2077         {
2078           start_sequence ();
2079           vec_cst = validize_mem (force_const_mem (V2DImode, vec_cst));
2080           rtx_insn *seq = get_insns ();
2081           end_sequence ();
2082           emit_insn_before (seq, insn);
2083         }
2084
2085       emit_insn_before (gen_move_insn (copy_rtx (tmp), vec_cst), insn);
2086       *op = tmp;
2087     }
2088   else
2089     {
2090       gcc_assert (SUBREG_P (*op));
2091       gcc_assert (GET_MODE (*op) == V2DImode);
2092     }
2093 }
2094
2095 /* Convert INSN to vector mode.  */
2096
2097 void
2098 dimode_scalar_chain::convert_insn (rtx_insn *insn)
2099 {
2100   rtx def_set = single_set (insn);
2101   rtx src = SET_SRC (def_set);
2102   rtx dst = SET_DEST (def_set);
2103   rtx subreg;
2104
2105   if (MEM_P (dst) && !REG_P (src))
2106     {
2107       /* There are no scalar integer instructions and therefore
2108          temporary register usage is required.  */
2109       rtx tmp = gen_reg_rtx (DImode);
2110       emit_conversion_insns (gen_move_insn (dst, tmp), insn);
2111       dst = gen_rtx_SUBREG (V2DImode, tmp, 0);
2112     }
2113
2114   switch (GET_CODE (src))
2115     {
2116     case ASHIFT:
2117     case ASHIFTRT:
2118     case LSHIFTRT:
2119       convert_op (&XEXP (src, 0), insn);
2120       PUT_MODE (src, V2DImode);
2121       break;
2122
2123     case PLUS:
2124     case MINUS:
2125     case IOR:
2126     case XOR:
2127     case AND:
2128       convert_op (&XEXP (src, 0), insn);
2129       convert_op (&XEXP (src, 1), insn);
2130       PUT_MODE (src, V2DImode);
2131       break;
2132
2133     case NEG:
2134       src = XEXP (src, 0);
2135       convert_op (&src, insn);
2136       subreg = gen_reg_rtx (V2DImode);
2137       emit_insn_before (gen_move_insn (subreg, CONST0_RTX (V2DImode)), insn);
2138       src = gen_rtx_MINUS (V2DImode, subreg, src);
2139       break;
2140
2141     case NOT:
2142       src = XEXP (src, 0);
2143       convert_op (&src, insn);
2144       subreg = gen_reg_rtx (V2DImode);
2145       emit_insn_before (gen_move_insn (subreg, CONSTM1_RTX (V2DImode)), insn);
2146       src = gen_rtx_XOR (V2DImode, src, subreg);
2147       break;
2148
2149     case MEM:
2150       if (!REG_P (dst))
2151         convert_op (&src, insn);
2152       break;
2153
2154     case REG:
2155       if (!MEM_P (dst))
2156         convert_op (&src, insn);
2157       break;
2158
2159     case SUBREG:
2160       gcc_assert (GET_MODE (src) == V2DImode);
2161       break;
2162
2163     case COMPARE:
2164       src = SUBREG_REG (XEXP (XEXP (src, 0), 0));
2165
2166       gcc_assert ((REG_P (src) && GET_MODE (src) == DImode)
2167                   || (SUBREG_P (src) && GET_MODE (src) == V2DImode));
2168
2169       if (REG_P (src))
2170         subreg = gen_rtx_SUBREG (V2DImode, src, 0);
2171       else
2172         subreg = copy_rtx_if_shared (src);
2173       emit_insn_before (gen_vec_interleave_lowv2di (copy_rtx_if_shared (subreg),
2174                                                     copy_rtx_if_shared (subreg),
2175                                                     copy_rtx_if_shared (subreg)),
2176                         insn);
2177       dst = gen_rtx_REG (CCmode, FLAGS_REG);
2178       src = gen_rtx_UNSPEC (CCmode, gen_rtvec (2, copy_rtx_if_shared (src),
2179                                                copy_rtx_if_shared (src)),
2180                             UNSPEC_PTEST);
2181       break;
2182
2183     case CONST_INT:
2184       convert_op (&src, insn);
2185       break;
2186
2187     default:
2188       gcc_unreachable ();
2189     }
2190
2191   SET_SRC (def_set) = src;
2192   SET_DEST (def_set) = dst;
2193
2194   /* Drop possible dead definitions.  */
2195   PATTERN (insn) = def_set;
2196
2197   INSN_CODE (insn) = -1;
2198   recog_memoized (insn);
2199   df_insn_rescan (insn);
2200 }
2201
2202 /* Fix uses of converted REG in debug insns.  */
2203
2204 void
2205 timode_scalar_chain::fix_debug_reg_uses (rtx reg)
2206 {
2207   if (!flag_var_tracking)
2208     return;
2209
2210   df_ref ref, next;
2211   for (ref = DF_REG_USE_CHAIN (REGNO (reg)); ref; ref = next)
2212     {
2213       rtx_insn *insn = DF_REF_INSN (ref);
2214       /* Make sure the next ref is for a different instruction,
2215          so that we're not affected by the rescan.  */
2216       next = DF_REF_NEXT_REG (ref);
2217       while (next && DF_REF_INSN (next) == insn)
2218         next = DF_REF_NEXT_REG (next);
2219
2220       if (DEBUG_INSN_P (insn))
2221         {
2222           /* It may be a debug insn with a TImode variable in
2223              register.  */
2224           bool changed = false;
2225           for (; ref != next; ref = DF_REF_NEXT_REG (ref))
2226             {
2227               rtx *loc = DF_REF_LOC (ref);
2228               if (REG_P (*loc) && GET_MODE (*loc) == V1TImode)
2229                 {
2230                   *loc = gen_rtx_SUBREG (TImode, *loc, 0);
2231                   changed = true;
2232                 }
2233             }
2234           if (changed)
2235             df_insn_rescan (insn);
2236         }
2237     }
2238 }
2239
2240 /* Convert INSN from TImode to V1T1mode.  */
2241
2242 void
2243 timode_scalar_chain::convert_insn (rtx_insn *insn)
2244 {
2245   rtx def_set = single_set (insn);
2246   rtx src = SET_SRC (def_set);
2247   rtx dst = SET_DEST (def_set);
2248
2249   switch (GET_CODE (dst))
2250     {
2251     case REG:
2252       {
2253         rtx tmp = find_reg_equal_equiv_note (insn);
2254         if (tmp)
2255           PUT_MODE (XEXP (tmp, 0), V1TImode);
2256         PUT_MODE (dst, V1TImode);
2257         fix_debug_reg_uses (dst);
2258       }
2259       break;
2260     case MEM:
2261       PUT_MODE (dst, V1TImode);
2262       break;
2263
2264     default:
2265       gcc_unreachable ();
2266     }
2267
2268   switch (GET_CODE (src))
2269     {
2270     case REG:
2271       PUT_MODE (src, V1TImode);
2272       /* Call fix_debug_reg_uses only if SRC is never defined.  */
2273       if (!DF_REG_DEF_CHAIN (REGNO (src)))
2274         fix_debug_reg_uses (src);
2275       break;
2276
2277     case MEM:
2278       PUT_MODE (src, V1TImode);
2279       break;
2280
2281     case CONST_WIDE_INT:
2282       if (NONDEBUG_INSN_P (insn))
2283         {
2284           /* Since there are no instructions to store 128-bit constant,
2285              temporary register usage is required.  */
2286           rtx tmp = gen_reg_rtx (V1TImode);
2287           start_sequence ();
2288           src = gen_rtx_CONST_VECTOR (V1TImode, gen_rtvec (1, src));
2289           src = validize_mem (force_const_mem (V1TImode, src));
2290           rtx_insn *seq = get_insns ();
2291           end_sequence ();
2292           if (seq)
2293             emit_insn_before (seq, insn);
2294           emit_conversion_insns (gen_rtx_SET (dst, tmp), insn);
2295           dst = tmp;
2296         }
2297       break;
2298
2299     case CONST_INT:
2300       switch (standard_sse_constant_p (src, TImode))
2301         {
2302         case 1:
2303           src = CONST0_RTX (GET_MODE (dst));
2304           break;
2305         case 2:
2306           src = CONSTM1_RTX (GET_MODE (dst));
2307           break;
2308         default:
2309           gcc_unreachable ();
2310         }
2311       if (NONDEBUG_INSN_P (insn))
2312         {
2313           rtx tmp = gen_reg_rtx (V1TImode);
2314           /* Since there are no instructions to store standard SSE
2315              constant, temporary register usage is required.  */
2316           emit_conversion_insns (gen_rtx_SET (dst, tmp), insn);
2317           dst = tmp;
2318         }
2319       break;
2320
2321     default:
2322       gcc_unreachable ();
2323     }
2324
2325   SET_SRC (def_set) = src;
2326   SET_DEST (def_set) = dst;
2327
2328   /* Drop possible dead definitions.  */
2329   PATTERN (insn) = def_set;
2330
2331   INSN_CODE (insn) = -1;
2332   recog_memoized (insn);
2333   df_insn_rescan (insn);
2334 }
2335
2336 void
2337 dimode_scalar_chain::convert_registers ()
2338 {
2339   bitmap_iterator bi;
2340   unsigned id;
2341
2342   EXECUTE_IF_SET_IN_BITMAP (defs, 0, id, bi)
2343     convert_reg (id);
2344
2345   EXECUTE_IF_AND_COMPL_IN_BITMAP (defs_conv, defs, 0, id, bi)
2346     make_vector_copies (id);
2347 }
2348
2349 /* Convert whole chain creating required register
2350    conversions and copies.  */
2351
2352 int
2353 scalar_chain::convert ()
2354 {
2355   bitmap_iterator bi;
2356   unsigned id;
2357   int converted_insns = 0;
2358
2359   if (!dbg_cnt (stv_conversion))
2360     return 0;
2361
2362   if (dump_file)
2363     fprintf (dump_file, "Converting chain #%d...\n", chain_id);
2364
2365   convert_registers ();
2366
2367   EXECUTE_IF_SET_IN_BITMAP (insns, 0, id, bi)
2368     {
2369       convert_insn (DF_INSN_UID_GET (id)->insn);
2370       converted_insns++;
2371     }
2372
2373   return converted_insns;
2374 }
2375
2376 /* Main STV pass function.  Find and convert scalar
2377    instructions into vector mode when profitable.  */
2378
2379 static unsigned int
2380 convert_scalars_to_vector ()
2381 {
2382   basic_block bb;
2383   bitmap candidates;
2384   int converted_insns = 0;
2385
2386   bitmap_obstack_initialize (NULL);
2387   candidates = BITMAP_ALLOC (NULL);
2388
2389   calculate_dominance_info (CDI_DOMINATORS);
2390   df_set_flags (DF_DEFER_INSN_RESCAN);
2391   df_chain_add_problem (DF_DU_CHAIN | DF_UD_CHAIN);
2392   df_md_add_problem ();
2393   df_analyze ();
2394
2395   /* Find all instructions we want to convert into vector mode.  */
2396   if (dump_file)
2397     fprintf (dump_file, "Searching for mode conversion candidates...\n");
2398
2399   FOR_EACH_BB_FN (bb, cfun)
2400     {
2401       rtx_insn *insn;
2402       FOR_BB_INSNS (bb, insn)
2403         if (scalar_to_vector_candidate_p (insn))
2404           {
2405             if (dump_file)
2406               fprintf (dump_file, "  insn %d is marked as a candidate\n",
2407                        INSN_UID (insn));
2408
2409             bitmap_set_bit (candidates, INSN_UID (insn));
2410           }
2411     }
2412
2413   remove_non_convertible_regs (candidates);
2414
2415   if (bitmap_empty_p (candidates))
2416     if (dump_file)
2417       fprintf (dump_file, "There are no candidates for optimization.\n");
2418
2419   while (!bitmap_empty_p (candidates))
2420     {
2421       unsigned uid = bitmap_first_set_bit (candidates);
2422       scalar_chain *chain;
2423
2424       if (TARGET_64BIT)
2425         chain = new timode_scalar_chain;
2426       else
2427         chain = new dimode_scalar_chain;
2428
2429       /* Find instructions chain we want to convert to vector mode.
2430          Check all uses and definitions to estimate all required
2431          conversions.  */
2432       chain->build (candidates, uid);
2433
2434       if (chain->compute_convert_gain () > 0)
2435         converted_insns += chain->convert ();
2436       else
2437         if (dump_file)
2438           fprintf (dump_file, "Chain #%d conversion is not profitable\n",
2439                    chain->chain_id);
2440
2441       delete chain;
2442     }
2443
2444   if (dump_file)
2445     fprintf (dump_file, "Total insns converted: %d\n", converted_insns);
2446
2447   BITMAP_FREE (candidates);
2448   bitmap_obstack_release (NULL);
2449   df_process_deferred_rescans ();
2450
2451   /* Conversion means we may have 128bit register spills/fills
2452      which require aligned stack.  */
2453   if (converted_insns)
2454     {
2455       if (crtl->stack_alignment_needed < 128)
2456         crtl->stack_alignment_needed = 128;
2457       if (crtl->stack_alignment_estimated < 128)
2458         crtl->stack_alignment_estimated = 128;
2459       /* Fix up DECL_RTL/DECL_INCOMING_RTL of arguments.  */
2460       if (TARGET_64BIT)
2461         for (tree parm = DECL_ARGUMENTS (current_function_decl);
2462              parm; parm = DECL_CHAIN (parm))
2463           {
2464             if (TYPE_MODE (TREE_TYPE (parm)) != TImode)
2465               continue;
2466             if (DECL_RTL_SET_P (parm)
2467                 && GET_MODE (DECL_RTL (parm)) == V1TImode)
2468               {
2469                 rtx r = DECL_RTL (parm);
2470                 if (REG_P (r))
2471                   SET_DECL_RTL (parm, gen_rtx_SUBREG (TImode, r, 0));
2472               }
2473             if (DECL_INCOMING_RTL (parm)
2474                 && GET_MODE (DECL_INCOMING_RTL (parm)) == V1TImode)
2475               {
2476                 rtx r = DECL_INCOMING_RTL (parm);
2477                 if (REG_P (r))
2478                   DECL_INCOMING_RTL (parm) = gen_rtx_SUBREG (TImode, r, 0);
2479               }
2480           }
2481     }
2482
2483   return 0;
2484 }
2485
2486 namespace {
2487
2488 const pass_data pass_data_insert_vzeroupper =
2489 {
2490   RTL_PASS, /* type */
2491   "vzeroupper", /* name */
2492   OPTGROUP_NONE, /* optinfo_flags */
2493   TV_MACH_DEP, /* tv_id */
2494   0, /* properties_required */
2495   0, /* properties_provided */
2496   0, /* properties_destroyed */
2497   0, /* todo_flags_start */
2498   TODO_df_finish, /* todo_flags_finish */
2499 };
2500
2501 class pass_insert_vzeroupper : public rtl_opt_pass
2502 {
2503 public:
2504   pass_insert_vzeroupper(gcc::context *ctxt)
2505     : rtl_opt_pass(pass_data_insert_vzeroupper, ctxt)
2506   {}
2507
2508   /* opt_pass methods: */
2509   virtual bool gate (function *)
2510     {
2511       return TARGET_AVX
2512              && TARGET_VZEROUPPER && flag_expensive_optimizations
2513              && !optimize_size;
2514     }
2515
2516   virtual unsigned int execute (function *)
2517     {
2518       return rest_of_handle_insert_vzeroupper ();
2519     }
2520
2521 }; // class pass_insert_vzeroupper
2522
2523 const pass_data pass_data_stv =
2524 {
2525   RTL_PASS, /* type */
2526   "stv", /* name */
2527   OPTGROUP_NONE, /* optinfo_flags */
2528   TV_MACH_DEP, /* tv_id */
2529   0, /* properties_required */
2530   0, /* properties_provided */
2531   0, /* properties_destroyed */
2532   0, /* todo_flags_start */
2533   TODO_df_finish, /* todo_flags_finish */
2534 };
2535
2536 class pass_stv : public rtl_opt_pass
2537 {
2538 public:
2539   pass_stv (gcc::context *ctxt)
2540     : rtl_opt_pass (pass_data_stv, ctxt),
2541       timode_p (false)
2542   {}
2543
2544   /* opt_pass methods: */
2545   virtual bool gate (function *)
2546     {
2547       return (timode_p == !!TARGET_64BIT
2548               && TARGET_STV && TARGET_SSE2 && optimize > 1);
2549     }
2550
2551   virtual unsigned int execute (function *)
2552     {
2553       return convert_scalars_to_vector ();
2554     }
2555
2556   opt_pass *clone ()
2557     {
2558       return new pass_stv (m_ctxt);
2559     }
2560
2561   void set_pass_param (unsigned int n, bool param)
2562     {
2563       gcc_assert (n == 0);
2564       timode_p = param;
2565     }
2566
2567 private:
2568   bool timode_p;
2569 }; // class pass_stv
2570
2571 } // anon namespace
2572
2573 rtl_opt_pass *
2574 make_pass_insert_vzeroupper (gcc::context *ctxt)
2575 {
2576   return new pass_insert_vzeroupper (ctxt);
2577 }
2578
2579 rtl_opt_pass *
2580 make_pass_stv (gcc::context *ctxt)
2581 {
2582   return new pass_stv (ctxt);
2583 }
2584
2585 /* Inserting ENDBRANCH instructions.  */
2586
2587 static unsigned int
2588 rest_of_insert_endbranch (void)
2589 {
2590   timevar_push (TV_MACH_DEP);
2591
2592   rtx cet_eb;
2593   rtx_insn *insn;
2594   basic_block bb;
2595
2596   /* Currently emit EB if it's a tracking function, i.e. 'nocf_check' is
2597      absent among function attributes.  Later an optimization will be
2598      introduced to make analysis if an address of a static function is
2599      taken.  A static function whose address is not taken will get a
2600      nocf_check attribute.  This will allow to reduce the number of EB.  */
2601
2602   if (!lookup_attribute ("nocf_check",
2603                          TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl)))
2604       && !cgraph_node::get (cfun->decl)->only_called_directly_p ())
2605     {
2606       cet_eb = gen_nop_endbr ();
2607
2608       bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
2609       insn = BB_HEAD (bb);
2610       emit_insn_before (cet_eb, insn);
2611     }
2612
2613   bb = 0;
2614   FOR_EACH_BB_FN (bb, cfun)
2615     {
2616       for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb));
2617            insn = NEXT_INSN (insn))
2618         {
2619           if (CALL_P (insn))
2620             {
2621               if (find_reg_note (insn, REG_SETJMP, NULL) == NULL)
2622                 continue;
2623               /* Generate ENDBRANCH after CALL, which can return more than
2624                  twice, setjmp-like functions.  */
2625
2626               cet_eb = gen_nop_endbr ();
2627               emit_insn_after_setloc (cet_eb, insn, INSN_LOCATION (insn));
2628               continue;
2629             }
2630
2631           if (JUMP_P (insn) && flag_cet_switch)
2632             {
2633               rtx target = JUMP_LABEL (insn);
2634               if (target == NULL_RTX || ANY_RETURN_P (target))
2635                 continue;
2636
2637               /* Check the jump is a switch table.  */
2638               rtx_insn *label = as_a<rtx_insn *> (target);
2639               rtx_insn *table = next_insn (label);
2640               if (table == NULL_RTX || !JUMP_TABLE_DATA_P (table))
2641                 continue;
2642
2643               /* For the indirect jump find out all places it jumps and insert
2644                  ENDBRANCH there.  It should be done under a special flag to
2645                  control ENDBRANCH generation for switch stmts.  */
2646               edge_iterator ei;
2647               edge e;
2648               basic_block dest_blk;
2649
2650               FOR_EACH_EDGE (e, ei, bb->succs)
2651                 {
2652                   rtx_insn *insn;
2653
2654                   dest_blk = e->dest;
2655                   insn = BB_HEAD (dest_blk);
2656                   gcc_assert (LABEL_P (insn));
2657                   cet_eb = gen_nop_endbr ();
2658                   emit_insn_after (cet_eb, insn);
2659                 }
2660               continue;
2661             }
2662
2663           if ((LABEL_P (insn) && LABEL_PRESERVE_P (insn))
2664               || (NOTE_P (insn)
2665                   && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))
2666             /* TODO.  Check /s bit also.  */
2667             {
2668               cet_eb = gen_nop_endbr ();
2669               emit_insn_after (cet_eb, insn);
2670               continue;
2671             }
2672         }
2673     }
2674
2675   timevar_pop (TV_MACH_DEP);
2676   return 0;
2677 }
2678
2679 namespace {
2680
2681 const pass_data pass_data_insert_endbranch =
2682 {
2683   RTL_PASS, /* type.  */
2684   "cet", /* name.  */
2685   OPTGROUP_NONE, /* optinfo_flags.  */
2686   TV_MACH_DEP, /* tv_id.  */
2687   0, /* properties_required.  */
2688   0, /* properties_provided.  */
2689   0, /* properties_destroyed.  */
2690   0, /* todo_flags_start.  */
2691   0, /* todo_flags_finish.  */
2692 };
2693
2694 class pass_insert_endbranch : public rtl_opt_pass
2695 {
2696 public:
2697   pass_insert_endbranch (gcc::context *ctxt)
2698     : rtl_opt_pass (pass_data_insert_endbranch, ctxt)
2699   {}
2700
2701   /* opt_pass methods: */
2702   virtual bool gate (function *)
2703     {
2704       return ((flag_cf_protection & CF_BRANCH));
2705     }
2706
2707   virtual unsigned int execute (function *)
2708     {
2709       return rest_of_insert_endbranch ();
2710     }
2711
2712 }; // class pass_insert_endbranch
2713
2714 } // anon namespace
2715
2716 rtl_opt_pass *
2717 make_pass_insert_endbranch (gcc::context *ctxt)
2718 {
2719   return new pass_insert_endbranch (ctxt);
2720 }
2721
2722 /* Return true if a red-zone is in use.  We can't use red-zone when
2723    there are local indirect jumps, like "indirect_jump" or "tablejump",
2724    which jumps to another place in the function, since "call" in the
2725    indirect thunk pushes the return address onto stack, destroying
2726    red-zone.
2727
2728    TODO: If we can reserve the first 2 WORDs, for PUSH and, another
2729    for CALL, in red-zone, we can allow local indirect jumps with
2730    indirect thunk.  */
2731
2732 bool
2733 ix86_using_red_zone (void)
2734 {
2735   return (TARGET_RED_ZONE
2736           && !TARGET_64BIT_MS_ABI
2737           && (!cfun->machine->has_local_indirect_jump
2738               || cfun->machine->indirect_branch_type == indirect_branch_keep));
2739 }
2740 \f
2741 /* Return a string that documents the current -m options.  The caller is
2742    responsible for freeing the string.  */
2743
2744 static char *
2745 ix86_target_string (HOST_WIDE_INT isa, HOST_WIDE_INT isa2,
2746                     int flags, int flags2,
2747                     const char *arch, const char *tune,
2748                     enum fpmath_unit fpmath, bool add_nl_p)
2749 {
2750   struct ix86_target_opts
2751   {
2752     const char *option;         /* option string */
2753     HOST_WIDE_INT mask;         /* isa mask options */
2754   };
2755
2756   /* This table is ordered so that options like -msse4.2 that imply other
2757      ISAs come first.  Target string will be displayed in the same order.  */
2758   static struct ix86_target_opts isa2_opts[] =
2759   {
2760     { "-mcx16",         OPTION_MASK_ISA_CX16 },
2761     { "-mmpx",          OPTION_MASK_ISA_MPX },
2762     { "-mvaes",         OPTION_MASK_ISA_VAES },
2763     { "-mrdpid",        OPTION_MASK_ISA_RDPID },
2764     { "-mpconfig",      OPTION_MASK_ISA_PCONFIG },
2765     { "-mwbnoinvd",     OPTION_MASK_ISA_WBNOINVD },
2766     { "-msgx",          OPTION_MASK_ISA_SGX },
2767     { "-mavx5124vnniw", OPTION_MASK_ISA_AVX5124VNNIW },
2768     { "-mavx5124fmaps", OPTION_MASK_ISA_AVX5124FMAPS },
2769     { "-mhle",          OPTION_MASK_ISA_HLE },
2770     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2771     { "-mclzero",       OPTION_MASK_ISA_CLZERO },
2772     { "-mmwaitx",       OPTION_MASK_ISA_MWAITX },
2773     { "-mmovdir64b",    OPTION_MASK_ISA_MOVDIR64B }
2774   };
2775   static struct ix86_target_opts isa_opts[] =
2776   {
2777     { "-mavx512vpopcntdq", OPTION_MASK_ISA_AVX512VPOPCNTDQ },
2778     { "-mavx512bitalg", OPTION_MASK_ISA_AVX512BITALG },
2779     { "-mvpclmulqdq",   OPTION_MASK_ISA_VPCLMULQDQ },
2780     { "-mgfni",         OPTION_MASK_ISA_GFNI },
2781     { "-mavx512vnni",   OPTION_MASK_ISA_AVX512VNNI },
2782     { "-mavx512vbmi2",  OPTION_MASK_ISA_AVX512VBMI2 },
2783     { "-mavx512vbmi",   OPTION_MASK_ISA_AVX512VBMI },
2784     { "-mavx512ifma",   OPTION_MASK_ISA_AVX512IFMA },
2785     { "-mavx512vl",     OPTION_MASK_ISA_AVX512VL },
2786     { "-mavx512bw",     OPTION_MASK_ISA_AVX512BW },
2787     { "-mavx512dq",     OPTION_MASK_ISA_AVX512DQ },
2788     { "-mavx512er",     OPTION_MASK_ISA_AVX512ER },
2789     { "-mavx512pf",     OPTION_MASK_ISA_AVX512PF },
2790     { "-mavx512cd",     OPTION_MASK_ISA_AVX512CD },
2791     { "-mavx512f",      OPTION_MASK_ISA_AVX512F },
2792     { "-mavx2",         OPTION_MASK_ISA_AVX2 },
2793     { "-mfma",          OPTION_MASK_ISA_FMA },
2794     { "-mxop",          OPTION_MASK_ISA_XOP },
2795     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2796     { "-mf16c",         OPTION_MASK_ISA_F16C },
2797     { "-mavx",          OPTION_MASK_ISA_AVX },
2798 /*  { "-msse4"          OPTION_MASK_ISA_SSE4 }, */
2799     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2800     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2801     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2802     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2803     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2804     { "-maes",          OPTION_MASK_ISA_AES },
2805     { "-msha",          OPTION_MASK_ISA_SHA },
2806     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2807     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2808     { "-msse",          OPTION_MASK_ISA_SSE },
2809     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2810     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2811     { "-mmmx",          OPTION_MASK_ISA_MMX },
2812     { "-mrtm",          OPTION_MASK_ISA_RTM },
2813     { "-mprfchw",       OPTION_MASK_ISA_PRFCHW },
2814     { "-mrdseed",       OPTION_MASK_ISA_RDSEED },
2815     { "-madx",          OPTION_MASK_ISA_ADX },
2816     { "-mprefetchwt1",  OPTION_MASK_ISA_PREFETCHWT1 },
2817     { "-mclflushopt",   OPTION_MASK_ISA_CLFLUSHOPT },
2818     { "-mxsaves",       OPTION_MASK_ISA_XSAVES },
2819     { "-mxsavec",       OPTION_MASK_ISA_XSAVEC },
2820     { "-mxsaveopt",     OPTION_MASK_ISA_XSAVEOPT },
2821     { "-mxsave",        OPTION_MASK_ISA_XSAVE },
2822     { "-mabm",          OPTION_MASK_ISA_ABM },
2823     { "-mbmi",          OPTION_MASK_ISA_BMI },
2824     { "-mbmi2",         OPTION_MASK_ISA_BMI2 },
2825     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2826     { "-mtbm",          OPTION_MASK_ISA_TBM },
2827     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2828     { "-msahf",         OPTION_MASK_ISA_SAHF },
2829     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2830     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2831     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2832     { "-mpku",          OPTION_MASK_ISA_PKU },
2833     { "-mlwp",          OPTION_MASK_ISA_LWP },
2834     { "-mfxsr",         OPTION_MASK_ISA_FXSR },
2835     { "-mclwb",         OPTION_MASK_ISA_CLWB },
2836     { "-mshstk",        OPTION_MASK_ISA_SHSTK },
2837     { "-mmovdiri",      OPTION_MASK_ISA_MOVDIRI }
2838   };
2839
2840   /* Flag options.  */
2841   static struct ix86_target_opts flag_opts[] =
2842   {
2843     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2844     { "-mlong-double-128",              MASK_LONG_DOUBLE_128 },
2845     { "-mlong-double-64",               MASK_LONG_DOUBLE_64 },
2846     { "-m80387",                        MASK_80387 },
2847     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2848     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2849     { "-mcld",                          MASK_CLD },
2850     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2851     { "-mieee-fp",                      MASK_IEEE_FP },
2852     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2853     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2854     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2855     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2856     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2857     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2858     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2859     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2860     { "-mrecip",                        MASK_RECIP },
2861     { "-mrtd",                          MASK_RTD },
2862     { "-msseregparm",                   MASK_SSEREGPARM },
2863     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2864     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2865     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2866     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2867     { "-mvzeroupper",                   MASK_VZEROUPPER },
2868     { "-mstv",                          MASK_STV },
2869     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD },
2870     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE },
2871     { "-mcall-ms2sysv-xlogues",         MASK_CALL_MS2SYSV_XLOGUES }
2872   };
2873
2874   /* Additional flag options.  */
2875   static struct ix86_target_opts flag2_opts[] =
2876   {
2877     { "-mgeneral-regs-only",            OPTION_MASK_GENERAL_REGS_ONLY }
2878   };
2879
2880   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (isa2_opts)
2881                    + ARRAY_SIZE (flag_opts) + ARRAY_SIZE (flag2_opts) + 6][2];
2882
2883   char isa_other[40];
2884   char isa2_other[40];
2885   char flags_other[40];
2886   char flags2_other[40];
2887   unsigned num = 0;
2888   unsigned i, j;
2889   char *ret;
2890   char *ptr;
2891   size_t len;
2892   size_t line_len;
2893   size_t sep_len;
2894   const char *abi;
2895
2896   memset (opts, '\0', sizeof (opts));
2897
2898   /* Add -march= option.  */
2899   if (arch)
2900     {
2901       opts[num][0] = "-march=";
2902       opts[num++][1] = arch;
2903     }
2904
2905   /* Add -mtune= option.  */
2906   if (tune)
2907     {
2908       opts[num][0] = "-mtune=";
2909       opts[num++][1] = tune;
2910     }
2911
2912   /* Add -m32/-m64/-mx32.  */
2913   if ((isa & OPTION_MASK_ISA_64BIT) != 0)
2914     {
2915       if ((isa & OPTION_MASK_ABI_64) != 0)
2916         abi = "-m64";
2917       else
2918         abi = "-mx32";
2919       isa &= ~ (OPTION_MASK_ISA_64BIT
2920                 | OPTION_MASK_ABI_64
2921                 | OPTION_MASK_ABI_X32);
2922     }
2923   else
2924     abi = "-m32";
2925   opts[num++][0] = abi;
2926
2927   /* Pick out the options in isa2 options.  */
2928   for (i = 0; i < ARRAY_SIZE (isa2_opts); i++)
2929     {
2930       if ((isa2 & isa2_opts[i].mask) != 0)
2931         {
2932           opts[num++][0] = isa2_opts[i].option;
2933           isa2 &= ~ isa2_opts[i].mask;
2934         }
2935     }
2936
2937   if (isa2 && add_nl_p)
2938     {
2939       opts[num++][0] = isa2_other;
2940       sprintf (isa2_other, "(other isa2: %#" HOST_WIDE_INT_PRINT "x)", isa2);
2941     }
2942
2943   /* Pick out the options in isa options.  */
2944   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2945     {
2946       if ((isa & isa_opts[i].mask) != 0)
2947         {
2948           opts[num++][0] = isa_opts[i].option;
2949           isa &= ~ isa_opts[i].mask;
2950         }
2951     }
2952
2953   if (isa && add_nl_p)
2954     {
2955       opts[num++][0] = isa_other;
2956       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)", isa);
2957     }
2958
2959   /* Add flag options.  */
2960   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2961     {
2962       if ((flags & flag_opts[i].mask) != 0)
2963         {
2964           opts[num++][0] = flag_opts[i].option;
2965           flags &= ~ flag_opts[i].mask;
2966         }
2967     }
2968
2969   if (flags && add_nl_p)
2970     {
2971       opts[num++][0] = flags_other;
2972       sprintf (flags_other, "(other flags: %#x)", flags);
2973     }
2974
2975     /* Add additional flag options.  */
2976   for (i = 0; i < ARRAY_SIZE (flag2_opts); i++)
2977     {
2978       if ((flags2 & flag2_opts[i].mask) != 0)
2979         {
2980           opts[num++][0] = flag2_opts[i].option;
2981           flags2 &= ~ flag2_opts[i].mask;
2982         }
2983     }
2984
2985   if (flags2 && add_nl_p)
2986     {
2987       opts[num++][0] = flags2_other;
2988       sprintf (flags2_other, "(other flags2: %#x)", flags2);
2989     }
2990
2991   /* Add -fpmath= option.  */
2992   if (fpmath)
2993     {
2994       opts[num][0] = "-mfpmath=";
2995       switch ((int) fpmath)
2996         {
2997         case FPMATH_387:
2998           opts[num++][1] = "387";
2999           break;
3000
3001         case FPMATH_SSE:
3002           opts[num++][1] = "sse";
3003           break;
3004
3005         case FPMATH_387 | FPMATH_SSE:
3006           opts[num++][1] = "sse+387";
3007           break;
3008
3009         default:
3010           gcc_unreachable ();
3011         }
3012     }
3013
3014   /* Any options?  */
3015   if (num == 0)
3016     return NULL;
3017
3018   gcc_assert (num < ARRAY_SIZE (opts));
3019
3020   /* Size the string.  */
3021   len = 0;
3022   sep_len = (add_nl_p) ? 3 : 1;
3023   for (i = 0; i < num; i++)
3024     {
3025       len += sep_len;
3026       for (j = 0; j < 2; j++)
3027         if (opts[i][j])
3028           len += strlen (opts[i][j]);
3029     }
3030
3031   /* Build the string.  */
3032   ret = ptr = (char *) xmalloc (len);
3033   line_len = 0;
3034
3035   for (i = 0; i < num; i++)
3036     {
3037       size_t len2[2];
3038
3039       for (j = 0; j < 2; j++)
3040         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
3041
3042       if (i != 0)
3043         {
3044           *ptr++ = ' ';
3045           line_len++;
3046
3047           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
3048             {
3049               *ptr++ = '\\';
3050               *ptr++ = '\n';
3051               line_len = 0;
3052             }
3053         }
3054
3055       for (j = 0; j < 2; j++)
3056         if (opts[i][j])
3057           {
3058             memcpy (ptr, opts[i][j], len2[j]);
3059             ptr += len2[j];
3060             line_len += len2[j];
3061           }
3062     }
3063
3064   *ptr = '\0';
3065   gcc_assert (ret + len >= ptr);
3066
3067   return ret;
3068 }
3069
3070 /* Return true, if profiling code should be emitted before
3071    prologue. Otherwise it returns false.
3072    Note: For x86 with "hotfix" it is sorried.  */
3073 static bool
3074 ix86_profile_before_prologue (void)
3075 {
3076   return flag_fentry != 0;
3077 }
3078
3079 /* Function that is callable from the debugger to print the current
3080    options.  */
3081 void ATTRIBUTE_UNUSED
3082 ix86_debug_options (void)
3083 {
3084   char *opts = ix86_target_string (ix86_isa_flags, ix86_isa_flags2,
3085                                    target_flags, ix86_target_flags,
3086                                    ix86_arch_string,ix86_tune_string,
3087                                    ix86_fpmath, true);
3088
3089   if (opts)
3090     {
3091       fprintf (stderr, "%s\n\n", opts);
3092       free (opts);
3093     }
3094   else
3095     fputs ("<no options>\n\n", stderr);
3096
3097   return;
3098 }
3099
3100 /* Return true if T is one of the bytes we should avoid with
3101    -mmitigate-rop.  */
3102
3103 static bool
3104 ix86_rop_should_change_byte_p (int t)
3105 {
3106   return t == 0xc2 || t == 0xc3 || t == 0xca || t == 0xcb;
3107 }
3108
3109 static const char *stringop_alg_names[] = {
3110 #define DEF_ENUM
3111 #define DEF_ALG(alg, name) #name,
3112 #include "stringop.def"
3113 #undef DEF_ENUM
3114 #undef DEF_ALG
3115 };
3116
3117 /* Parse parameter string passed to -mmemcpy-strategy= or -mmemset-strategy=.
3118    The string is of the following form (or comma separated list of it):
3119
3120      strategy_alg:max_size:[align|noalign]
3121
3122    where the full size range for the strategy is either [0, max_size] or
3123    [min_size, max_size], in which min_size is the max_size + 1 of the
3124    preceding range.  The last size range must have max_size == -1.
3125
3126    Examples:
3127
3128     1.
3129        -mmemcpy-strategy=libcall:-1:noalign
3130
3131       this is equivalent to (for known size memcpy) -mstringop-strategy=libcall
3132
3133
3134    2.
3135       -mmemset-strategy=rep_8byte:16:noalign,vector_loop:2048:align,libcall:-1:noalign
3136
3137       This is to tell the compiler to use the following strategy for memset
3138       1) when the expected size is between [1, 16], use rep_8byte strategy;
3139       2) when the size is between [17, 2048], use vector_loop;
3140       3) when the size is > 2048, use libcall.  */
3141
3142 struct stringop_size_range
3143 {
3144   int max;
3145   stringop_alg alg;
3146   bool noalign;
3147 };
3148
3149 static void
3150 ix86_parse_stringop_strategy_string (char *strategy_str, bool is_memset)
3151 {
3152   const struct stringop_algs *default_algs;
3153   stringop_size_range input_ranges[MAX_STRINGOP_ALGS];
3154   char *curr_range_str, *next_range_str;
3155   const char *opt = is_memset ? "-mmemset_strategy=" : "-mmemcpy_strategy=";
3156   int i = 0, n = 0;
3157
3158   if (is_memset)
3159     default_algs = &ix86_cost->memset[TARGET_64BIT != 0];
3160   else
3161     default_algs = &ix86_cost->memcpy[TARGET_64BIT != 0];
3162
3163   curr_range_str = strategy_str;
3164
3165   do
3166     {
3167       int maxs;
3168       char alg_name[128];
3169       char align[16];
3170       next_range_str = strchr (curr_range_str, ',');
3171       if (next_range_str)
3172         *next_range_str++ = '\0';
3173
3174       if (sscanf (curr_range_str, "%20[^:]:%d:%10s", alg_name, &maxs,
3175                   align) != 3)
3176         {
3177           error ("wrong argument %qs to option %qs", curr_range_str, opt);
3178           return;
3179         }
3180
3181       if (n > 0 && (maxs < (input_ranges[n - 1].max + 1) && maxs != -1))
3182         {
3183           error ("size ranges of option %qs should be increasing", opt);
3184           return;
3185         }
3186
3187       for (i = 0; i < last_alg; i++)
3188         if (!strcmp (alg_name, stringop_alg_names[i]))
3189           break;
3190
3191       if (i == last_alg)
3192         {
3193           error ("wrong strategy name %qs specified for option %qs",
3194                  alg_name, opt);
3195
3196           auto_vec <const char *> candidates;
3197           for (i = 0; i < last_alg; i++)
3198             if ((stringop_alg) i != rep_prefix_8_byte || TARGET_64BIT)
3199               candidates.safe_push (stringop_alg_names[i]);
3200
3201           char *s;
3202           const char *hint
3203             = candidates_list_and_hint (alg_name, s, candidates);
3204           if (hint)
3205             inform (input_location,
3206                     "valid arguments to %qs are: %s; did you mean %qs?",
3207                     opt, s, hint);
3208           else
3209             inform (input_location, "valid arguments to %qs are: %s",
3210                     opt, s);
3211           XDELETEVEC (s);
3212           return;
3213         }
3214
3215       if ((stringop_alg) i == rep_prefix_8_byte
3216           && !TARGET_64BIT)
3217         {
3218           /* rep; movq isn't available in 32-bit code.  */
3219           error ("strategy name %qs specified for option %qs "
3220                  "not supported for 32-bit code", alg_name, opt);
3221           return;
3222         }
3223
3224       input_ranges[n].max = maxs;
3225       input_ranges[n].alg = (stringop_alg) i;
3226       if (!strcmp (align, "align"))
3227         input_ranges[n].noalign = false;
3228       else if (!strcmp (align, "noalign"))
3229         input_ranges[n].noalign = true;
3230       else
3231         {
3232           error ("unknown alignment %qs specified for option %qs", align, opt);
3233           return;
3234         }
3235       n++;
3236       curr_range_str = next_range_str;
3237     }
3238   while (curr_range_str);
3239
3240   if (input_ranges[n - 1].max != -1)
3241     {
3242       error ("the max value for the last size range should be -1"
3243              " for option %qs", opt);
3244       return;
3245     }
3246
3247   if (n > MAX_STRINGOP_ALGS)
3248     {
3249       error ("too many size ranges specified in option %qs", opt);
3250       return;
3251     }
3252
3253   /* Now override the default algs array.  */
3254   for (i = 0; i < n; i++)
3255     {
3256       *const_cast<int *>(&default_algs->size[i].max) = input_ranges[i].max;
3257       *const_cast<stringop_alg *>(&default_algs->size[i].alg)
3258           = input_ranges[i].alg;
3259       *const_cast<int *>(&default_algs->size[i].noalign)
3260           = input_ranges[i].noalign;
3261     }
3262 }
3263
3264 \f
3265 /* parse -mtune-ctrl= option. When DUMP is true,
3266    print the features that are explicitly set.  */
3267
3268 static void
3269 parse_mtune_ctrl_str (bool dump)
3270 {
3271   if (!ix86_tune_ctrl_string)
3272     return;
3273
3274   char *next_feature_string = NULL;
3275   char *curr_feature_string = xstrdup (ix86_tune_ctrl_string);
3276   char *orig = curr_feature_string;
3277   int i;
3278   do
3279     {
3280       bool clear = false;
3281
3282       next_feature_string = strchr (curr_feature_string, ',');
3283       if (next_feature_string)
3284         *next_feature_string++ = '\0';
3285       if (*curr_feature_string == '^')
3286         {
3287           curr_feature_string++;
3288           clear = true;
3289         }
3290       for (i = 0; i < X86_TUNE_LAST; i++)
3291         {
3292           if (!strcmp (curr_feature_string, ix86_tune_feature_names[i]))
3293             {
3294               ix86_tune_features[i] = !clear;
3295               if (dump)
3296                 fprintf (stderr, "Explicitly %s feature %s\n",
3297                          clear ? "clear" : "set", ix86_tune_feature_names[i]);
3298               break;
3299             }
3300         }
3301       if (i == X86_TUNE_LAST)
3302         error ("unknown parameter to option -mtune-ctrl: %s",
3303                clear ? curr_feature_string - 1 : curr_feature_string);
3304       curr_feature_string = next_feature_string;
3305     }
3306   while (curr_feature_string);
3307   free (orig);
3308 }
3309
3310 /* Helper function to set ix86_tune_features. IX86_TUNE is the
3311    processor type.  */
3312
3313 static void
3314 set_ix86_tune_features (enum processor_type ix86_tune, bool dump)
3315 {
3316   unsigned HOST_WIDE_INT ix86_tune_mask = HOST_WIDE_INT_1U << ix86_tune;
3317   int i;
3318
3319   for (i = 0; i < X86_TUNE_LAST; ++i)
3320     {
3321       if (ix86_tune_no_default)
3322         ix86_tune_features[i] = 0;
3323       else
3324         ix86_tune_features[i]
3325           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3326     }
3327
3328   if (dump)
3329     {
3330       fprintf (stderr, "List of x86 specific tuning parameter names:\n");
3331       for (i = 0; i < X86_TUNE_LAST; i++)
3332         fprintf (stderr, "%s : %s\n", ix86_tune_feature_names[i],
3333                  ix86_tune_features[i] ? "on" : "off");
3334     }
3335
3336   parse_mtune_ctrl_str (dump);
3337 }
3338
3339
3340 /* Default align_* from the processor table.  */
3341
3342 static void
3343 ix86_default_align (struct gcc_options *opts)
3344 {
3345   if (opts->x_align_loops == 0)
3346     {
3347       opts->x_align_loops = processor_target_table[ix86_tune].align_loop;
3348       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3349     }
3350   if (opts->x_align_jumps == 0)
3351     {
3352       opts->x_align_jumps = processor_target_table[ix86_tune].align_jump;
3353       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3354     }
3355   if (opts->x_align_functions == 0)
3356     {
3357       opts->x_align_functions = processor_target_table[ix86_tune].align_func;
3358     }
3359 }
3360
3361 /* Implement TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE hook.  */
3362
3363 static void
3364 ix86_override_options_after_change (void)
3365 {
3366   ix86_default_align (&global_options);
3367 }
3368
3369 /* Override various settings based on options.  If MAIN_ARGS_P, the
3370    options are from the command line, otherwise they are from
3371    attributes.  Return true if there's an error related to march
3372    option.  */
3373
3374 static bool
3375 ix86_option_override_internal (bool main_args_p,
3376                                struct gcc_options *opts,
3377                                struct gcc_options *opts_set)
3378 {
3379   int i;
3380   unsigned HOST_WIDE_INT ix86_arch_mask;
3381   const bool ix86_tune_specified = (opts->x_ix86_tune_string != NULL);
3382
3383   const wide_int_bitmask PTA_3DNOW (HOST_WIDE_INT_1U << 0);
3384   const wide_int_bitmask PTA_3DNOW_A (HOST_WIDE_INT_1U << 1);
3385   const wide_int_bitmask PTA_64BIT (HOST_WIDE_INT_1U << 2);
3386   const wide_int_bitmask PTA_ABM (HOST_WIDE_INT_1U << 3);
3387   const wide_int_bitmask PTA_AES (HOST_WIDE_INT_1U << 4);
3388   const wide_int_bitmask PTA_AVX (HOST_WIDE_INT_1U << 5);
3389   const wide_int_bitmask PTA_BMI (HOST_WIDE_INT_1U << 6);
3390   const wide_int_bitmask PTA_CX16 (HOST_WIDE_INT_1U << 7);
3391   const wide_int_bitmask PTA_F16C (HOST_WIDE_INT_1U << 8);
3392   const wide_int_bitmask PTA_FMA (HOST_WIDE_INT_1U << 9);
3393   const wide_int_bitmask PTA_FMA4 (HOST_WIDE_INT_1U << 10);
3394   const wide_int_bitmask PTA_FSGSBASE (HOST_WIDE_INT_1U << 11);
3395   const wide_int_bitmask PTA_LWP (HOST_WIDE_INT_1U << 12);
3396   const wide_int_bitmask PTA_LZCNT (HOST_WIDE_INT_1U << 13);
3397   const wide_int_bitmask PTA_MMX (HOST_WIDE_INT_1U << 14);
3398   const wide_int_bitmask PTA_MOVBE (HOST_WIDE_INT_1U << 15);
3399   const wide_int_bitmask PTA_NO_SAHF (HOST_WIDE_INT_1U << 16);
3400   const wide_int_bitmask PTA_PCLMUL (HOST_WIDE_INT_1U << 17);
3401   const wide_int_bitmask PTA_POPCNT (HOST_WIDE_INT_1U << 18);
3402   const wide_int_bitmask PTA_PREFETCH_SSE (HOST_WIDE_INT_1U << 19);
3403   const wide_int_bitmask PTA_RDRND (HOST_WIDE_INT_1U << 20);
3404   const wide_int_bitmask PTA_SSE (HOST_WIDE_INT_1U << 21);
3405   const wide_int_bitmask PTA_SSE2 (HOST_WIDE_INT_1U << 22);
3406   const wide_int_bitmask PTA_SSE3 (HOST_WIDE_INT_1U << 23);
3407   const wide_int_bitmask PTA_SSE4_1 (HOST_WIDE_INT_1U << 24);
3408   const wide_int_bitmask PTA_SSE4_2 (HOST_WIDE_INT_1U << 25);
3409   const wide_int_bitmask PTA_SSE4A (HOST_WIDE_INT_1U << 26);
3410   const wide_int_bitmask PTA_SSSE3 (HOST_WIDE_INT_1U << 27);
3411   const wide_int_bitmask PTA_TBM (HOST_WIDE_INT_1U << 28);
3412   const wide_int_bitmask PTA_XOP (HOST_WIDE_INT_1U << 29);
3413   const wide_int_bitmask PTA_AVX2 (HOST_WIDE_INT_1U << 30);
3414   const wide_int_bitmask PTA_BMI2 (HOST_WIDE_INT_1U << 31);
3415   const wide_int_bitmask PTA_RTM (HOST_WIDE_INT_1U << 32);
3416   const wide_int_bitmask PTA_HLE (HOST_WIDE_INT_1U << 33);
3417   const wide_int_bitmask PTA_PRFCHW (HOST_WIDE_INT_1U << 34);
3418   const wide_int_bitmask PTA_RDSEED (HOST_WIDE_INT_1U << 35);
3419   const wide_int_bitmask PTA_ADX (HOST_WIDE_INT_1U << 36);
3420   const wide_int_bitmask PTA_FXSR (HOST_WIDE_INT_1U << 37);
3421   const wide_int_bitmask PTA_XSAVE (HOST_WIDE_INT_1U << 38);
3422   const wide_int_bitmask PTA_XSAVEOPT (HOST_WIDE_INT_1U << 39);
3423   const wide_int_bitmask PTA_AVX512F (HOST_WIDE_INT_1U << 40);
3424   const wide_int_bitmask PTA_AVX512ER (HOST_WIDE_INT_1U << 41);
3425   const wide_int_bitmask PTA_AVX512PF (HOST_WIDE_INT_1U << 42);
3426   const wide_int_bitmask PTA_AVX512CD (HOST_WIDE_INT_1U << 43);
3427   const wide_int_bitmask PTA_MPX (HOST_WIDE_INT_1U << 44);
3428   const wide_int_bitmask PTA_SHA (HOST_WIDE_INT_1U << 45);
3429   const wide_int_bitmask PTA_PREFETCHWT1 (HOST_WIDE_INT_1U << 46);
3430   const wide_int_bitmask PTA_CLFLUSHOPT (HOST_WIDE_INT_1U << 47);
3431   const wide_int_bitmask PTA_XSAVEC (HOST_WIDE_INT_1U << 48);
3432   const wide_int_bitmask PTA_XSAVES (HOST_WIDE_INT_1U << 49);
3433   const wide_int_bitmask PTA_AVX512DQ (HOST_WIDE_INT_1U << 50);
3434   const wide_int_bitmask PTA_AVX512BW (HOST_WIDE_INT_1U << 51);
3435   const wide_int_bitmask PTA_AVX512VL (HOST_WIDE_INT_1U << 52);
3436   const wide_int_bitmask PTA_AVX512IFMA (HOST_WIDE_INT_1U << 53);
3437   const wide_int_bitmask PTA_AVX512VBMI (HOST_WIDE_INT_1U << 54);
3438   const wide_int_bitmask PTA_CLWB (HOST_WIDE_INT_1U << 55);
3439   const wide_int_bitmask PTA_MWAITX (HOST_WIDE_INT_1U << 56);
3440   const wide_int_bitmask PTA_CLZERO (HOST_WIDE_INT_1U << 57);
3441   const wide_int_bitmask PTA_NO_80387 (HOST_WIDE_INT_1U << 58);
3442   const wide_int_bitmask PTA_PKU (HOST_WIDE_INT_1U << 59);
3443   const wide_int_bitmask PTA_AVX5124VNNIW (HOST_WIDE_INT_1U << 60);
3444   const wide_int_bitmask PTA_AVX5124FMAPS (HOST_WIDE_INT_1U << 61);
3445   const wide_int_bitmask PTA_AVX512VPOPCNTDQ (HOST_WIDE_INT_1U << 62);
3446   const wide_int_bitmask PTA_SGX (HOST_WIDE_INT_1U << 63);
3447   const wide_int_bitmask PTA_AVX512VNNI (0, HOST_WIDE_INT_1U);
3448   const wide_int_bitmask PTA_GFNI (0, HOST_WIDE_INT_1U << 1);
3449   const wide_int_bitmask PTA_VAES (0, HOST_WIDE_INT_1U << 2);
3450   const wide_int_bitmask PTA_AVX512VBMI2 (0, HOST_WIDE_INT_1U << 3);
3451   const wide_int_bitmask PTA_VPCLMULQDQ (0, HOST_WIDE_INT_1U << 4);
3452   const wide_int_bitmask PTA_AVX512BITALG (0, HOST_WIDE_INT_1U << 5);
3453   const wide_int_bitmask PTA_RDPID (0, HOST_WIDE_INT_1U << 6);
3454   const wide_int_bitmask PTA_PCONFIG (0, HOST_WIDE_INT_1U << 7);
3455   const wide_int_bitmask PTA_WBNOINVD (0, HOST_WIDE_INT_1U << 8);
3456
3457   const wide_int_bitmask PTA_CORE2 = PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2
3458     | PTA_SSE3 | PTA_SSSE3 | PTA_CX16 | PTA_FXSR;
3459   const wide_int_bitmask PTA_NEHALEM = PTA_CORE2 | PTA_SSE4_1 | PTA_SSE4_2
3460     | PTA_POPCNT;
3461   const wide_int_bitmask PTA_WESTMERE = PTA_NEHALEM | PTA_AES | PTA_PCLMUL;
3462   const wide_int_bitmask PTA_SANDYBRIDGE = PTA_WESTMERE | PTA_AVX | PTA_XSAVE
3463     | PTA_XSAVEOPT;
3464   const wide_int_bitmask PTA_IVYBRIDGE = PTA_SANDYBRIDGE | PTA_FSGSBASE
3465     | PTA_RDRND | PTA_F16C;
3466   const wide_int_bitmask PTA_HASWELL = PTA_IVYBRIDGE | PTA_AVX2 | PTA_BMI
3467     | PTA_BMI2 | PTA_LZCNT | PTA_FMA | PTA_MOVBE | PTA_HLE;
3468   const wide_int_bitmask PTA_BROADWELL = PTA_HASWELL | PTA_ADX | PTA_PRFCHW
3469     | PTA_RDSEED;
3470   const wide_int_bitmask PTA_SKYLAKE = PTA_BROADWELL | PTA_CLFLUSHOPT
3471     | PTA_XSAVEC | PTA_XSAVES | PTA_SGX;
3472   const wide_int_bitmask PTA_SKYLAKE_AVX512 = PTA_SKYLAKE | PTA_AVX512F
3473     | PTA_AVX512CD | PTA_AVX512VL | PTA_AVX512BW | PTA_AVX512DQ | PTA_PKU
3474     | PTA_CLWB;
3475   const wide_int_bitmask PTA_CANNONLAKE = PTA_SKYLAKE | PTA_AVX512F
3476     | PTA_AVX512CD | PTA_AVX512VL | PTA_AVX512BW | PTA_AVX512DQ | PTA_PKU
3477     | PTA_AVX512VBMI | PTA_AVX512IFMA | PTA_SHA;
3478   const wide_int_bitmask PTA_ICELAKE_CLIENT = PTA_CANNONLAKE | PTA_AVX512VNNI
3479     | PTA_GFNI | PTA_VAES | PTA_AVX512VBMI2 | PTA_VPCLMULQDQ | PTA_AVX512BITALG
3480     | PTA_RDPID | PTA_CLWB;
3481   const wide_int_bitmask PTA_ICELAKE_SERVER = PTA_ICELAKE_CLIENT | PTA_PCONFIG
3482     | PTA_WBNOINVD;
3483   const wide_int_bitmask PTA_KNL = PTA_BROADWELL | PTA_AVX512PF | PTA_AVX512ER
3484     | PTA_AVX512F | PTA_AVX512CD;
3485   const wide_int_bitmask PTA_BONNELL = PTA_CORE2 | PTA_MOVBE;
3486   const wide_int_bitmask PTA_SILVERMONT = PTA_WESTMERE | PTA_MOVBE | PTA_RDRND;
3487   const wide_int_bitmask PTA_KNM = PTA_KNL | PTA_AVX5124VNNIW
3488     | PTA_AVX5124FMAPS | PTA_AVX512VPOPCNTDQ;
3489
3490   static struct pta
3491     {
3492       const char *const name;           /* processor name or nickname.  */
3493       const enum processor_type processor;
3494       const enum attr_cpu schedule;
3495       const wide_int_bitmask flags;
3496     }
3497   const processor_alias_table[] =
3498     {
3499       {"i386", PROCESSOR_I386, CPU_NONE, 0},
3500       {"i486", PROCESSOR_I486, CPU_NONE, 0},
3501       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
3502       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
3503       {"lakemont", PROCESSOR_LAKEMONT, CPU_PENTIUM, PTA_NO_80387},
3504       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
3505       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
3506       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
3507       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
3508       {"samuel-2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
3509       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3510         PTA_MMX | PTA_SSE | PTA_FXSR},
3511       {"nehemiah", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3512         PTA_MMX | PTA_SSE | PTA_FXSR},
3513       {"c7", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3514         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_FXSR},
3515       {"esther", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3516         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_FXSR},
3517       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
3518       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
3519       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_FXSR},
3520       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3521         PTA_MMX | PTA_SSE | PTA_FXSR},
3522       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3523         PTA_MMX | PTA_SSE | PTA_FXSR},
3524       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
3525         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_FXSR},
3526       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
3527         PTA_MMX |PTA_SSE | PTA_SSE2 | PTA_FXSR},
3528       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
3529         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_FXSR},
3530       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
3531         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_FXSR},
3532       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
3533         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3534         | PTA_CX16 | PTA_NO_SAHF | PTA_FXSR},
3535       {"core2", PROCESSOR_CORE2, CPU_CORE2, PTA_CORE2},
3536       {"nehalem", PROCESSOR_NEHALEM, CPU_NEHALEM, PTA_NEHALEM},
3537       {"corei7", PROCESSOR_NEHALEM, CPU_NEHALEM, PTA_NEHALEM},
3538       {"westmere", PROCESSOR_NEHALEM, CPU_NEHALEM, PTA_WESTMERE},
3539       {"sandybridge", PROCESSOR_SANDYBRIDGE, CPU_NEHALEM,
3540         PTA_SANDYBRIDGE},
3541       {"corei7-avx", PROCESSOR_SANDYBRIDGE, CPU_NEHALEM,
3542         PTA_SANDYBRIDGE},
3543       {"ivybridge", PROCESSOR_SANDYBRIDGE, CPU_NEHALEM,
3544         PTA_IVYBRIDGE},
3545       {"core-avx-i", PROCESSOR_SANDYBRIDGE, CPU_NEHALEM,
3546         PTA_IVYBRIDGE},
3547       {"haswell", PROCESSOR_HASWELL, CPU_HASWELL, PTA_HASWELL},
3548       {"core-avx2", PROCESSOR_HASWELL, CPU_HASWELL, PTA_HASWELL},
3549       {"broadwell", PROCESSOR_HASWELL, CPU_HASWELL, PTA_BROADWELL},
3550       {"skylake", PROCESSOR_SKYLAKE, CPU_HASWELL, PTA_SKYLAKE},
3551       {"skylake-avx512", PROCESSOR_SKYLAKE_AVX512, CPU_HASWELL,
3552         PTA_SKYLAKE_AVX512},
3553       {"cannonlake", PROCESSOR_CANNONLAKE, CPU_HASWELL, PTA_CANNONLAKE},
3554       {"icelake-client", PROCESSOR_ICELAKE_CLIENT, CPU_HASWELL,
3555         PTA_ICELAKE_CLIENT},
3556       {"icelake-server", PROCESSOR_ICELAKE_SERVER, CPU_HASWELL,
3557         PTA_ICELAKE_SERVER},
3558       {"bonnell", PROCESSOR_BONNELL, CPU_ATOM, PTA_BONNELL},
3559       {"atom", PROCESSOR_BONNELL, CPU_ATOM, PTA_BONNELL},
3560       {"silvermont", PROCESSOR_SILVERMONT, CPU_SLM, PTA_SILVERMONT},
3561       {"slm", PROCESSOR_SILVERMONT, CPU_SLM, PTA_SILVERMONT},
3562       {"knl", PROCESSOR_KNL, CPU_SLM, PTA_KNL},
3563       {"knm", PROCESSOR_KNM, CPU_SLM, PTA_KNM},
3564       {"intel", PROCESSOR_INTEL, CPU_SLM, PTA_NEHALEM},
3565       {"geode", PROCESSOR_GEODE, CPU_GEODE,
3566         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3567       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
3568       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
3569       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
3570       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
3571         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3572       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
3573         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3574       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
3575         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE | PTA_FXSR},
3576       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
3577         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE | PTA_FXSR},
3578       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
3579         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE | PTA_FXSR},
3580       {"x86-64", PROCESSOR_K8, CPU_K8,
3581         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF | PTA_FXSR},
3582       {"eden-x2", PROCESSOR_K8, CPU_K8,
3583         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_FXSR},
3584       {"nano", PROCESSOR_K8, CPU_K8,
3585         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3586         | PTA_SSSE3 | PTA_FXSR},
3587       {"nano-1000", PROCESSOR_K8, CPU_K8,
3588         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3589         | PTA_SSSE3 | PTA_FXSR},
3590       {"nano-2000", PROCESSOR_K8, CPU_K8,
3591         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3592         | PTA_SSSE3 | PTA_FXSR},
3593       {"nano-3000", PROCESSOR_K8, CPU_K8,
3594         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3595         | PTA_SSSE3 | PTA_SSE4_1 | PTA_FXSR},
3596       {"nano-x2", PROCESSOR_K8, CPU_K8,
3597         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3598         | PTA_SSSE3 | PTA_SSE4_1 | PTA_FXSR},
3599       {"eden-x4", PROCESSOR_K8, CPU_K8,
3600         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3601         | PTA_SSSE3 | PTA_SSE4_1 | PTA_FXSR},
3602       {"nano-x4", PROCESSOR_K8, CPU_K8,
3603         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3604         | PTA_SSSE3 | PTA_SSE4_1 | PTA_FXSR},
3605       {"k8", PROCESSOR_K8, CPU_K8,
3606         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3607         | PTA_SSE2 | PTA_NO_SAHF | PTA_FXSR},
3608       {"k8-sse3", PROCESSOR_K8, CPU_K8,
3609         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3610         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF | PTA_FXSR},
3611       {"opteron", PROCESSOR_K8, CPU_K8,
3612         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3613         | PTA_SSE2 | PTA_NO_SAHF | PTA_FXSR},
3614       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3615         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3616         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF | PTA_FXSR},
3617       {"athlon64", PROCESSOR_K8, CPU_K8,
3618         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3619         | PTA_SSE2 | PTA_NO_SAHF | PTA_FXSR},
3620       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3621         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3622         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF | PTA_FXSR},
3623       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3624         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3625         | PTA_SSE2 | PTA_NO_SAHF | PTA_FXSR},
3626       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3627         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE | PTA_SSE2
3628         | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_PRFCHW | PTA_FXSR},
3629       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3630         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE | PTA_SSE2
3631         | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_PRFCHW | PTA_FXSR},
3632       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3633         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3634         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3635         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3636         | PTA_XOP | PTA_LWP | PTA_PRFCHW | PTA_FXSR | PTA_XSAVE},
3637       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3638         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3639         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3640         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3641         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3642         | PTA_FMA | PTA_PRFCHW | PTA_FXSR | PTA_XSAVE},
3643       {"bdver3", PROCESSOR_BDVER3, CPU_BDVER3,
3644         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3645         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3646         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3647         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3648         | PTA_FMA | PTA_PRFCHW | PTA_FXSR | PTA_XSAVE 
3649         | PTA_XSAVEOPT | PTA_FSGSBASE},
3650       {"bdver4", PROCESSOR_BDVER4, CPU_BDVER4,
3651         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3652         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3653         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_AVX2 
3654         | PTA_FMA4 | PTA_XOP | PTA_LWP | PTA_BMI | PTA_BMI2 
3655         | PTA_TBM | PTA_F16C | PTA_FMA | PTA_PRFCHW | PTA_FXSR 
3656         | PTA_XSAVE | PTA_XSAVEOPT | PTA_FSGSBASE | PTA_RDRND
3657         | PTA_MOVBE | PTA_MWAITX},
3658       {"znver1", PROCESSOR_ZNVER1, CPU_ZNVER1,
3659         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3660         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3661         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_AVX2
3662         | PTA_BMI | PTA_BMI2 | PTA_F16C | PTA_FMA | PTA_PRFCHW
3663         | PTA_FXSR | PTA_XSAVE | PTA_XSAVEOPT | PTA_FSGSBASE
3664         | PTA_RDRND | PTA_MOVBE | PTA_MWAITX | PTA_ADX | PTA_RDSEED
3665         | PTA_CLZERO | PTA_CLFLUSHOPT | PTA_XSAVEC | PTA_XSAVES
3666         | PTA_SHA | PTA_LZCNT | PTA_POPCNT},
3667       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC,
3668         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3669         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16 | PTA_PRFCHW
3670         | PTA_FXSR | PTA_XSAVE},
3671       {"btver2", PROCESSOR_BTVER2, CPU_BTVER2,
3672         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3673         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16 | PTA_SSE4_1
3674         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3675         | PTA_BMI | PTA_F16C | PTA_MOVBE | PTA_PRFCHW
3676         | PTA_FXSR | PTA_XSAVE | PTA_XSAVEOPT},
3677
3678       {"generic", PROCESSOR_GENERIC, CPU_GENERIC,
3679         PTA_64BIT
3680         | PTA_HLE /* flags are only used for -march switch.  */ },
3681     };
3682
3683   /* -mrecip options.  */
3684   static struct
3685     {
3686       const char *string;           /* option name */
3687       unsigned int mask;            /* mask bits to set */
3688     }
3689   const recip_options[] =
3690     {
3691       { "all",       RECIP_MASK_ALL },
3692       { "none",      RECIP_MASK_NONE },
3693       { "div",       RECIP_MASK_DIV },
3694       { "sqrt",      RECIP_MASK_SQRT },
3695       { "vec-div",   RECIP_MASK_VEC_DIV },
3696       { "vec-sqrt",  RECIP_MASK_VEC_SQRT },
3697     };
3698
3699   int const pta_size = ARRAY_SIZE (processor_alias_table);
3700
3701   /* Turn off both OPTION_MASK_ABI_64 and OPTION_MASK_ABI_X32 if
3702      TARGET_64BIT_DEFAULT is true and TARGET_64BIT is false.  */
3703   if (TARGET_64BIT_DEFAULT && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
3704     opts->x_ix86_isa_flags &= ~(OPTION_MASK_ABI_64 | OPTION_MASK_ABI_X32);
3705 #ifdef TARGET_BI_ARCH
3706   else
3707     {
3708 #if TARGET_BI_ARCH == 1
3709       /* When TARGET_BI_ARCH == 1, by default, OPTION_MASK_ABI_64
3710          is on and OPTION_MASK_ABI_X32 is off.  We turn off
3711          OPTION_MASK_ABI_64 if OPTION_MASK_ABI_X32 is turned on by
3712          -mx32.  */
3713       if (TARGET_X32_P (opts->x_ix86_isa_flags))
3714         opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_64;
3715 #else
3716       /* When TARGET_BI_ARCH == 2, by default, OPTION_MASK_ABI_X32 is
3717          on and OPTION_MASK_ABI_64 is off.  We turn off
3718          OPTION_MASK_ABI_X32 if OPTION_MASK_ABI_64 is turned on by
3719          -m64 or OPTION_MASK_CODE16 is turned on by -m16.  */
3720       if (TARGET_LP64_P (opts->x_ix86_isa_flags)
3721           || TARGET_16BIT_P (opts->x_ix86_isa_flags))
3722         opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_X32;
3723 #endif
3724       if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
3725           && TARGET_IAMCU_P (opts->x_target_flags))
3726         sorry ("Intel MCU psABI isn%'t supported in %s mode",
3727                TARGET_X32_P (opts->x_ix86_isa_flags) ? "x32" : "64-bit");
3728     }
3729 #endif
3730
3731   if (TARGET_X32_P (opts->x_ix86_isa_flags))
3732     {
3733       /* Always turn on OPTION_MASK_ISA_64BIT and turn off
3734          OPTION_MASK_ABI_64 for TARGET_X32.  */
3735       opts->x_ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3736       opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_64;
3737     }
3738   else if (TARGET_16BIT_P (opts->x_ix86_isa_flags))
3739     opts->x_ix86_isa_flags &= ~(OPTION_MASK_ISA_64BIT
3740                                 | OPTION_MASK_ABI_X32
3741                                 | OPTION_MASK_ABI_64);
3742   else if (TARGET_LP64_P (opts->x_ix86_isa_flags))
3743     {
3744       /* Always turn on OPTION_MASK_ISA_64BIT and turn off
3745          OPTION_MASK_ABI_X32 for TARGET_LP64.  */
3746       opts->x_ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3747       opts->x_ix86_isa_flags &= ~OPTION_MASK_ABI_X32;
3748     }
3749
3750 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3751   SUBTARGET_OVERRIDE_OPTIONS;
3752 #endif
3753
3754 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3755   SUBSUBTARGET_OVERRIDE_OPTIONS;
3756 #endif
3757
3758   /* -fPIC is the default for x86_64.  */
3759   if (TARGET_MACHO && TARGET_64BIT_P (opts->x_ix86_isa_flags))
3760     opts->x_flag_pic = 2;
3761
3762   /* Need to check -mtune=generic first.  */
3763   if (opts->x_ix86_tune_string)
3764     {
3765       /* As special support for cross compilers we read -mtune=native
3766              as -mtune=generic.  With native compilers we won't see the
3767              -mtune=native, as it was changed by the driver.  */
3768       if (!strcmp (opts->x_ix86_tune_string, "native"))
3769         {
3770           opts->x_ix86_tune_string = "generic";
3771         }
3772       else if (!strcmp (opts->x_ix86_tune_string, "x86-64"))
3773         warning (OPT_Wdeprecated,
3774                  main_args_p
3775                  ? G_("%<-mtune=x86-64%> is deprecated; use %<-mtune=k8%> "
3776                       "or %<-mtune=generic%> instead as appropriate")
3777                  : G_("%<target(\"tune=x86-64\")%> is deprecated; use "
3778                       "%<target(\"tune=k8\")%> or %<target(\"tune=generic\")%>"
3779                       " instead as appropriate"));
3780     }
3781   else
3782     {
3783       if (opts->x_ix86_arch_string)
3784         opts->x_ix86_tune_string = opts->x_ix86_arch_string;
3785       if (!opts->x_ix86_tune_string)
3786         {
3787           opts->x_ix86_tune_string
3788             = processor_target_table[TARGET_CPU_DEFAULT].name;
3789           ix86_tune_defaulted = 1;
3790         }
3791
3792       /* opts->x_ix86_tune_string is set to opts->x_ix86_arch_string
3793          or defaulted.  We need to use a sensible tune option.  */
3794       if (!strcmp (opts->x_ix86_tune_string, "x86-64"))
3795         {
3796           opts->x_ix86_tune_string = "generic";
3797         }
3798     }
3799
3800   if (opts->x_ix86_stringop_alg == rep_prefix_8_byte
3801       && !TARGET_64BIT_P (opts->x_ix86_isa_flags))
3802     {
3803       /* rep; movq isn't available in 32-bit code.  */
3804       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3805       opts->x_ix86_stringop_alg = no_stringop;
3806     }
3807
3808   if (!opts->x_ix86_arch_string)
3809     opts->x_ix86_arch_string
3810       = TARGET_64BIT_P (opts->x_ix86_isa_flags)
3811         ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3812   else
3813     ix86_arch_specified = 1;
3814
3815   if (opts_set->x_ix86_pmode)
3816     {
3817       if ((TARGET_LP64_P (opts->x_ix86_isa_flags)
3818            && opts->x_ix86_pmode == PMODE_SI)
3819           || (!TARGET_64BIT_P (opts->x_ix86_isa_flags)
3820                && opts->x_ix86_pmode == PMODE_DI))
3821         error ("address mode %qs not supported in the %s bit mode",
3822                TARGET_64BIT_P (opts->x_ix86_isa_flags) ? "short" : "long",
3823                TARGET_64BIT_P (opts->x_ix86_isa_flags) ? "64" : "32");
3824     }
3825   else
3826     opts->x_ix86_pmode = TARGET_LP64_P (opts->x_ix86_isa_flags)
3827                          ? PMODE_DI : PMODE_SI;
3828
3829   if (!opts_set->x_ix86_abi)
3830     opts->x_ix86_abi = DEFAULT_ABI;
3831
3832   if (opts->x_ix86_abi == MS_ABI && TARGET_X32_P (opts->x_ix86_isa_flags))
3833     error ("-mabi=ms not supported with X32 ABI");
3834   gcc_assert (opts->x_ix86_abi == SYSV_ABI || opts->x_ix86_abi == MS_ABI);
3835
3836   /* For targets using ms ABI enable ms-extensions, if not
3837      explicit turned off.  For non-ms ABI we turn off this
3838      option.  */
3839   if (!opts_set->x_flag_ms_extensions)
3840     opts->x_flag_ms_extensions = (MS_ABI == DEFAULT_ABI);
3841
3842   if (opts_set->x_ix86_cmodel)
3843     {
3844       switch (opts->x_ix86_cmodel)
3845         {
3846         case CM_SMALL:
3847         case CM_SMALL_PIC:
3848           if (opts->x_flag_pic)
3849             opts->x_ix86_cmodel = CM_SMALL_PIC;
3850           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
3851             error ("code model %qs not supported in the %s bit mode",
3852                    "small", "32");
3853           break;
3854
3855         case CM_MEDIUM:
3856         case CM_MEDIUM_PIC:
3857           if (opts->x_flag_pic)
3858             opts->x_ix86_cmodel = CM_MEDIUM_PIC;
3859           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
3860             error ("code model %qs not supported in the %s bit mode",
3861                    "medium", "32");
3862           else if (TARGET_X32_P (opts->x_ix86_isa_flags))
3863             error ("code model %qs not supported in x32 mode",
3864                    "medium");
3865           break;
3866
3867         case CM_LARGE:
3868         case CM_LARGE_PIC:
3869           if (opts->x_flag_pic)
3870             opts->x_ix86_cmodel = CM_LARGE_PIC;
3871           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
3872             error ("code model %qs not supported in the %s bit mode",
3873                    "large", "32");
3874           else if (TARGET_X32_P (opts->x_ix86_isa_flags))
3875             error ("code model %qs not supported in x32 mode",
3876                    "large");
3877           break;
3878
3879         case CM_32:
3880           if (opts->x_flag_pic)
3881             error ("code model %s does not support PIC mode", "32");
3882           if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
3883             error ("code model %qs not supported in the %s bit mode",
3884                    "32", "64");
3885           break;
3886
3887         case CM_KERNEL:
3888           if (opts->x_flag_pic)
3889             {
3890               error ("code model %s does not support PIC mode", "kernel");
3891               opts->x_ix86_cmodel = CM_32;
3892             }
3893           if (!TARGET_64BIT_P (opts->x_ix86_isa_flags))
3894             error ("code model %qs not supported in the %s bit mode",
3895                    "kernel", "32");
3896           break;
3897
3898         default:
3899           gcc_unreachable ();
3900         }
3901     }
3902   else
3903     {
3904       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
3905          use of rip-relative addressing.  This eliminates fixups that
3906          would otherwise be needed if this object is to be placed in a
3907          DLL, and is essentially just as efficient as direct addressing.  */
3908       if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
3909           && (TARGET_RDOS || TARGET_PECOFF))
3910         opts->x_ix86_cmodel = CM_MEDIUM_PIC, opts->x_flag_pic = 1;
3911       else if (TARGET_64BIT_P (opts->x_ix86_isa_flags))
3912         opts->x_ix86_cmodel = opts->x_flag_pic ? CM_SMALL_PIC : CM_SMALL;
3913       else
3914         opts->x_ix86_cmodel = CM_32;
3915     }
3916   if (TARGET_MACHO && opts->x_ix86_asm_dialect == ASM_INTEL)
3917     {
3918       error ("-masm=intel not supported in this configuration");
3919       opts->x_ix86_asm_dialect = ASM_ATT;
3920     }
3921   if ((TARGET_64BIT_P (opts->x_ix86_isa_flags) != 0)
3922       != ((opts->x_ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
3923     sorry ("%i-bit mode not compiled in",
3924            (opts->x_ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
3925
3926   for (i = 0; i < pta_size; i++)
3927     if (! strcmp (opts->x_ix86_arch_string, processor_alias_table[i].name))
3928       {
3929         if (!strcmp (opts->x_ix86_arch_string, "generic"))
3930           {
3931             error (main_args_p
3932                    ? G_("%<generic%> CPU can be used only for %<-mtune=%> "
3933                         "switch")
3934                    : G_("%<generic%> CPU can be used only for "
3935                         "%<target(\"tune=\")%> attribute"));
3936             return false;
3937           }
3938         else if (!strcmp (opts->x_ix86_arch_string, "intel"))
3939           {
3940             error (main_args_p
3941                    ? G_("%<intel%> CPU can be used only for %<-mtune=%> "
3942                         "switch")
3943                    : G_("%<intel%> CPU can be used only for "
3944                         "%<target(\"tune=\")%> attribute"));
3945             return false;
3946           }
3947
3948         if (TARGET_64BIT_P (opts->x_ix86_isa_flags)
3949             && !((processor_alias_table[i].flags & PTA_64BIT) != 0))
3950           {
3951             error ("CPU you selected does not support x86-64 "
3952                    "instruction set");
3953             return false;
3954           }
3955
3956         ix86_schedule = processor_alias_table[i].schedule;
3957         ix86_arch = processor_alias_table[i].processor;
3958         /* Default cpu tuning to the architecture.  */
3959         ix86_tune = ix86_arch;
3960
3961         if (((processor_alias_table[i].flags & PTA_MMX) != 0)
3962             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
3963           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_MMX;
3964         if (((processor_alias_table[i].flags & PTA_3DNOW) != 0)
3965             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
3966           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
3967         if (((processor_alias_table[i].flags & PTA_3DNOW_A) != 0)
3968             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
3969           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
3970         if (((processor_alias_table[i].flags & PTA_SSE) != 0)
3971             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
3972           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE;
3973         if (((processor_alias_table[i].flags & PTA_SSE2) != 0)
3974             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
3975           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
3976         if (((processor_alias_table[i].flags & PTA_SSE3) != 0)
3977             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
3978           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
3979         if (((processor_alias_table[i].flags & PTA_SSSE3) != 0)
3980             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
3981           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
3982         if (((processor_alias_table[i].flags & PTA_SSE4_1) != 0)
3983             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
3984           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
3985         if (((processor_alias_table[i].flags & PTA_SSE4_2) != 0)
3986             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
3987           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
3988         if (((processor_alias_table[i].flags & PTA_AVX) != 0)
3989             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
3990           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX;
3991         if (((processor_alias_table[i].flags & PTA_AVX2) != 0)
3992             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX2))
3993           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX2;
3994         if (((processor_alias_table[i].flags & PTA_FMA) != 0)
3995             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
3996           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FMA;
3997         if (((processor_alias_table[i].flags & PTA_SSE4A) != 0)
3998             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
3999           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
4000         if (((processor_alias_table[i].flags & PTA_FMA4) != 0)
4001             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
4002           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
4003         if (((processor_alias_table[i].flags & PTA_XOP) != 0)
4004             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
4005           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XOP;
4006         if (((processor_alias_table[i].flags & PTA_LWP) != 0)
4007             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
4008           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_LWP;
4009         if (((processor_alias_table[i].flags & PTA_ABM) != 0)
4010             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
4011           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_ABM;
4012         if (((processor_alias_table[i].flags & PTA_BMI) != 0)
4013             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI))
4014           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_BMI;
4015         if (((processor_alias_table[i].flags & (PTA_LZCNT | PTA_ABM)) != 0)
4016             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_LZCNT))
4017           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_LZCNT;
4018         if (((processor_alias_table[i].flags & PTA_TBM) != 0)
4019             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_TBM))
4020           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_TBM;
4021         if (((processor_alias_table[i].flags & PTA_BMI2) != 0)
4022             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI2))
4023           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_BMI2;
4024         if (((processor_alias_table[i].flags & PTA_CX16) != 0)
4025             && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA_CX16))
4026           opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA_CX16;
4027         if (((processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)) != 0)
4028             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
4029           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
4030         if (!(TARGET_64BIT_P (opts->x_ix86_isa_flags)
4031             && ((processor_alias_table[i].flags & PTA_NO_SAHF) != 0))
4032             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
4033           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
4034         if (((processor_alias_table[i].flags & PTA_MOVBE) != 0)
4035             && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA_MOVBE))
4036           opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA_MOVBE;
4037         if (((processor_alias_table[i].flags & PTA_AES) != 0)
4038             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
4039           ix86_isa_flags |= OPTION_MASK_ISA_AES;
4040         if (((processor_alias_table[i].flags & PTA_SHA) != 0)
4041             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SHA))
4042           ix86_isa_flags |= OPTION_MASK_ISA_SHA;
4043         if (((processor_alias_table[i].flags & PTA_PCLMUL) != 0)
4044             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
4045           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
4046         if (((processor_alias_table[i].flags & PTA_FSGSBASE) != 0)
4047             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_FSGSBASE))
4048           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE;
4049         if (((processor_alias_table[i].flags & PTA_RDRND) != 0)
4050             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_RDRND))
4051           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_RDRND;
4052         if (((processor_alias_table[i].flags & PTA_F16C) != 0)
4053             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_F16C))
4054           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_F16C;
4055         if (((processor_alias_table[i].flags & PTA_RTM) != 0)
4056             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_RTM))
4057           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_RTM;
4058         if (((processor_alias_table[i].flags & PTA_HLE) != 0)
4059             && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA_HLE))
4060           opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA_HLE;
4061         if (((processor_alias_table[i].flags & PTA_PRFCHW) != 0)
4062             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_PRFCHW))
4063           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PRFCHW;
4064         if (((processor_alias_table[i].flags & PTA_RDSEED) != 0)
4065             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_RDSEED))
4066           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_RDSEED;
4067         if (((processor_alias_table[i].flags & PTA_ADX) != 0)
4068             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_ADX))
4069           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_ADX;
4070         if (((processor_alias_table[i].flags & PTA_FXSR) != 0)
4071             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_FXSR))
4072           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FXSR;
4073         if (((processor_alias_table[i].flags & PTA_XSAVE) != 0)
4074             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_XSAVE))
4075           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XSAVE;
4076         if (((processor_alias_table[i].flags & PTA_XSAVEOPT) != 0)
4077             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_XSAVEOPT))
4078           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XSAVEOPT;
4079         if (((processor_alias_table[i].flags & PTA_AVX512F) != 0)
4080             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512F))
4081           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512F;
4082         if (((processor_alias_table[i].flags & PTA_AVX512ER) != 0)
4083             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512ER))
4084           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512ER;
4085         if (((processor_alias_table[i].flags & PTA_AVX512PF) != 0)
4086             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512PF))
4087           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512PF;
4088         if (((processor_alias_table[i].flags & PTA_AVX512CD) != 0)
4089             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512CD))
4090           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512CD;
4091         if (((processor_alias_table[i].flags & PTA_PREFETCHWT1) != 0)
4092             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_PREFETCHWT1))
4093           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PREFETCHWT1;
4094         if (((processor_alias_table[i].flags & PTA_CLWB) != 0)
4095             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_CLWB))
4096           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_CLWB;
4097         if (((processor_alias_table[i].flags & PTA_CLFLUSHOPT) != 0)
4098             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_CLFLUSHOPT))
4099           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_CLFLUSHOPT;
4100         if (((processor_alias_table[i].flags & PTA_CLZERO) != 0)
4101             && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA_CLZERO))
4102           opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA_CLZERO;
4103         if (((processor_alias_table[i].flags & PTA_XSAVEC) != 0)
4104             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_XSAVEC))
4105           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XSAVEC;
4106         if (((processor_alias_table[i].flags & PTA_XSAVES) != 0)
4107             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_XSAVES))
4108           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XSAVES;
4109         if (((processor_alias_table[i].flags & PTA_AVX512DQ) != 0)
4110             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512DQ))
4111           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512DQ;
4112         if (((processor_alias_table[i].flags & PTA_AVX512BW) != 0)
4113             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512BW))
4114           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512BW;
4115         if (((processor_alias_table[i].flags & PTA_AVX512VL) != 0)
4116             && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512VL))
4117           opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX512VL;
4118         if (((processor_alias_table[i].flags & PTA_MPX) != 0)
4119             && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA_MPX))