Update gcc-50 to SVN version 225979 (gcc-5-branch)
[dragonfly.git] / contrib / gcc-5.0 / gcc / config / i386 / i386.c
1 /* Subroutines used for code generation on IA-32.
2    Copyright (C) 1988-2015 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 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "rtl.h"
25 #include "hash-set.h"
26 #include "machmode.h"
27 #include "vec.h"
28 #include "double-int.h"
29 #include "input.h"
30 #include "alias.h"
31 #include "symtab.h"
32 #include "wide-int.h"
33 #include "inchash.h"
34 #include "tree.h"
35 #include "fold-const.h"
36 #include "stringpool.h"
37 #include "attribs.h"
38 #include "calls.h"
39 #include "stor-layout.h"
40 #include "varasm.h"
41 #include "tm_p.h"
42 #include "regs.h"
43 #include "hard-reg-set.h"
44 #include "insn-config.h"
45 #include "conditions.h"
46 #include "output.h"
47 #include "insn-codes.h"
48 #include "insn-attr.h"
49 #include "flags.h"
50 #include "except.h"
51 #include "function.h"
52 #include "recog.h"
53 #include "hashtab.h"
54 #include "statistics.h"
55 #include "real.h"
56 #include "fixed-value.h"
57 #include "expmed.h"
58 #include "dojump.h"
59 #include "explow.h"
60 #include "emit-rtl.h"
61 #include "stmt.h"
62 #include "expr.h"
63 #include "optabs.h"
64 #include "diagnostic-core.h"
65 #include "toplev.h"
66 #include "predict.h"
67 #include "dominance.h"
68 #include "cfg.h"
69 #include "cfgrtl.h"
70 #include "cfganal.h"
71 #include "lcm.h"
72 #include "cfgbuild.h"
73 #include "cfgcleanup.h"
74 #include "basic-block.h"
75 #include "ggc.h"
76 #include "target.h"
77 #include "target-def.h"
78 #include "common/common-target.h"
79 #include "langhooks.h"
80 #include "reload.h"
81 #include "hash-map.h"
82 #include "is-a.h"
83 #include "plugin-api.h"
84 #include "ipa-ref.h"
85 #include "cgraph.h"
86 #include "hash-table.h"
87 #include "tree-ssa-alias.h"
88 #include "internal-fn.h"
89 #include "gimple-fold.h"
90 #include "tree-eh.h"
91 #include "gimple-expr.h"
92 #include "gimple.h"
93 #include "gimplify.h"
94 #include "cfgloop.h"
95 #include "dwarf2.h"
96 #include "df.h"
97 #include "tm-constrs.h"
98 #include "params.h"
99 #include "cselib.h"
100 #include "debug.h"
101 #include "sched-int.h"
102 #include "sbitmap.h"
103 #include "fibheap.h"
104 #include "opts.h"
105 #include "diagnostic.h"
106 #include "dumpfile.h"
107 #include "tree-pass.h"
108 #include "context.h"
109 #include "pass_manager.h"
110 #include "target-globals.h"
111 #include "tree-vectorizer.h"
112 #include "shrink-wrap.h"
113 #include "builtins.h"
114 #include "rtl-iter.h"
115 #include "tree-iterator.h"
116 #include "tree-chkp.h"
117 #include "rtl-chkp.h"
118
119 static rtx legitimize_dllimport_symbol (rtx, bool);
120 static rtx legitimize_pe_coff_extern_decl (rtx, bool);
121 static rtx legitimize_pe_coff_symbol (rtx, bool);
122
123 #ifndef CHECK_STACK_LIMIT
124 #define CHECK_STACK_LIMIT (-1)
125 #endif
126
127 /* Return index of given mode in mult and division cost tables.  */
128 #define MODE_INDEX(mode)                                        \
129   ((mode) == QImode ? 0                                         \
130    : (mode) == HImode ? 1                                       \
131    : (mode) == SImode ? 2                                       \
132    : (mode) == DImode ? 3                                       \
133    : 4)
134
135 /* Processor costs (relative to an add) */
136 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
137 #define COSTS_N_BYTES(N) ((N) * 2)
138
139 #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall, false}}}
140
141 static stringop_algs ix86_size_memcpy[2] = {
142   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}},
143   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}}};
144 static stringop_algs ix86_size_memset[2] = {
145   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}},
146   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}}};
147
148 const
149 struct processor_costs ix86_size_cost = {/* costs for tuning for size */
150   COSTS_N_BYTES (2),                    /* cost of an add instruction */
151   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
152   COSTS_N_BYTES (2),                    /* variable shift costs */
153   COSTS_N_BYTES (3),                    /* constant shift costs */
154   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
155    COSTS_N_BYTES (3),                   /*                               HI */
156    COSTS_N_BYTES (3),                   /*                               SI */
157    COSTS_N_BYTES (3),                   /*                               DI */
158    COSTS_N_BYTES (5)},                  /*                            other */
159   0,                                    /* cost of multiply per each bit set */
160   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
161    COSTS_N_BYTES (3),                   /*                          HI */
162    COSTS_N_BYTES (3),                   /*                          SI */
163    COSTS_N_BYTES (3),                   /*                          DI */
164    COSTS_N_BYTES (5)},                  /*                          other */
165   COSTS_N_BYTES (3),                    /* cost of movsx */
166   COSTS_N_BYTES (3),                    /* cost of movzx */
167   0,                                    /* "large" insn */
168   2,                                    /* MOVE_RATIO */
169   2,                                 /* cost for loading QImode using movzbl */
170   {2, 2, 2},                            /* cost of loading integer registers
171                                            in QImode, HImode and SImode.
172                                            Relative to reg-reg move (2).  */
173   {2, 2, 2},                            /* cost of storing integer registers */
174   2,                                    /* cost of reg,reg fld/fst */
175   {2, 2, 2},                            /* cost of loading fp registers
176                                            in SFmode, DFmode and XFmode */
177   {2, 2, 2},                            /* cost of storing fp registers
178                                            in SFmode, DFmode and XFmode */
179   3,                                    /* cost of moving MMX register */
180   {3, 3},                               /* cost of loading MMX registers
181                                            in SImode and DImode */
182   {3, 3},                               /* cost of storing MMX registers
183                                            in SImode and DImode */
184   3,                                    /* cost of moving SSE register */
185   {3, 3, 3},                            /* cost of loading SSE registers
186                                            in SImode, DImode and TImode */
187   {3, 3, 3},                            /* cost of storing SSE registers
188                                            in SImode, DImode and TImode */
189   3,                                    /* MMX or SSE register to integer */
190   0,                                    /* size of l1 cache  */
191   0,                                    /* size of l2 cache  */
192   0,                                    /* size of prefetch block */
193   0,                                    /* number of parallel prefetches */
194   2,                                    /* Branch cost */
195   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
196   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
197   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
198   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
199   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
200   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
201   ix86_size_memcpy,
202   ix86_size_memset,
203   1,                                    /* scalar_stmt_cost.  */
204   1,                                    /* scalar load_cost.  */
205   1,                                    /* scalar_store_cost.  */
206   1,                                    /* vec_stmt_cost.  */
207   1,                                    /* vec_to_scalar_cost.  */
208   1,                                    /* scalar_to_vec_cost.  */
209   1,                                    /* vec_align_load_cost.  */
210   1,                                    /* vec_unalign_load_cost.  */
211   1,                                    /* vec_store_cost.  */
212   1,                                    /* cond_taken_branch_cost.  */
213   1,                                    /* cond_not_taken_branch_cost.  */
214 };
215
216 /* Processor costs (relative to an add) */
217 static stringop_algs i386_memcpy[2] = {
218   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}},
219   DUMMY_STRINGOP_ALGS};
220 static stringop_algs i386_memset[2] = {
221   {rep_prefix_1_byte, {{-1, rep_prefix_1_byte, false}}},
222   DUMMY_STRINGOP_ALGS};
223
224 static const
225 struct processor_costs i386_cost = {    /* 386 specific costs */
226   COSTS_N_INSNS (1),                    /* cost of an add instruction */
227   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
228   COSTS_N_INSNS (3),                    /* variable shift costs */
229   COSTS_N_INSNS (2),                    /* constant shift costs */
230   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
231    COSTS_N_INSNS (6),                   /*                               HI */
232    COSTS_N_INSNS (6),                   /*                               SI */
233    COSTS_N_INSNS (6),                   /*                               DI */
234    COSTS_N_INSNS (6)},                  /*                            other */
235   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
236   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
237    COSTS_N_INSNS (23),                  /*                          HI */
238    COSTS_N_INSNS (23),                  /*                          SI */
239    COSTS_N_INSNS (23),                  /*                          DI */
240    COSTS_N_INSNS (23)},                 /*                          other */
241   COSTS_N_INSNS (3),                    /* cost of movsx */
242   COSTS_N_INSNS (2),                    /* cost of movzx */
243   15,                                   /* "large" insn */
244   3,                                    /* MOVE_RATIO */
245   4,                                 /* cost for loading QImode using movzbl */
246   {2, 4, 2},                            /* cost of loading integer registers
247                                            in QImode, HImode and SImode.
248                                            Relative to reg-reg move (2).  */
249   {2, 4, 2},                            /* cost of storing integer registers */
250   2,                                    /* cost of reg,reg fld/fst */
251   {8, 8, 8},                            /* cost of loading fp registers
252                                            in SFmode, DFmode and XFmode */
253   {8, 8, 8},                            /* cost of storing fp registers
254                                            in SFmode, DFmode and XFmode */
255   2,                                    /* cost of moving MMX register */
256   {4, 8},                               /* cost of loading MMX registers
257                                            in SImode and DImode */
258   {4, 8},                               /* cost of storing MMX registers
259                                            in SImode and DImode */
260   2,                                    /* cost of moving SSE register */
261   {4, 8, 16},                           /* cost of loading SSE registers
262                                            in SImode, DImode and TImode */
263   {4, 8, 16},                           /* cost of storing SSE registers
264                                            in SImode, DImode and TImode */
265   3,                                    /* MMX or SSE register to integer */
266   0,                                    /* size of l1 cache  */
267   0,                                    /* size of l2 cache  */
268   0,                                    /* size of prefetch block */
269   0,                                    /* number of parallel prefetches */
270   1,                                    /* Branch cost */
271   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
272   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
273   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
274   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
275   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
276   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
277   i386_memcpy,
278   i386_memset,
279   1,                                    /* scalar_stmt_cost.  */
280   1,                                    /* scalar load_cost.  */
281   1,                                    /* scalar_store_cost.  */
282   1,                                    /* vec_stmt_cost.  */
283   1,                                    /* vec_to_scalar_cost.  */
284   1,                                    /* scalar_to_vec_cost.  */
285   1,                                    /* vec_align_load_cost.  */
286   2,                                    /* vec_unalign_load_cost.  */
287   1,                                    /* vec_store_cost.  */
288   3,                                    /* cond_taken_branch_cost.  */
289   1,                                    /* cond_not_taken_branch_cost.  */
290 };
291
292 static stringop_algs i486_memcpy[2] = {
293   {rep_prefix_4_byte, {{-1, rep_prefix_4_byte, false}}},
294   DUMMY_STRINGOP_ALGS};
295 static stringop_algs i486_memset[2] = {
296   {rep_prefix_4_byte, {{-1, rep_prefix_4_byte, false}}},
297   DUMMY_STRINGOP_ALGS};
298
299 static const
300 struct processor_costs i486_cost = {    /* 486 specific costs */
301   COSTS_N_INSNS (1),                    /* cost of an add instruction */
302   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
303   COSTS_N_INSNS (3),                    /* variable shift costs */
304   COSTS_N_INSNS (2),                    /* constant shift costs */
305   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
306    COSTS_N_INSNS (12),                  /*                               HI */
307    COSTS_N_INSNS (12),                  /*                               SI */
308    COSTS_N_INSNS (12),                  /*                               DI */
309    COSTS_N_INSNS (12)},                 /*                            other */
310   1,                                    /* cost of multiply per each bit set */
311   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
312    COSTS_N_INSNS (40),                  /*                          HI */
313    COSTS_N_INSNS (40),                  /*                          SI */
314    COSTS_N_INSNS (40),                  /*                          DI */
315    COSTS_N_INSNS (40)},                 /*                          other */
316   COSTS_N_INSNS (3),                    /* cost of movsx */
317   COSTS_N_INSNS (2),                    /* cost of movzx */
318   15,                                   /* "large" insn */
319   3,                                    /* MOVE_RATIO */
320   4,                                 /* cost for loading QImode using movzbl */
321   {2, 4, 2},                            /* cost of loading integer registers
322                                            in QImode, HImode and SImode.
323                                            Relative to reg-reg move (2).  */
324   {2, 4, 2},                            /* cost of storing integer registers */
325   2,                                    /* cost of reg,reg fld/fst */
326   {8, 8, 8},                            /* cost of loading fp registers
327                                            in SFmode, DFmode and XFmode */
328   {8, 8, 8},                            /* cost of storing fp registers
329                                            in SFmode, DFmode and XFmode */
330   2,                                    /* cost of moving MMX register */
331   {4, 8},                               /* cost of loading MMX registers
332                                            in SImode and DImode */
333   {4, 8},                               /* cost of storing MMX registers
334                                            in SImode and DImode */
335   2,                                    /* cost of moving SSE register */
336   {4, 8, 16},                           /* cost of loading SSE registers
337                                            in SImode, DImode and TImode */
338   {4, 8, 16},                           /* cost of storing SSE registers
339                                            in SImode, DImode and TImode */
340   3,                                    /* MMX or SSE register to integer */
341   4,                                    /* size of l1 cache.  486 has 8kB cache
342                                            shared for code and data, so 4kB is
343                                            not really precise.  */
344   4,                                    /* size of l2 cache  */
345   0,                                    /* size of prefetch block */
346   0,                                    /* number of parallel prefetches */
347   1,                                    /* Branch cost */
348   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
349   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
350   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
351   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
352   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
353   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
354   i486_memcpy,
355   i486_memset,
356   1,                                    /* scalar_stmt_cost.  */
357   1,                                    /* scalar load_cost.  */
358   1,                                    /* scalar_store_cost.  */
359   1,                                    /* vec_stmt_cost.  */
360   1,                                    /* vec_to_scalar_cost.  */
361   1,                                    /* scalar_to_vec_cost.  */
362   1,                                    /* vec_align_load_cost.  */
363   2,                                    /* vec_unalign_load_cost.  */
364   1,                                    /* vec_store_cost.  */
365   3,                                    /* cond_taken_branch_cost.  */
366   1,                                    /* cond_not_taken_branch_cost.  */
367 };
368
369 static stringop_algs pentium_memcpy[2] = {
370   {libcall, {{256, rep_prefix_4_byte, false}, {-1, libcall, false}}},
371   DUMMY_STRINGOP_ALGS};
372 static stringop_algs pentium_memset[2] = {
373   {libcall, {{-1, rep_prefix_4_byte, false}}},
374   DUMMY_STRINGOP_ALGS};
375
376 static const
377 struct processor_costs pentium_cost = {
378   COSTS_N_INSNS (1),                    /* cost of an add instruction */
379   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
380   COSTS_N_INSNS (4),                    /* variable shift costs */
381   COSTS_N_INSNS (1),                    /* constant shift costs */
382   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
383    COSTS_N_INSNS (11),                  /*                               HI */
384    COSTS_N_INSNS (11),                  /*                               SI */
385    COSTS_N_INSNS (11),                  /*                               DI */
386    COSTS_N_INSNS (11)},                 /*                            other */
387   0,                                    /* cost of multiply per each bit set */
388   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
389    COSTS_N_INSNS (25),                  /*                          HI */
390    COSTS_N_INSNS (25),                  /*                          SI */
391    COSTS_N_INSNS (25),                  /*                          DI */
392    COSTS_N_INSNS (25)},                 /*                          other */
393   COSTS_N_INSNS (3),                    /* cost of movsx */
394   COSTS_N_INSNS (2),                    /* cost of movzx */
395   8,                                    /* "large" insn */
396   6,                                    /* MOVE_RATIO */
397   6,                                 /* cost for loading QImode using movzbl */
398   {2, 4, 2},                            /* cost of loading integer registers
399                                            in QImode, HImode and SImode.
400                                            Relative to reg-reg move (2).  */
401   {2, 4, 2},                            /* cost of storing integer registers */
402   2,                                    /* cost of reg,reg fld/fst */
403   {2, 2, 6},                            /* cost of loading fp registers
404                                            in SFmode, DFmode and XFmode */
405   {4, 4, 6},                            /* cost of storing fp registers
406                                            in SFmode, DFmode and XFmode */
407   8,                                    /* cost of moving MMX register */
408   {8, 8},                               /* cost of loading MMX registers
409                                            in SImode and DImode */
410   {8, 8},                               /* cost of storing MMX registers
411                                            in SImode and DImode */
412   2,                                    /* cost of moving SSE register */
413   {4, 8, 16},                           /* cost of loading SSE registers
414                                            in SImode, DImode and TImode */
415   {4, 8, 16},                           /* cost of storing SSE registers
416                                            in SImode, DImode and TImode */
417   3,                                    /* MMX or SSE register to integer */
418   8,                                    /* size of l1 cache.  */
419   8,                                    /* size of l2 cache  */
420   0,                                    /* size of prefetch block */
421   0,                                    /* number of parallel prefetches */
422   2,                                    /* Branch cost */
423   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
424   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
425   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
426   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
427   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
428   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
429   pentium_memcpy,
430   pentium_memset,
431   1,                                    /* scalar_stmt_cost.  */
432   1,                                    /* scalar load_cost.  */
433   1,                                    /* scalar_store_cost.  */
434   1,                                    /* vec_stmt_cost.  */
435   1,                                    /* vec_to_scalar_cost.  */
436   1,                                    /* scalar_to_vec_cost.  */
437   1,                                    /* vec_align_load_cost.  */
438   2,                                    /* vec_unalign_load_cost.  */
439   1,                                    /* vec_store_cost.  */
440   3,                                    /* cond_taken_branch_cost.  */
441   1,                                    /* cond_not_taken_branch_cost.  */
442 };
443
444 /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes
445    (we ensure the alignment).  For small blocks inline loop is still a
446    noticeable win, for bigger blocks either rep movsl or rep movsb is
447    way to go.  Rep movsb has apparently more expensive startup time in CPU,
448    but after 4K the difference is down in the noise.  */
449 static stringop_algs pentiumpro_memcpy[2] = {
450   {rep_prefix_4_byte, {{128, loop, false}, {1024, unrolled_loop, false},
451                        {8192, rep_prefix_4_byte, false},
452                        {-1, rep_prefix_1_byte, false}}},
453   DUMMY_STRINGOP_ALGS};
454 static stringop_algs pentiumpro_memset[2] = {
455   {rep_prefix_4_byte, {{1024, unrolled_loop, false},
456                        {8192, rep_prefix_4_byte, false},
457                        {-1, libcall, false}}},
458   DUMMY_STRINGOP_ALGS};
459 static const
460 struct processor_costs pentiumpro_cost = {
461   COSTS_N_INSNS (1),                    /* cost of an add instruction */
462   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
463   COSTS_N_INSNS (1),                    /* variable shift costs */
464   COSTS_N_INSNS (1),                    /* constant shift costs */
465   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
466    COSTS_N_INSNS (4),                   /*                               HI */
467    COSTS_N_INSNS (4),                   /*                               SI */
468    COSTS_N_INSNS (4),                   /*                               DI */
469    COSTS_N_INSNS (4)},                  /*                            other */
470   0,                                    /* cost of multiply per each bit set */
471   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
472    COSTS_N_INSNS (17),                  /*                          HI */
473    COSTS_N_INSNS (17),                  /*                          SI */
474    COSTS_N_INSNS (17),                  /*                          DI */
475    COSTS_N_INSNS (17)},                 /*                          other */
476   COSTS_N_INSNS (1),                    /* cost of movsx */
477   COSTS_N_INSNS (1),                    /* cost of movzx */
478   8,                                    /* "large" insn */
479   6,                                    /* MOVE_RATIO */
480   2,                                 /* cost for loading QImode using movzbl */
481   {4, 4, 4},                            /* cost of loading integer registers
482                                            in QImode, HImode and SImode.
483                                            Relative to reg-reg move (2).  */
484   {2, 2, 2},                            /* cost of storing integer registers */
485   2,                                    /* cost of reg,reg fld/fst */
486   {2, 2, 6},                            /* cost of loading fp registers
487                                            in SFmode, DFmode and XFmode */
488   {4, 4, 6},                            /* cost of storing fp registers
489                                            in SFmode, DFmode and XFmode */
490   2,                                    /* cost of moving MMX register */
491   {2, 2},                               /* cost of loading MMX registers
492                                            in SImode and DImode */
493   {2, 2},                               /* cost of storing MMX registers
494                                            in SImode and DImode */
495   2,                                    /* cost of moving SSE register */
496   {2, 2, 8},                            /* cost of loading SSE registers
497                                            in SImode, DImode and TImode */
498   {2, 2, 8},                            /* cost of storing SSE registers
499                                            in SImode, DImode and TImode */
500   3,                                    /* MMX or SSE register to integer */
501   8,                                    /* size of l1 cache.  */
502   256,                                  /* size of l2 cache  */
503   32,                                   /* size of prefetch block */
504   6,                                    /* number of parallel prefetches */
505   2,                                    /* Branch cost */
506   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
507   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
508   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
509   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
510   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
511   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
512   pentiumpro_memcpy,
513   pentiumpro_memset,
514   1,                                    /* scalar_stmt_cost.  */
515   1,                                    /* scalar load_cost.  */
516   1,                                    /* scalar_store_cost.  */
517   1,                                    /* vec_stmt_cost.  */
518   1,                                    /* vec_to_scalar_cost.  */
519   1,                                    /* scalar_to_vec_cost.  */
520   1,                                    /* vec_align_load_cost.  */
521   2,                                    /* vec_unalign_load_cost.  */
522   1,                                    /* vec_store_cost.  */
523   3,                                    /* cond_taken_branch_cost.  */
524   1,                                    /* cond_not_taken_branch_cost.  */
525 };
526
527 static stringop_algs geode_memcpy[2] = {
528   {libcall, {{256, rep_prefix_4_byte, false}, {-1, libcall, false}}},
529   DUMMY_STRINGOP_ALGS};
530 static stringop_algs geode_memset[2] = {
531   {libcall, {{256, rep_prefix_4_byte, false}, {-1, libcall, false}}},
532   DUMMY_STRINGOP_ALGS};
533 static const
534 struct processor_costs geode_cost = {
535   COSTS_N_INSNS (1),                    /* cost of an add instruction */
536   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
537   COSTS_N_INSNS (2),                    /* variable shift costs */
538   COSTS_N_INSNS (1),                    /* constant shift costs */
539   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
540    COSTS_N_INSNS (4),                   /*                               HI */
541    COSTS_N_INSNS (7),                   /*                               SI */
542    COSTS_N_INSNS (7),                   /*                               DI */
543    COSTS_N_INSNS (7)},                  /*                            other */
544   0,                                    /* cost of multiply per each bit set */
545   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
546    COSTS_N_INSNS (23),                  /*                          HI */
547    COSTS_N_INSNS (39),                  /*                          SI */
548    COSTS_N_INSNS (39),                  /*                          DI */
549    COSTS_N_INSNS (39)},                 /*                          other */
550   COSTS_N_INSNS (1),                    /* cost of movsx */
551   COSTS_N_INSNS (1),                    /* cost of movzx */
552   8,                                    /* "large" insn */
553   4,                                    /* MOVE_RATIO */
554   1,                                 /* cost for loading QImode using movzbl */
555   {1, 1, 1},                            /* cost of loading integer registers
556                                            in QImode, HImode and SImode.
557                                            Relative to reg-reg move (2).  */
558   {1, 1, 1},                            /* cost of storing integer registers */
559   1,                                    /* cost of reg,reg fld/fst */
560   {1, 1, 1},                            /* cost of loading fp registers
561                                            in SFmode, DFmode and XFmode */
562   {4, 6, 6},                            /* cost of storing fp registers
563                                            in SFmode, DFmode and XFmode */
564
565   1,                                    /* cost of moving MMX register */
566   {1, 1},                               /* cost of loading MMX registers
567                                            in SImode and DImode */
568   {1, 1},                               /* cost of storing MMX registers
569                                            in SImode and DImode */
570   1,                                    /* cost of moving SSE register */
571   {1, 1, 1},                            /* cost of loading SSE registers
572                                            in SImode, DImode and TImode */
573   {1, 1, 1},                            /* cost of storing SSE registers
574                                            in SImode, DImode and TImode */
575   1,                                    /* MMX or SSE register to integer */
576   64,                                   /* size of l1 cache.  */
577   128,                                  /* size of l2 cache.  */
578   32,                                   /* size of prefetch block */
579   1,                                    /* number of parallel prefetches */
580   1,                                    /* Branch cost */
581   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
582   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
583   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
584   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
585   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
586   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
587   geode_memcpy,
588   geode_memset,
589   1,                                    /* scalar_stmt_cost.  */
590   1,                                    /* scalar load_cost.  */
591   1,                                    /* scalar_store_cost.  */
592   1,                                    /* vec_stmt_cost.  */
593   1,                                    /* vec_to_scalar_cost.  */
594   1,                                    /* scalar_to_vec_cost.  */
595   1,                                    /* vec_align_load_cost.  */
596   2,                                    /* vec_unalign_load_cost.  */
597   1,                                    /* vec_store_cost.  */
598   3,                                    /* cond_taken_branch_cost.  */
599   1,                                    /* cond_not_taken_branch_cost.  */
600 };
601
602 static stringop_algs k6_memcpy[2] = {
603   {libcall, {{256, rep_prefix_4_byte, false}, {-1, libcall, false}}},
604   DUMMY_STRINGOP_ALGS};
605 static stringop_algs k6_memset[2] = {
606   {libcall, {{256, rep_prefix_4_byte, false}, {-1, libcall, false}}},
607   DUMMY_STRINGOP_ALGS};
608 static const
609 struct processor_costs k6_cost = {
610   COSTS_N_INSNS (1),                    /* cost of an add instruction */
611   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
612   COSTS_N_INSNS (1),                    /* variable shift costs */
613   COSTS_N_INSNS (1),                    /* constant shift costs */
614   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
615    COSTS_N_INSNS (3),                   /*                               HI */
616    COSTS_N_INSNS (3),                   /*                               SI */
617    COSTS_N_INSNS (3),                   /*                               DI */
618    COSTS_N_INSNS (3)},                  /*                            other */
619   0,                                    /* cost of multiply per each bit set */
620   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
621    COSTS_N_INSNS (18),                  /*                          HI */
622    COSTS_N_INSNS (18),                  /*                          SI */
623    COSTS_N_INSNS (18),                  /*                          DI */
624    COSTS_N_INSNS (18)},                 /*                          other */
625   COSTS_N_INSNS (2),                    /* cost of movsx */
626   COSTS_N_INSNS (2),                    /* cost of movzx */
627   8,                                    /* "large" insn */
628   4,                                    /* MOVE_RATIO */
629   3,                                 /* cost for loading QImode using movzbl */
630   {4, 5, 4},                            /* cost of loading integer registers
631                                            in QImode, HImode and SImode.
632                                            Relative to reg-reg move (2).  */
633   {2, 3, 2},                            /* cost of storing integer registers */
634   4,                                    /* cost of reg,reg fld/fst */
635   {6, 6, 6},                            /* cost of loading fp registers
636                                            in SFmode, DFmode and XFmode */
637   {4, 4, 4},                            /* cost of storing fp registers
638                                            in SFmode, DFmode and XFmode */
639   2,                                    /* cost of moving MMX register */
640   {2, 2},                               /* cost of loading MMX registers
641                                            in SImode and DImode */
642   {2, 2},                               /* cost of storing MMX registers
643                                            in SImode and DImode */
644   2,                                    /* cost of moving SSE register */
645   {2, 2, 8},                            /* cost of loading SSE registers
646                                            in SImode, DImode and TImode */
647   {2, 2, 8},                            /* cost of storing SSE registers
648                                            in SImode, DImode and TImode */
649   6,                                    /* MMX or SSE register to integer */
650   32,                                   /* size of l1 cache.  */
651   32,                                   /* size of l2 cache.  Some models
652                                            have integrated l2 cache, but
653                                            optimizing for k6 is not important
654                                            enough to worry about that.  */
655   32,                                   /* size of prefetch block */
656   1,                                    /* number of parallel prefetches */
657   1,                                    /* Branch cost */
658   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
659   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
660   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
661   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
662   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
663   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
664   k6_memcpy,
665   k6_memset,
666   1,                                    /* scalar_stmt_cost.  */
667   1,                                    /* scalar load_cost.  */
668   1,                                    /* scalar_store_cost.  */
669   1,                                    /* vec_stmt_cost.  */
670   1,                                    /* vec_to_scalar_cost.  */
671   1,                                    /* scalar_to_vec_cost.  */
672   1,                                    /* vec_align_load_cost.  */
673   2,                                    /* vec_unalign_load_cost.  */
674   1,                                    /* vec_store_cost.  */
675   3,                                    /* cond_taken_branch_cost.  */
676   1,                                    /* cond_not_taken_branch_cost.  */
677 };
678
679 /* For some reason, Athlon deals better with REP prefix (relative to loops)
680    compared to K8. Alignment becomes important after 8 bytes for memcpy and
681    128 bytes for memset.  */
682 static stringop_algs athlon_memcpy[2] = {
683   {libcall, {{2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
684   DUMMY_STRINGOP_ALGS};
685 static stringop_algs athlon_memset[2] = {
686   {libcall, {{2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
687   DUMMY_STRINGOP_ALGS};
688 static const
689 struct processor_costs athlon_cost = {
690   COSTS_N_INSNS (1),                    /* cost of an add instruction */
691   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
692   COSTS_N_INSNS (1),                    /* variable shift costs */
693   COSTS_N_INSNS (1),                    /* constant shift costs */
694   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
695    COSTS_N_INSNS (5),                   /*                               HI */
696    COSTS_N_INSNS (5),                   /*                               SI */
697    COSTS_N_INSNS (5),                   /*                               DI */
698    COSTS_N_INSNS (5)},                  /*                            other */
699   0,                                    /* cost of multiply per each bit set */
700   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
701    COSTS_N_INSNS (26),                  /*                          HI */
702    COSTS_N_INSNS (42),                  /*                          SI */
703    COSTS_N_INSNS (74),                  /*                          DI */
704    COSTS_N_INSNS (74)},                 /*                          other */
705   COSTS_N_INSNS (1),                    /* cost of movsx */
706   COSTS_N_INSNS (1),                    /* cost of movzx */
707   8,                                    /* "large" insn */
708   9,                                    /* MOVE_RATIO */
709   4,                                 /* cost for loading QImode using movzbl */
710   {3, 4, 3},                            /* cost of loading integer registers
711                                            in QImode, HImode and SImode.
712                                            Relative to reg-reg move (2).  */
713   {3, 4, 3},                            /* cost of storing integer registers */
714   4,                                    /* cost of reg,reg fld/fst */
715   {4, 4, 12},                           /* cost of loading fp registers
716                                            in SFmode, DFmode and XFmode */
717   {6, 6, 8},                            /* cost of storing fp registers
718                                            in SFmode, DFmode and XFmode */
719   2,                                    /* cost of moving MMX register */
720   {4, 4},                               /* cost of loading MMX registers
721                                            in SImode and DImode */
722   {4, 4},                               /* cost of storing MMX registers
723                                            in SImode and DImode */
724   2,                                    /* cost of moving SSE register */
725   {4, 4, 6},                            /* cost of loading SSE registers
726                                            in SImode, DImode and TImode */
727   {4, 4, 5},                            /* cost of storing SSE registers
728                                            in SImode, DImode and TImode */
729   5,                                    /* MMX or SSE register to integer */
730   64,                                   /* size of l1 cache.  */
731   256,                                  /* size of l2 cache.  */
732   64,                                   /* size of prefetch block */
733   6,                                    /* number of parallel prefetches */
734   5,                                    /* Branch cost */
735   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
736   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
737   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
738   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
739   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
740   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
741   athlon_memcpy,
742   athlon_memset,
743   1,                                    /* scalar_stmt_cost.  */
744   1,                                    /* scalar load_cost.  */
745   1,                                    /* scalar_store_cost.  */
746   1,                                    /* vec_stmt_cost.  */
747   1,                                    /* vec_to_scalar_cost.  */
748   1,                                    /* scalar_to_vec_cost.  */
749   1,                                    /* vec_align_load_cost.  */
750   2,                                    /* vec_unalign_load_cost.  */
751   1,                                    /* vec_store_cost.  */
752   3,                                    /* cond_taken_branch_cost.  */
753   1,                                    /* cond_not_taken_branch_cost.  */
754 };
755
756 /* K8 has optimized REP instruction for medium sized blocks, but for very
757    small blocks it is better to use loop. For large blocks, libcall can
758    do nontemporary accesses and beat inline considerably.  */
759 static stringop_algs k8_memcpy[2] = {
760   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
761              {-1, rep_prefix_4_byte, false}}},
762   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
763              {-1, libcall, false}}}};
764 static stringop_algs k8_memset[2] = {
765   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
766              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
767   {libcall, {{48, unrolled_loop, false},
768              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
769 static const
770 struct processor_costs k8_cost = {
771   COSTS_N_INSNS (1),                    /* cost of an add instruction */
772   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
773   COSTS_N_INSNS (1),                    /* variable shift costs */
774   COSTS_N_INSNS (1),                    /* constant shift costs */
775   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
776    COSTS_N_INSNS (4),                   /*                               HI */
777    COSTS_N_INSNS (3),                   /*                               SI */
778    COSTS_N_INSNS (4),                   /*                               DI */
779    COSTS_N_INSNS (5)},                  /*                            other */
780   0,                                    /* cost of multiply per each bit set */
781   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
782    COSTS_N_INSNS (26),                  /*                          HI */
783    COSTS_N_INSNS (42),                  /*                          SI */
784    COSTS_N_INSNS (74),                  /*                          DI */
785    COSTS_N_INSNS (74)},                 /*                          other */
786   COSTS_N_INSNS (1),                    /* cost of movsx */
787   COSTS_N_INSNS (1),                    /* cost of movzx */
788   8,                                    /* "large" insn */
789   9,                                    /* MOVE_RATIO */
790   4,                                 /* cost for loading QImode using movzbl */
791   {3, 4, 3},                            /* cost of loading integer registers
792                                            in QImode, HImode and SImode.
793                                            Relative to reg-reg move (2).  */
794   {3, 4, 3},                            /* cost of storing integer registers */
795   4,                                    /* cost of reg,reg fld/fst */
796   {4, 4, 12},                           /* cost of loading fp registers
797                                            in SFmode, DFmode and XFmode */
798   {6, 6, 8},                            /* cost of storing fp registers
799                                            in SFmode, DFmode and XFmode */
800   2,                                    /* cost of moving MMX register */
801   {3, 3},                               /* cost of loading MMX registers
802                                            in SImode and DImode */
803   {4, 4},                               /* cost of storing MMX registers
804                                            in SImode and DImode */
805   2,                                    /* cost of moving SSE register */
806   {4, 3, 6},                            /* cost of loading SSE registers
807                                            in SImode, DImode and TImode */
808   {4, 4, 5},                            /* cost of storing SSE registers
809                                            in SImode, DImode and TImode */
810   5,                                    /* MMX or SSE register to integer */
811   64,                                   /* size of l1 cache.  */
812   512,                                  /* size of l2 cache.  */
813   64,                                   /* size of prefetch block */
814   /* New AMD processors never drop prefetches; if they cannot be performed
815      immediately, they are queued.  We set number of simultaneous prefetches
816      to a large constant to reflect this (it probably is not a good idea not
817      to limit number of prefetches at all, as their execution also takes some
818      time).  */
819   100,                                  /* number of parallel prefetches */
820   3,                                    /* Branch cost */
821   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
822   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
823   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
824   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
825   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
826   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
827
828   k8_memcpy,
829   k8_memset,
830   4,                                    /* scalar_stmt_cost.  */
831   2,                                    /* scalar load_cost.  */
832   2,                                    /* scalar_store_cost.  */
833   5,                                    /* vec_stmt_cost.  */
834   0,                                    /* vec_to_scalar_cost.  */
835   2,                                    /* scalar_to_vec_cost.  */
836   2,                                    /* vec_align_load_cost.  */
837   3,                                    /* vec_unalign_load_cost.  */
838   3,                                    /* vec_store_cost.  */
839   3,                                    /* cond_taken_branch_cost.  */
840   2,                                    /* cond_not_taken_branch_cost.  */
841 };
842
843 /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
844    very small blocks it is better to use loop. For large blocks, libcall can
845    do nontemporary accesses and beat inline considerably.  */
846 static stringop_algs amdfam10_memcpy[2] = {
847   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
848              {-1, rep_prefix_4_byte, false}}},
849   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
850              {-1, libcall, false}}}};
851 static stringop_algs amdfam10_memset[2] = {
852   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
853              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
854   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
855              {-1, libcall, false}}}};
856 struct processor_costs amdfam10_cost = {
857   COSTS_N_INSNS (1),                    /* cost of an add instruction */
858   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
859   COSTS_N_INSNS (1),                    /* variable shift costs */
860   COSTS_N_INSNS (1),                    /* constant shift costs */
861   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
862    COSTS_N_INSNS (4),                   /*                               HI */
863    COSTS_N_INSNS (3),                   /*                               SI */
864    COSTS_N_INSNS (4),                   /*                               DI */
865    COSTS_N_INSNS (5)},                  /*                            other */
866   0,                                    /* cost of multiply per each bit set */
867   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
868    COSTS_N_INSNS (35),                  /*                          HI */
869    COSTS_N_INSNS (51),                  /*                          SI */
870    COSTS_N_INSNS (83),                  /*                          DI */
871    COSTS_N_INSNS (83)},                 /*                          other */
872   COSTS_N_INSNS (1),                    /* cost of movsx */
873   COSTS_N_INSNS (1),                    /* cost of movzx */
874   8,                                    /* "large" insn */
875   9,                                    /* MOVE_RATIO */
876   4,                                 /* cost for loading QImode using movzbl */
877   {3, 4, 3},                            /* cost of loading integer registers
878                                            in QImode, HImode and SImode.
879                                            Relative to reg-reg move (2).  */
880   {3, 4, 3},                            /* cost of storing integer registers */
881   4,                                    /* cost of reg,reg fld/fst */
882   {4, 4, 12},                           /* cost of loading fp registers
883                                            in SFmode, DFmode and XFmode */
884   {6, 6, 8},                            /* cost of storing fp registers
885                                            in SFmode, DFmode and XFmode */
886   2,                                    /* cost of moving MMX register */
887   {3, 3},                               /* cost of loading MMX registers
888                                            in SImode and DImode */
889   {4, 4},                               /* cost of storing MMX registers
890                                            in SImode and DImode */
891   2,                                    /* cost of moving SSE register */
892   {4, 4, 3},                            /* cost of loading SSE registers
893                                            in SImode, DImode and TImode */
894   {4, 4, 5},                            /* cost of storing SSE registers
895                                            in SImode, DImode and TImode */
896   3,                                    /* MMX or SSE register to integer */
897                                         /* On K8:
898                                             MOVD reg64, xmmreg Double FSTORE 4
899                                             MOVD reg32, xmmreg Double FSTORE 4
900                                            On AMDFAM10:
901                                             MOVD reg64, xmmreg Double FADD 3
902                                                                1/1  1/1
903                                             MOVD reg32, xmmreg Double FADD 3
904                                                                1/1  1/1 */
905   64,                                   /* size of l1 cache.  */
906   512,                                  /* size of l2 cache.  */
907   64,                                   /* size of prefetch block */
908   /* New AMD processors never drop prefetches; if they cannot be performed
909      immediately, they are queued.  We set number of simultaneous prefetches
910      to a large constant to reflect this (it probably is not a good idea not
911      to limit number of prefetches at all, as their execution also takes some
912      time).  */
913   100,                                  /* number of parallel prefetches */
914   2,                                    /* Branch cost */
915   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
916   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
917   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
918   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
919   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
920   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
921
922   amdfam10_memcpy,
923   amdfam10_memset,
924   4,                                    /* scalar_stmt_cost.  */
925   2,                                    /* scalar load_cost.  */
926   2,                                    /* scalar_store_cost.  */
927   6,                                    /* vec_stmt_cost.  */
928   0,                                    /* vec_to_scalar_cost.  */
929   2,                                    /* scalar_to_vec_cost.  */
930   2,                                    /* vec_align_load_cost.  */
931   2,                                    /* vec_unalign_load_cost.  */
932   2,                                    /* vec_store_cost.  */
933   2,                                    /* cond_taken_branch_cost.  */
934   1,                                    /* cond_not_taken_branch_cost.  */
935 };
936
937 /*  BDVER1 has optimized REP instruction for medium sized blocks, but for
938     very small blocks it is better to use loop. For large blocks, libcall
939     can do nontemporary accesses and beat inline considerably.  */
940 static stringop_algs bdver1_memcpy[2] = {
941   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
942              {-1, rep_prefix_4_byte, false}}},
943   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
944              {-1, libcall, false}}}};
945 static stringop_algs bdver1_memset[2] = {
946   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
947              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
948   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
949              {-1, libcall, false}}}};
950
951 const struct processor_costs bdver1_cost = {
952   COSTS_N_INSNS (1),                    /* cost of an add instruction */
953   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
954   COSTS_N_INSNS (1),                    /* variable shift costs */
955   COSTS_N_INSNS (1),                    /* constant shift costs */
956   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
957    COSTS_N_INSNS (4),                   /*                               HI */
958    COSTS_N_INSNS (4),                   /*                               SI */
959    COSTS_N_INSNS (6),                   /*                               DI */
960    COSTS_N_INSNS (6)},                  /*                            other */
961   0,                                    /* cost of multiply per each bit set */
962   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
963    COSTS_N_INSNS (35),                  /*                          HI */
964    COSTS_N_INSNS (51),                  /*                          SI */
965    COSTS_N_INSNS (83),                  /*                          DI */
966    COSTS_N_INSNS (83)},                 /*                          other */
967   COSTS_N_INSNS (1),                    /* cost of movsx */
968   COSTS_N_INSNS (1),                    /* cost of movzx */
969   8,                                    /* "large" insn */
970   9,                                    /* MOVE_RATIO */
971   4,                                 /* cost for loading QImode using movzbl */
972   {5, 5, 4},                            /* cost of loading integer registers
973                                            in QImode, HImode and SImode.
974                                            Relative to reg-reg move (2).  */
975   {4, 4, 4},                            /* cost of storing integer registers */
976   2,                                    /* cost of reg,reg fld/fst */
977   {5, 5, 12},                           /* cost of loading fp registers
978                                            in SFmode, DFmode and XFmode */
979   {4, 4, 8},                            /* cost of storing fp registers
980                                            in SFmode, DFmode and XFmode */
981   2,                                    /* cost of moving MMX register */
982   {4, 4},                               /* cost of loading MMX registers
983                                            in SImode and DImode */
984   {4, 4},                               /* cost of storing MMX registers
985                                            in SImode and DImode */
986   2,                                    /* cost of moving SSE register */
987   {4, 4, 4},                            /* cost of loading SSE registers
988                                            in SImode, DImode and TImode */
989   {4, 4, 4},                            /* cost of storing SSE registers
990                                            in SImode, DImode and TImode */
991   2,                                    /* MMX or SSE register to integer */
992                                         /* On K8:
993                                             MOVD reg64, xmmreg Double FSTORE 4
994                                             MOVD reg32, xmmreg Double FSTORE 4
995                                            On AMDFAM10:
996                                             MOVD reg64, xmmreg Double FADD 3
997                                                                1/1  1/1
998                                             MOVD reg32, xmmreg Double FADD 3
999                                                                1/1  1/1 */
1000   16,                                   /* size of l1 cache.  */
1001   2048,                                 /* size of l2 cache.  */
1002   64,                                   /* size of prefetch block */
1003   /* New AMD processors never drop prefetches; if they cannot be performed
1004      immediately, they are queued.  We set number of simultaneous prefetches
1005      to a large constant to reflect this (it probably is not a good idea not
1006      to limit number of prefetches at all, as their execution also takes some
1007      time).  */
1008   100,                                  /* number of parallel prefetches */
1009   2,                                    /* Branch cost */
1010   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1011   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1012   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1013   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1014   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1015   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1016
1017   bdver1_memcpy,
1018   bdver1_memset,
1019   6,                                    /* scalar_stmt_cost.  */
1020   4,                                    /* scalar load_cost.  */
1021   4,                                    /* scalar_store_cost.  */
1022   6,                                    /* vec_stmt_cost.  */
1023   0,                                    /* vec_to_scalar_cost.  */
1024   2,                                    /* scalar_to_vec_cost.  */
1025   4,                                    /* vec_align_load_cost.  */
1026   4,                                    /* vec_unalign_load_cost.  */
1027   4,                                    /* vec_store_cost.  */
1028   2,                                    /* cond_taken_branch_cost.  */
1029   1,                                    /* cond_not_taken_branch_cost.  */
1030 };
1031
1032 /*  BDVER2 has optimized REP instruction for medium sized blocks, but for
1033     very small blocks it is better to use loop. For large blocks, libcall
1034     can do nontemporary accesses and beat inline considerably.  */
1035
1036 static stringop_algs bdver2_memcpy[2] = {
1037   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
1038              {-1, rep_prefix_4_byte, false}}},
1039   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
1040              {-1, libcall, false}}}};
1041 static stringop_algs bdver2_memset[2] = {
1042   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
1043              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1044   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
1045              {-1, libcall, false}}}};
1046
1047 const struct processor_costs bdver2_cost = {
1048   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1049   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1050   COSTS_N_INSNS (1),                    /* variable shift costs */
1051   COSTS_N_INSNS (1),                    /* constant shift costs */
1052   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1053    COSTS_N_INSNS (4),                   /*                               HI */
1054    COSTS_N_INSNS (4),                   /*                               SI */
1055    COSTS_N_INSNS (6),                   /*                               DI */
1056    COSTS_N_INSNS (6)},                  /*                            other */
1057   0,                                    /* cost of multiply per each bit set */
1058   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1059    COSTS_N_INSNS (35),                  /*                          HI */
1060    COSTS_N_INSNS (51),                  /*                          SI */
1061    COSTS_N_INSNS (83),                  /*                          DI */
1062    COSTS_N_INSNS (83)},                 /*                          other */
1063   COSTS_N_INSNS (1),                    /* cost of movsx */
1064   COSTS_N_INSNS (1),                    /* cost of movzx */
1065   8,                                    /* "large" insn */
1066   9,                                    /* MOVE_RATIO */
1067   4,                                 /* cost for loading QImode using movzbl */
1068   {5, 5, 4},                            /* cost of loading integer registers
1069                                            in QImode, HImode and SImode.
1070                                            Relative to reg-reg move (2).  */
1071   {4, 4, 4},                            /* cost of storing integer registers */
1072   2,                                    /* cost of reg,reg fld/fst */
1073   {5, 5, 12},                           /* cost of loading fp registers
1074                                            in SFmode, DFmode and XFmode */
1075   {4, 4, 8},                            /* cost of storing fp registers
1076                                            in SFmode, DFmode and XFmode */
1077   2,                                    /* cost of moving MMX register */
1078   {4, 4},                               /* cost of loading MMX registers
1079                                            in SImode and DImode */
1080   {4, 4},                               /* cost of storing MMX registers
1081                                            in SImode and DImode */
1082   2,                                    /* cost of moving SSE register */
1083   {4, 4, 4},                            /* cost of loading SSE registers
1084                                            in SImode, DImode and TImode */
1085   {4, 4, 4},                            /* cost of storing SSE registers
1086                                            in SImode, DImode and TImode */
1087   2,                                    /* MMX or SSE register to integer */
1088                                         /* On K8:
1089                                             MOVD reg64, xmmreg Double FSTORE 4
1090                                             MOVD reg32, xmmreg Double FSTORE 4
1091                                            On AMDFAM10:
1092                                             MOVD reg64, xmmreg Double FADD 3
1093                                                                1/1  1/1
1094                                             MOVD reg32, xmmreg Double FADD 3
1095                                                                1/1  1/1 */
1096   16,                                   /* size of l1 cache.  */
1097   2048,                                 /* size of l2 cache.  */
1098   64,                                   /* size of prefetch block */
1099   /* New AMD processors never drop prefetches; if they cannot be performed
1100      immediately, they are queued.  We set number of simultaneous prefetches
1101      to a large constant to reflect this (it probably is not a good idea not
1102      to limit number of prefetches at all, as their execution also takes some
1103      time).  */
1104   100,                                  /* number of parallel prefetches */
1105   2,                                    /* Branch cost */
1106   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1107   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1108   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1109   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1110   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1111   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1112
1113   bdver2_memcpy,
1114   bdver2_memset,
1115   6,                                    /* scalar_stmt_cost.  */
1116   4,                                    /* scalar load_cost.  */
1117   4,                                    /* scalar_store_cost.  */
1118   6,                                    /* vec_stmt_cost.  */
1119   0,                                    /* vec_to_scalar_cost.  */
1120   2,                                    /* scalar_to_vec_cost.  */
1121   4,                                    /* vec_align_load_cost.  */
1122   4,                                    /* vec_unalign_load_cost.  */
1123   4,                                    /* vec_store_cost.  */
1124   2,                                    /* cond_taken_branch_cost.  */
1125   1,                                    /* cond_not_taken_branch_cost.  */
1126 };
1127
1128
1129   /*  BDVER3 has optimized REP instruction for medium sized blocks, but for
1130       very small blocks it is better to use loop. For large blocks, libcall
1131       can do nontemporary accesses and beat inline considerably.  */
1132 static stringop_algs bdver3_memcpy[2] = {
1133   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
1134              {-1, rep_prefix_4_byte, false}}},
1135   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
1136              {-1, libcall, false}}}};
1137 static stringop_algs bdver3_memset[2] = {
1138   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
1139              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1140   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
1141              {-1, libcall, false}}}};
1142 struct processor_costs bdver3_cost = {
1143   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1144   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1145   COSTS_N_INSNS (1),                    /* variable shift costs */
1146   COSTS_N_INSNS (1),                    /* constant shift costs */
1147   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1148    COSTS_N_INSNS (4),                   /*                               HI */
1149    COSTS_N_INSNS (4),                   /*                               SI */
1150    COSTS_N_INSNS (6),                   /*                               DI */
1151    COSTS_N_INSNS (6)},                  /*                            other */
1152   0,                                    /* cost of multiply per each bit set */
1153   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1154    COSTS_N_INSNS (35),                  /*                          HI */
1155    COSTS_N_INSNS (51),                  /*                          SI */
1156    COSTS_N_INSNS (83),                  /*                          DI */
1157    COSTS_N_INSNS (83)},                 /*                          other */
1158   COSTS_N_INSNS (1),                    /* cost of movsx */
1159   COSTS_N_INSNS (1),                    /* cost of movzx */
1160   8,                                    /* "large" insn */
1161   9,                                    /* MOVE_RATIO */
1162   4,                                 /* cost for loading QImode using movzbl */
1163   {5, 5, 4},                            /* cost of loading integer registers
1164                                            in QImode, HImode and SImode.
1165                                            Relative to reg-reg move (2).  */
1166   {4, 4, 4},                            /* cost of storing integer registers */
1167   2,                                    /* cost of reg,reg fld/fst */
1168   {5, 5, 12},                           /* cost of loading fp registers
1169                                            in SFmode, DFmode and XFmode */
1170   {4, 4, 8},                            /* cost of storing fp registers
1171                                            in SFmode, DFmode and XFmode */
1172   2,                                    /* cost of moving MMX register */
1173   {4, 4},                               /* cost of loading MMX registers
1174                                            in SImode and DImode */
1175   {4, 4},                               /* cost of storing MMX registers
1176                                            in SImode and DImode */
1177   2,                                    /* cost of moving SSE register */
1178   {4, 4, 4},                            /* cost of loading SSE registers
1179                                            in SImode, DImode and TImode */
1180   {4, 4, 4},                            /* cost of storing SSE registers
1181                                            in SImode, DImode and TImode */
1182   2,                                    /* MMX or SSE register to integer */
1183   16,                                   /* size of l1 cache.  */
1184   2048,                                 /* size of l2 cache.  */
1185   64,                                   /* size of prefetch block */
1186   /* New AMD processors never drop prefetches; if they cannot be performed
1187      immediately, they are queued.  We set number of simultaneous prefetches
1188      to a large constant to reflect this (it probably is not a good idea not
1189      to limit number of prefetches at all, as their execution also takes some
1190      time).  */
1191   100,                                  /* number of parallel prefetches */
1192   2,                                    /* Branch cost */
1193   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1194   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1195   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1196   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1197   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1198   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1199
1200   bdver3_memcpy,
1201   bdver3_memset,
1202   6,                                    /* scalar_stmt_cost.  */
1203   4,                                    /* scalar load_cost.  */
1204   4,                                    /* scalar_store_cost.  */
1205   6,                                    /* vec_stmt_cost.  */
1206   0,                                    /* vec_to_scalar_cost.  */
1207   2,                                    /* scalar_to_vec_cost.  */
1208   4,                                    /* vec_align_load_cost.  */
1209   4,                                    /* vec_unalign_load_cost.  */
1210   4,                                    /* vec_store_cost.  */
1211   2,                                    /* cond_taken_branch_cost.  */
1212   1,                                    /* cond_not_taken_branch_cost.  */
1213 };
1214
1215 /*  BDVER4 has optimized REP instruction for medium sized blocks, but for
1216     very small blocks it is better to use loop. For large blocks, libcall
1217     can do nontemporary accesses and beat inline considerably.  */
1218 static stringop_algs bdver4_memcpy[2] = {
1219   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
1220              {-1, rep_prefix_4_byte, false}}},
1221   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
1222              {-1, libcall, false}}}};
1223 static stringop_algs bdver4_memset[2] = {
1224   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
1225              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1226   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
1227              {-1, libcall, false}}}};
1228 struct processor_costs bdver4_cost = {
1229   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1230   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1231   COSTS_N_INSNS (1),                    /* variable shift costs */
1232   COSTS_N_INSNS (1),                    /* constant shift costs */
1233   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1234    COSTS_N_INSNS (4),                   /*                               HI */
1235    COSTS_N_INSNS (4),                   /*                               SI */
1236    COSTS_N_INSNS (6),                   /*                               DI */
1237    COSTS_N_INSNS (6)},                  /*                            other */
1238   0,                                    /* cost of multiply per each bit set */
1239   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1240    COSTS_N_INSNS (35),                  /*                          HI */
1241    COSTS_N_INSNS (51),                  /*                          SI */
1242    COSTS_N_INSNS (83),                  /*                          DI */
1243    COSTS_N_INSNS (83)},                 /*                          other */
1244   COSTS_N_INSNS (1),                    /* cost of movsx */
1245   COSTS_N_INSNS (1),                    /* cost of movzx */
1246   8,                                    /* "large" insn */
1247   9,                                    /* MOVE_RATIO */
1248   4,                                 /* cost for loading QImode using movzbl */
1249   {5, 5, 4},                            /* cost of loading integer registers
1250                                            in QImode, HImode and SImode.
1251                                            Relative to reg-reg move (2).  */
1252   {4, 4, 4},                            /* cost of storing integer registers */
1253   2,                                    /* cost of reg,reg fld/fst */
1254   {5, 5, 12},                           /* cost of loading fp registers
1255                                            in SFmode, DFmode and XFmode */
1256   {4, 4, 8},                            /* cost of storing fp registers
1257                                            in SFmode, DFmode and XFmode */
1258   2,                                    /* cost of moving MMX register */
1259   {4, 4},                               /* cost of loading MMX registers
1260                                            in SImode and DImode */
1261   {4, 4},                               /* cost of storing MMX registers
1262                                            in SImode and DImode */
1263   2,                                    /* cost of moving SSE register */
1264   {4, 4, 4},                            /* cost of loading SSE registers
1265                                            in SImode, DImode and TImode */
1266   {4, 4, 4},                            /* cost of storing SSE registers
1267                                            in SImode, DImode and TImode */
1268   2,                                    /* MMX or SSE register to integer */
1269   16,                                   /* size of l1 cache.  */
1270   2048,                                 /* size of l2 cache.  */
1271   64,                                   /* size of prefetch block */
1272   /* New AMD processors never drop prefetches; if they cannot be performed
1273      immediately, they are queued.  We set number of simultaneous prefetches
1274      to a large constant to reflect this (it probably is not a good idea not
1275      to limit number of prefetches at all, as their execution also takes some
1276      time).  */
1277   100,                                  /* number of parallel prefetches */
1278   2,                                    /* Branch cost */
1279   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1280   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1281   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1282   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1283   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1284   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1285
1286   bdver4_memcpy,
1287   bdver4_memset,
1288   6,                                    /* scalar_stmt_cost.  */
1289   4,                                    /* scalar load_cost.  */
1290   4,                                    /* scalar_store_cost.  */
1291   6,                                    /* vec_stmt_cost.  */
1292   0,                                    /* vec_to_scalar_cost.  */
1293   2,                                    /* scalar_to_vec_cost.  */
1294   4,                                    /* vec_align_load_cost.  */
1295   4,                                    /* vec_unalign_load_cost.  */
1296   4,                                    /* vec_store_cost.  */
1297   2,                                    /* cond_taken_branch_cost.  */
1298   1,                                    /* cond_not_taken_branch_cost.  */
1299 };
1300
1301   /* BTVER1 has optimized REP instruction for medium sized blocks, but for
1302      very small blocks it is better to use loop. For large blocks, libcall can
1303      do nontemporary accesses and beat inline considerably.  */
1304 static stringop_algs btver1_memcpy[2] = {
1305   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
1306              {-1, rep_prefix_4_byte, false}}},
1307   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
1308              {-1, libcall, false}}}};
1309 static stringop_algs btver1_memset[2] = {
1310   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
1311              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1312   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
1313              {-1, libcall, false}}}};
1314 const struct processor_costs btver1_cost = {
1315   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1316   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1317   COSTS_N_INSNS (1),                    /* variable shift costs */
1318   COSTS_N_INSNS (1),                    /* constant shift costs */
1319   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1320    COSTS_N_INSNS (4),                   /*                               HI */
1321    COSTS_N_INSNS (3),                   /*                               SI */
1322    COSTS_N_INSNS (4),                   /*                               DI */
1323    COSTS_N_INSNS (5)},                  /*                            other */
1324   0,                                    /* cost of multiply per each bit set */
1325   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1326    COSTS_N_INSNS (35),                  /*                          HI */
1327    COSTS_N_INSNS (51),                  /*                          SI */
1328    COSTS_N_INSNS (83),                  /*                          DI */
1329    COSTS_N_INSNS (83)},                 /*                          other */
1330   COSTS_N_INSNS (1),                    /* cost of movsx */
1331   COSTS_N_INSNS (1),                    /* cost of movzx */
1332   8,                                    /* "large" insn */
1333   9,                                    /* MOVE_RATIO */
1334   4,                                 /* cost for loading QImode using movzbl */
1335   {3, 4, 3},                            /* cost of loading integer registers
1336                                            in QImode, HImode and SImode.
1337                                            Relative to reg-reg move (2).  */
1338   {3, 4, 3},                            /* cost of storing integer registers */
1339   4,                                    /* cost of reg,reg fld/fst */
1340   {4, 4, 12},                           /* cost of loading fp registers
1341                                            in SFmode, DFmode and XFmode */
1342   {6, 6, 8},                            /* cost of storing fp registers
1343                                            in SFmode, DFmode and XFmode */
1344   2,                                    /* cost of moving MMX register */
1345   {3, 3},                               /* cost of loading MMX registers
1346                                            in SImode and DImode */
1347   {4, 4},                               /* cost of storing MMX registers
1348                                            in SImode and DImode */
1349   2,                                    /* cost of moving SSE register */
1350   {4, 4, 3},                            /* cost of loading SSE registers
1351                                            in SImode, DImode and TImode */
1352   {4, 4, 5},                            /* cost of storing SSE registers
1353                                            in SImode, DImode and TImode */
1354   3,                                    /* MMX or SSE register to integer */
1355                                         /* On K8:
1356                                            MOVD reg64, xmmreg Double FSTORE 4
1357                                            MOVD reg32, xmmreg Double FSTORE 4
1358                                            On AMDFAM10:
1359                                            MOVD reg64, xmmreg Double FADD 3
1360                                                                1/1  1/1
1361                                             MOVD reg32, xmmreg Double FADD 3
1362                                                                1/1  1/1 */
1363   32,                                   /* size of l1 cache.  */
1364   512,                                  /* size of l2 cache.  */
1365   64,                                   /* size of prefetch block */
1366   100,                                  /* number of parallel prefetches */
1367   2,                                    /* Branch cost */
1368   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1369   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1370   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1371   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1372   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1373   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1374
1375   btver1_memcpy,
1376   btver1_memset,
1377   4,                                    /* scalar_stmt_cost.  */
1378   2,                                    /* scalar load_cost.  */
1379   2,                                    /* scalar_store_cost.  */
1380   6,                                    /* vec_stmt_cost.  */
1381   0,                                    /* vec_to_scalar_cost.  */
1382   2,                                    /* scalar_to_vec_cost.  */
1383   2,                                    /* vec_align_load_cost.  */
1384   2,                                    /* vec_unalign_load_cost.  */
1385   2,                                    /* vec_store_cost.  */
1386   2,                                    /* cond_taken_branch_cost.  */
1387   1,                                    /* cond_not_taken_branch_cost.  */
1388 };
1389
1390 static stringop_algs btver2_memcpy[2] = {
1391   {libcall, {{6, loop, false}, {14, unrolled_loop, false},
1392              {-1, rep_prefix_4_byte, false}}},
1393   {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false},
1394              {-1, libcall, false}}}};
1395 static stringop_algs btver2_memset[2] = {
1396   {libcall, {{8, loop, false}, {24, unrolled_loop, false},
1397              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1398   {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false},
1399              {-1, libcall, false}}}};
1400 const struct processor_costs btver2_cost = {
1401   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1402   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1403   COSTS_N_INSNS (1),                    /* variable shift costs */
1404   COSTS_N_INSNS (1),                    /* constant shift costs */
1405   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1406    COSTS_N_INSNS (4),                   /*                               HI */
1407    COSTS_N_INSNS (3),                   /*                               SI */
1408    COSTS_N_INSNS (4),                   /*                               DI */
1409    COSTS_N_INSNS (5)},                  /*                            other */
1410   0,                                    /* cost of multiply per each bit set */
1411   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1412    COSTS_N_INSNS (35),                  /*                          HI */
1413    COSTS_N_INSNS (51),                  /*                          SI */
1414    COSTS_N_INSNS (83),                  /*                          DI */
1415    COSTS_N_INSNS (83)},                 /*                          other */
1416   COSTS_N_INSNS (1),                    /* cost of movsx */
1417   COSTS_N_INSNS (1),                    /* cost of movzx */
1418   8,                                    /* "large" insn */
1419   9,                                    /* MOVE_RATIO */
1420   4,                                 /* cost for loading QImode using movzbl */
1421   {3, 4, 3},                            /* cost of loading integer registers
1422                                            in QImode, HImode and SImode.
1423                                            Relative to reg-reg move (2).  */
1424   {3, 4, 3},                            /* cost of storing integer registers */
1425   4,                                    /* cost of reg,reg fld/fst */
1426   {4, 4, 12},                           /* cost of loading fp registers
1427                                            in SFmode, DFmode and XFmode */
1428   {6, 6, 8},                            /* cost of storing fp registers
1429                                            in SFmode, DFmode and XFmode */
1430   2,                                    /* cost of moving MMX register */
1431   {3, 3},                               /* cost of loading MMX registers
1432                                            in SImode and DImode */
1433   {4, 4},                               /* cost of storing MMX registers
1434                                            in SImode and DImode */
1435   2,                                    /* cost of moving SSE register */
1436   {4, 4, 3},                            /* cost of loading SSE registers
1437                                            in SImode, DImode and TImode */
1438   {4, 4, 5},                            /* cost of storing SSE registers
1439                                            in SImode, DImode and TImode */
1440   3,                                    /* MMX or SSE register to integer */
1441                                         /* On K8:
1442                                            MOVD reg64, xmmreg Double FSTORE 4
1443                                            MOVD reg32, xmmreg Double FSTORE 4
1444                                            On AMDFAM10:
1445                                            MOVD reg64, xmmreg Double FADD 3
1446                                                                1/1  1/1
1447                                             MOVD reg32, xmmreg Double FADD 3
1448                                                                1/1  1/1 */
1449   32,                                   /* size of l1 cache.  */
1450   2048,                                 /* size of l2 cache.  */
1451   64,                                   /* size of prefetch block */
1452   100,                                  /* number of parallel prefetches */
1453   2,                                    /* Branch cost */
1454   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1455   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1456   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1457   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1458   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1459   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1460   btver2_memcpy,
1461   btver2_memset,
1462   4,                                    /* scalar_stmt_cost.  */
1463   2,                                    /* scalar load_cost.  */
1464   2,                                    /* scalar_store_cost.  */
1465   6,                                    /* vec_stmt_cost.  */
1466   0,                                    /* vec_to_scalar_cost.  */
1467   2,                                    /* scalar_to_vec_cost.  */
1468   2,                                    /* vec_align_load_cost.  */
1469   2,                                    /* vec_unalign_load_cost.  */
1470   2,                                    /* vec_store_cost.  */
1471   2,                                    /* cond_taken_branch_cost.  */
1472   1,                                    /* cond_not_taken_branch_cost.  */
1473 };
1474
1475 static stringop_algs pentium4_memcpy[2] = {
1476   {libcall, {{12, loop_1_byte, false}, {-1, rep_prefix_4_byte, false}}},
1477   DUMMY_STRINGOP_ALGS};
1478 static stringop_algs pentium4_memset[2] = {
1479   {libcall, {{6, loop_1_byte, false}, {48, loop, false},
1480              {20480, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1481   DUMMY_STRINGOP_ALGS};
1482
1483 static const
1484 struct processor_costs pentium4_cost = {
1485   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1486   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
1487   COSTS_N_INSNS (4),                    /* variable shift costs */
1488   COSTS_N_INSNS (4),                    /* constant shift costs */
1489   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
1490    COSTS_N_INSNS (15),                  /*                               HI */
1491    COSTS_N_INSNS (15),                  /*                               SI */
1492    COSTS_N_INSNS (15),                  /*                               DI */
1493    COSTS_N_INSNS (15)},                 /*                            other */
1494   0,                                    /* cost of multiply per each bit set */
1495   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
1496    COSTS_N_INSNS (56),                  /*                          HI */
1497    COSTS_N_INSNS (56),                  /*                          SI */
1498    COSTS_N_INSNS (56),                  /*                          DI */
1499    COSTS_N_INSNS (56)},                 /*                          other */
1500   COSTS_N_INSNS (1),                    /* cost of movsx */
1501   COSTS_N_INSNS (1),                    /* cost of movzx */
1502   16,                                   /* "large" insn */
1503   6,                                    /* MOVE_RATIO */
1504   2,                                 /* cost for loading QImode using movzbl */
1505   {4, 5, 4},                            /* cost of loading integer registers
1506                                            in QImode, HImode and SImode.
1507                                            Relative to reg-reg move (2).  */
1508   {2, 3, 2},                            /* cost of storing integer registers */
1509   2,                                    /* cost of reg,reg fld/fst */
1510   {2, 2, 6},                            /* cost of loading fp registers
1511                                            in SFmode, DFmode and XFmode */
1512   {4, 4, 6},                            /* cost of storing fp registers
1513                                            in SFmode, DFmode and XFmode */
1514   2,                                    /* cost of moving MMX register */
1515   {2, 2},                               /* cost of loading MMX registers
1516                                            in SImode and DImode */
1517   {2, 2},                               /* cost of storing MMX registers
1518                                            in SImode and DImode */
1519   12,                                   /* cost of moving SSE register */
1520   {12, 12, 12},                         /* cost of loading SSE registers
1521                                            in SImode, DImode and TImode */
1522   {2, 2, 8},                            /* cost of storing SSE registers
1523                                            in SImode, DImode and TImode */
1524   10,                                   /* MMX or SSE register to integer */
1525   8,                                    /* size of l1 cache.  */
1526   256,                                  /* size of l2 cache.  */
1527   64,                                   /* size of prefetch block */
1528   6,                                    /* number of parallel prefetches */
1529   2,                                    /* Branch cost */
1530   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
1531   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
1532   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
1533   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1534   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1535   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
1536   pentium4_memcpy,
1537   pentium4_memset,
1538   1,                                    /* scalar_stmt_cost.  */
1539   1,                                    /* scalar load_cost.  */
1540   1,                                    /* scalar_store_cost.  */
1541   1,                                    /* vec_stmt_cost.  */
1542   1,                                    /* vec_to_scalar_cost.  */
1543   1,                                    /* scalar_to_vec_cost.  */
1544   1,                                    /* vec_align_load_cost.  */
1545   2,                                    /* vec_unalign_load_cost.  */
1546   1,                                    /* vec_store_cost.  */
1547   3,                                    /* cond_taken_branch_cost.  */
1548   1,                                    /* cond_not_taken_branch_cost.  */
1549 };
1550
1551 static stringop_algs nocona_memcpy[2] = {
1552   {libcall, {{12, loop_1_byte, false}, {-1, rep_prefix_4_byte, false}}},
1553   {libcall, {{32, loop, false}, {20000, rep_prefix_8_byte, false},
1554              {100000, unrolled_loop, false}, {-1, libcall, false}}}};
1555
1556 static stringop_algs nocona_memset[2] = {
1557   {libcall, {{6, loop_1_byte, false}, {48, loop, false},
1558              {20480, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1559   {libcall, {{24, loop, false}, {64, unrolled_loop, false},
1560              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1561
1562 static const
1563 struct processor_costs nocona_cost = {
1564   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1565   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1566   COSTS_N_INSNS (1),                    /* variable shift costs */
1567   COSTS_N_INSNS (1),                    /* constant shift costs */
1568   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
1569    COSTS_N_INSNS (10),                  /*                               HI */
1570    COSTS_N_INSNS (10),                  /*                               SI */
1571    COSTS_N_INSNS (10),                  /*                               DI */
1572    COSTS_N_INSNS (10)},                 /*                            other */
1573   0,                                    /* cost of multiply per each bit set */
1574   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
1575    COSTS_N_INSNS (66),                  /*                          HI */
1576    COSTS_N_INSNS (66),                  /*                          SI */
1577    COSTS_N_INSNS (66),                  /*                          DI */
1578    COSTS_N_INSNS (66)},                 /*                          other */
1579   COSTS_N_INSNS (1),                    /* cost of movsx */
1580   COSTS_N_INSNS (1),                    /* cost of movzx */
1581   16,                                   /* "large" insn */
1582   17,                                   /* MOVE_RATIO */
1583   4,                                 /* cost for loading QImode using movzbl */
1584   {4, 4, 4},                            /* cost of loading integer registers
1585                                            in QImode, HImode and SImode.
1586                                            Relative to reg-reg move (2).  */
1587   {4, 4, 4},                            /* cost of storing integer registers */
1588   3,                                    /* cost of reg,reg fld/fst */
1589   {12, 12, 12},                         /* cost of loading fp registers
1590                                            in SFmode, DFmode and XFmode */
1591   {4, 4, 4},                            /* cost of storing fp registers
1592                                            in SFmode, DFmode and XFmode */
1593   6,                                    /* cost of moving MMX register */
1594   {12, 12},                             /* cost of loading MMX registers
1595                                            in SImode and DImode */
1596   {12, 12},                             /* cost of storing MMX registers
1597                                            in SImode and DImode */
1598   6,                                    /* cost of moving SSE register */
1599   {12, 12, 12},                         /* cost of loading SSE registers
1600                                            in SImode, DImode and TImode */
1601   {12, 12, 12},                         /* cost of storing SSE registers
1602                                            in SImode, DImode and TImode */
1603   8,                                    /* MMX or SSE register to integer */
1604   8,                                    /* size of l1 cache.  */
1605   1024,                                 /* size of l2 cache.  */
1606   64,                                   /* size of prefetch block */
1607   8,                                    /* number of parallel prefetches */
1608   1,                                    /* Branch cost */
1609   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1610   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1611   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
1612   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
1613   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
1614   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
1615   nocona_memcpy,
1616   nocona_memset,
1617   1,                                    /* scalar_stmt_cost.  */
1618   1,                                    /* scalar load_cost.  */
1619   1,                                    /* scalar_store_cost.  */
1620   1,                                    /* vec_stmt_cost.  */
1621   1,                                    /* vec_to_scalar_cost.  */
1622   1,                                    /* scalar_to_vec_cost.  */
1623   1,                                    /* vec_align_load_cost.  */
1624   2,                                    /* vec_unalign_load_cost.  */
1625   1,                                    /* vec_store_cost.  */
1626   3,                                    /* cond_taken_branch_cost.  */
1627   1,                                    /* cond_not_taken_branch_cost.  */
1628 };
1629
1630 static stringop_algs atom_memcpy[2] = {
1631   {libcall, {{11, loop, false}, {-1, rep_prefix_4_byte, false}}},
1632   {libcall, {{32, loop, false}, {64, rep_prefix_4_byte, false},
1633              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1634 static stringop_algs atom_memset[2] = {
1635   {libcall, {{8, loop, false}, {15, unrolled_loop, false},
1636              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1637   {libcall, {{24, loop, false}, {32, unrolled_loop, false},
1638              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1639 static const
1640 struct processor_costs atom_cost = {
1641   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1642   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1643   COSTS_N_INSNS (1),                    /* variable shift costs */
1644   COSTS_N_INSNS (1),                    /* constant shift costs */
1645   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1646    COSTS_N_INSNS (4),                   /*                               HI */
1647    COSTS_N_INSNS (3),                   /*                               SI */
1648    COSTS_N_INSNS (4),                   /*                               DI */
1649    COSTS_N_INSNS (2)},                  /*                            other */
1650   0,                                    /* cost of multiply per each bit set */
1651   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1652    COSTS_N_INSNS (26),                  /*                          HI */
1653    COSTS_N_INSNS (42),                  /*                          SI */
1654    COSTS_N_INSNS (74),                  /*                          DI */
1655    COSTS_N_INSNS (74)},                 /*                          other */
1656   COSTS_N_INSNS (1),                    /* cost of movsx */
1657   COSTS_N_INSNS (1),                    /* cost of movzx */
1658   8,                                    /* "large" insn */
1659   17,                                   /* MOVE_RATIO */
1660   4,                                    /* cost for loading QImode using movzbl */
1661   {4, 4, 4},                            /* cost of loading integer registers
1662                                            in QImode, HImode and SImode.
1663                                            Relative to reg-reg move (2).  */
1664   {4, 4, 4},                            /* cost of storing integer registers */
1665   4,                                    /* cost of reg,reg fld/fst */
1666   {12, 12, 12},                         /* cost of loading fp registers
1667                                            in SFmode, DFmode and XFmode */
1668   {6, 6, 8},                            /* cost of storing fp registers
1669                                            in SFmode, DFmode and XFmode */
1670   2,                                    /* cost of moving MMX register */
1671   {8, 8},                               /* cost of loading MMX registers
1672                                            in SImode and DImode */
1673   {8, 8},                               /* cost of storing MMX registers
1674                                            in SImode and DImode */
1675   2,                                    /* cost of moving SSE register */
1676   {8, 8, 8},                            /* cost of loading SSE registers
1677                                            in SImode, DImode and TImode */
1678   {8, 8, 8},                            /* cost of storing SSE registers
1679                                            in SImode, DImode and TImode */
1680   5,                                    /* MMX or SSE register to integer */
1681   32,                                   /* size of l1 cache.  */
1682   256,                                  /* size of l2 cache.  */
1683   64,                                   /* size of prefetch block */
1684   6,                                    /* number of parallel prefetches */
1685   3,                                    /* Branch cost */
1686   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1687   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1688   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1689   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1690   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1691   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1692   atom_memcpy,
1693   atom_memset,
1694   1,                                    /* scalar_stmt_cost.  */
1695   1,                                    /* scalar load_cost.  */
1696   1,                                    /* scalar_store_cost.  */
1697   1,                                    /* vec_stmt_cost.  */
1698   1,                                    /* vec_to_scalar_cost.  */
1699   1,                                    /* scalar_to_vec_cost.  */
1700   1,                                    /* vec_align_load_cost.  */
1701   2,                                    /* vec_unalign_load_cost.  */
1702   1,                                    /* vec_store_cost.  */
1703   3,                                    /* cond_taken_branch_cost.  */
1704   1,                                    /* cond_not_taken_branch_cost.  */
1705 };
1706
1707 static stringop_algs slm_memcpy[2] = {
1708   {libcall, {{11, loop, false}, {-1, rep_prefix_4_byte, false}}},
1709   {libcall, {{32, loop, false}, {64, rep_prefix_4_byte, false},
1710              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1711 static stringop_algs slm_memset[2] = {
1712   {libcall, {{8, loop, false}, {15, unrolled_loop, false},
1713              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1714   {libcall, {{24, loop, false}, {32, unrolled_loop, false},
1715              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1716 static const
1717 struct processor_costs slm_cost = {
1718   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1719   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1720   COSTS_N_INSNS (1),                    /* variable shift costs */
1721   COSTS_N_INSNS (1),                    /* constant shift costs */
1722   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1723    COSTS_N_INSNS (3),                   /*                               HI */
1724    COSTS_N_INSNS (3),                   /*                               SI */
1725    COSTS_N_INSNS (4),                   /*                               DI */
1726    COSTS_N_INSNS (2)},                  /*                            other */
1727   0,                                    /* cost of multiply per each bit set */
1728   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1729    COSTS_N_INSNS (26),                  /*                          HI */
1730    COSTS_N_INSNS (42),                  /*                          SI */
1731    COSTS_N_INSNS (74),                  /*                          DI */
1732    COSTS_N_INSNS (74)},                 /*                          other */
1733   COSTS_N_INSNS (1),                    /* cost of movsx */
1734   COSTS_N_INSNS (1),                    /* cost of movzx */
1735   8,                                    /* "large" insn */
1736   17,                                   /* MOVE_RATIO */
1737   4,                                    /* cost for loading QImode using movzbl */
1738   {4, 4, 4},                            /* cost of loading integer registers
1739                                            in QImode, HImode and SImode.
1740                                            Relative to reg-reg move (2).  */
1741   {4, 4, 4},                            /* cost of storing integer registers */
1742   4,                                    /* cost of reg,reg fld/fst */
1743   {12, 12, 12},                         /* cost of loading fp registers
1744                                            in SFmode, DFmode and XFmode */
1745   {6, 6, 8},                            /* cost of storing fp registers
1746                                            in SFmode, DFmode and XFmode */
1747   2,                                    /* cost of moving MMX register */
1748   {8, 8},                               /* cost of loading MMX registers
1749                                            in SImode and DImode */
1750   {8, 8},                               /* cost of storing MMX registers
1751                                            in SImode and DImode */
1752   2,                                    /* cost of moving SSE register */
1753   {8, 8, 8},                            /* cost of loading SSE registers
1754                                            in SImode, DImode and TImode */
1755   {8, 8, 8},                            /* cost of storing SSE registers
1756                                            in SImode, DImode and TImode */
1757   5,                                    /* MMX or SSE register to integer */
1758   32,                                   /* size of l1 cache.  */
1759   256,                                  /* size of l2 cache.  */
1760   64,                                   /* size of prefetch block */
1761   6,                                    /* number of parallel prefetches */
1762   3,                                    /* Branch cost */
1763   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1764   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1765   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1766   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1767   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1768   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1769   slm_memcpy,
1770   slm_memset,
1771   1,                                    /* scalar_stmt_cost.  */
1772   1,                                    /* scalar load_cost.  */
1773   1,                                    /* scalar_store_cost.  */
1774   1,                                    /* vec_stmt_cost.  */
1775   4,                                    /* vec_to_scalar_cost.  */
1776   1,                                    /* scalar_to_vec_cost.  */
1777   1,                                    /* vec_align_load_cost.  */
1778   2,                                    /* vec_unalign_load_cost.  */
1779   1,                                    /* vec_store_cost.  */
1780   3,                                    /* cond_taken_branch_cost.  */
1781   1,                                    /* cond_not_taken_branch_cost.  */
1782 };
1783
1784 static stringop_algs intel_memcpy[2] = {
1785   {libcall, {{11, loop, false}, {-1, rep_prefix_4_byte, false}}},
1786   {libcall, {{32, loop, false}, {64, rep_prefix_4_byte, false},
1787              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1788 static stringop_algs intel_memset[2] = {
1789   {libcall, {{8, loop, false}, {15, unrolled_loop, false},
1790              {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}},
1791   {libcall, {{24, loop, false}, {32, unrolled_loop, false},
1792              {8192, rep_prefix_8_byte, false}, {-1, libcall, false}}}};
1793 static const
1794 struct processor_costs intel_cost = {
1795   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1796   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1797   COSTS_N_INSNS (1),                    /* variable shift costs */
1798   COSTS_N_INSNS (1),                    /* constant shift costs */
1799   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1800    COSTS_N_INSNS (3),                   /*                               HI */
1801    COSTS_N_INSNS (3),                   /*                               SI */
1802    COSTS_N_INSNS (4),                   /*                               DI */
1803    COSTS_N_INSNS (2)},                  /*                            other */
1804   0,                                    /* cost of multiply per each bit set */
1805   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1806    COSTS_N_INSNS (26),                  /*                          HI */
1807    COSTS_N_INSNS (42),                  /*                          SI */
1808    COSTS_N_INSNS (74),                  /*                          DI */
1809    COSTS_N_INSNS (74)},                 /*                          other */
1810   COSTS_N_INSNS (1),                    /* cost of movsx */
1811   COSTS_N_INSNS (1),                    /* cost of movzx */
1812   8,                                    /* "large" insn */
1813   17,                                   /* MOVE_RATIO */
1814   4,                                    /* cost for loading QImode using movzbl */
1815   {4, 4, 4},                            /* cost of loading integer registers
1816                                            in QImode, HImode and SImode.
1817                                            Relative to reg-reg move (2).  */
1818   {4, 4, 4},                            /* cost of storing integer registers */
1819   4,                                    /* cost of reg,reg fld/fst */
1820   {12, 12, 12},                         /* cost of loading fp registers
1821                                            in SFmode, DFmode and XFmode */
1822   {6, 6, 8},                            /* cost of storing fp registers
1823                                            in SFmode, DFmode and XFmode */
1824   2,                                    /* cost of moving MMX register */
1825   {8, 8},                               /* cost of loading MMX registers
1826                                            in SImode and DImode */
1827   {8, 8},                               /* cost of storing MMX registers
1828                                            in SImode and DImode */
1829   2,                                    /* cost of moving SSE register */
1830   {8, 8, 8},                            /* cost of loading SSE registers
1831                                            in SImode, DImode and TImode */
1832   {8, 8, 8},                            /* cost of storing SSE registers
1833                                            in SImode, DImode and TImode */
1834   5,                                    /* MMX or SSE register to integer */
1835   32,                                   /* size of l1 cache.  */
1836   256,                                  /* size of l2 cache.  */
1837   64,                                   /* size of prefetch block */
1838   6,                                    /* number of parallel prefetches */
1839   3,                                    /* Branch cost */
1840   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1841   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1842   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1843   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1844   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1845   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1846   intel_memcpy,
1847   intel_memset,
1848   1,                                    /* scalar_stmt_cost.  */
1849   1,                                    /* scalar load_cost.  */
1850   1,                                    /* scalar_store_cost.  */
1851   1,                                    /* vec_stmt_cost.  */
1852   4,                                    /* vec_to_scalar_cost.  */
1853   1,                                    /* scalar_to_vec_cost.  */
1854   1,                                    /* vec_align_load_cost.  */
1855   2,                                    /* vec_unalign_load_cost.  */
1856   1,                                    /* vec_store_cost.  */
1857   3,                                    /* cond_taken_branch_cost.  */
1858   1,                                    /* cond_not_taken_branch_cost.  */
1859 };
1860
1861 /* Generic should produce code tuned for Core-i7 (and newer chips)
1862    and btver1 (and newer chips).  */
1863
1864 static stringop_algs generic_memcpy[2] = {
1865   {libcall, {{32, loop, false}, {8192, rep_prefix_4_byte, false},
1866              {-1, libcall, false}}},
1867   {libcall, {{32, loop, false}, {8192, rep_prefix_8_byte, false},
1868              {-1, libcall, false}}}};
1869 static stringop_algs generic_memset[2] = {
1870   {libcall, {{32, loop, false}, {8192, rep_prefix_4_byte, false},
1871              {-1, libcall, false}}},
1872   {libcall, {{32, loop, false}, {8192, rep_prefix_8_byte, false},
1873              {-1, libcall, false}}}};
1874 static const
1875 struct processor_costs generic_cost = {
1876   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1877   /* On all chips taken into consideration lea is 2 cycles and more.  With
1878      this cost however our current implementation of synth_mult results in
1879      use of unnecessary temporary registers causing regression on several
1880      SPECfp benchmarks.  */
1881   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1882   COSTS_N_INSNS (1),                    /* variable shift costs */
1883   COSTS_N_INSNS (1),                    /* constant shift costs */
1884   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1885    COSTS_N_INSNS (4),                   /*                               HI */
1886    COSTS_N_INSNS (3),                   /*                               SI */
1887    COSTS_N_INSNS (4),                   /*                               DI */
1888    COSTS_N_INSNS (2)},                  /*                            other */
1889   0,                                    /* cost of multiply per each bit set */
1890   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1891    COSTS_N_INSNS (26),                  /*                          HI */
1892    COSTS_N_INSNS (42),                  /*                          SI */
1893    COSTS_N_INSNS (74),                  /*                          DI */
1894    COSTS_N_INSNS (74)},                 /*                          other */
1895   COSTS_N_INSNS (1),                    /* cost of movsx */
1896   COSTS_N_INSNS (1),                    /* cost of movzx */
1897   8,                                    /* "large" insn */
1898   17,                                   /* MOVE_RATIO */
1899   4,                                 /* cost for loading QImode using movzbl */
1900   {4, 4, 4},                            /* cost of loading integer registers
1901                                            in QImode, HImode and SImode.
1902                                            Relative to reg-reg move (2).  */
1903   {4, 4, 4},                            /* cost of storing integer registers */
1904   4,                                    /* cost of reg,reg fld/fst */
1905   {12, 12, 12},                         /* cost of loading fp registers
1906                                            in SFmode, DFmode and XFmode */
1907   {6, 6, 8},                            /* cost of storing fp registers
1908                                            in SFmode, DFmode and XFmode */
1909   2,                                    /* cost of moving MMX register */
1910   {8, 8},                               /* cost of loading MMX registers
1911                                            in SImode and DImode */
1912   {8, 8},                               /* cost of storing MMX registers
1913                                            in SImode and DImode */
1914   2,                                    /* cost of moving SSE register */
1915   {8, 8, 8},                            /* cost of loading SSE registers
1916                                            in SImode, DImode and TImode */
1917   {8, 8, 8},                            /* cost of storing SSE registers
1918                                            in SImode, DImode and TImode */
1919   5,                                    /* MMX or SSE register to integer */
1920   32,                                   /* size of l1 cache.  */
1921   512,                                  /* size of l2 cache.  */
1922   64,                                   /* size of prefetch block */
1923   6,                                    /* number of parallel prefetches */
1924   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1925      value is increased to perhaps more appropriate value of 5.  */
1926   3,                                    /* Branch cost */
1927   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1928   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1929   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1930   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1931   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1932   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1933   generic_memcpy,
1934   generic_memset,
1935   1,                                    /* scalar_stmt_cost.  */
1936   1,                                    /* scalar load_cost.  */
1937   1,                                    /* scalar_store_cost.  */
1938   1,                                    /* vec_stmt_cost.  */
1939   1,                                    /* vec_to_scalar_cost.  */
1940   1,                                    /* scalar_to_vec_cost.  */
1941   1,                                    /* vec_align_load_cost.  */
1942   2,                                    /* vec_unalign_load_cost.  */
1943   1,                                    /* vec_store_cost.  */
1944   3,                                    /* cond_taken_branch_cost.  */
1945   1,                                    /* cond_not_taken_branch_cost.  */
1946 };
1947
1948 /* core_cost should produce code tuned for Core familly of CPUs.  */
1949 static stringop_algs core_memcpy[2] = {
1950   {libcall, {{1024, rep_prefix_4_byte, true}, {-1, libcall, false}}},
1951   {libcall, {{24, loop, true}, {128, rep_prefix_8_byte, true},
1952              {-1, libcall, false}}}};
1953 static stringop_algs core_memset[2] = {
1954   {libcall, {{6, loop_1_byte, true},
1955              {24, loop, true},
1956              {8192, rep_prefix_4_byte, true},
1957              {-1, libcall, false}}},
1958   {libcall, {{24, loop, true}, {512, rep_prefix_8_byte, true},
1959              {-1, libcall, false}}}};
1960
1961 static const
1962 struct processor_costs core_cost = {
1963   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1964   /* On all chips taken into consideration lea is 2 cycles and more.  With
1965      this cost however our current implementation of synth_mult results in
1966      use of unnecessary temporary registers causing regression on several
1967      SPECfp benchmarks.  */
1968   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1969   COSTS_N_INSNS (1),                    /* variable shift costs */
1970   COSTS_N_INSNS (1),                    /* constant shift costs */
1971   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1972    COSTS_N_INSNS (4),                   /*                               HI */
1973    COSTS_N_INSNS (3),                   /*                               SI */
1974    COSTS_N_INSNS (4),                   /*                               DI */
1975    COSTS_N_INSNS (2)},                  /*                            other */
1976   0,                                    /* cost of multiply per each bit set */
1977   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1978    COSTS_N_INSNS (26),                  /*                          HI */
1979    COSTS_N_INSNS (42),                  /*                          SI */
1980    COSTS_N_INSNS (74),                  /*                          DI */
1981    COSTS_N_INSNS (74)},                 /*                          other */
1982   COSTS_N_INSNS (1),                    /* cost of movsx */
1983   COSTS_N_INSNS (1),                    /* cost of movzx */
1984   8,                                    /* "large" insn */
1985   17,                                   /* MOVE_RATIO */
1986   4,                                 /* cost for loading QImode using movzbl */
1987   {4, 4, 4},                            /* cost of loading integer registers
1988                                            in QImode, HImode and SImode.
1989                                            Relative to reg-reg move (2).  */
1990   {4, 4, 4},                            /* cost of storing integer registers */
1991   4,                                    /* cost of reg,reg fld/fst */
1992   {12, 12, 12},                         /* cost of loading fp registers
1993                                            in SFmode, DFmode and XFmode */
1994   {6, 6, 8},                            /* cost of storing fp registers
1995                                            in SFmode, DFmode and XFmode */
1996   2,                                    /* cost of moving MMX register */
1997   {8, 8},                               /* cost of loading MMX registers
1998                                            in SImode and DImode */
1999   {8, 8},                               /* cost of storing MMX registers
2000                                            in SImode and DImode */
2001   2,                                    /* cost of moving SSE register */
2002   {8, 8, 8},                            /* cost of loading SSE registers
2003                                            in SImode, DImode and TImode */
2004   {8, 8, 8},                            /* cost of storing SSE registers
2005                                            in SImode, DImode and TImode */
2006   5,                                    /* MMX or SSE register to integer */
2007   64,                                   /* size of l1 cache.  */
2008   512,                                  /* size of l2 cache.  */
2009   64,                                   /* size of prefetch block */
2010   6,                                    /* number of parallel prefetches */
2011   /* FIXME perhaps more appropriate value is 5.  */
2012   3,                                    /* Branch cost */
2013   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
2014   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
2015   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
2016   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
2017   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
2018   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
2019   core_memcpy,
2020   core_memset,
2021   1,                                    /* scalar_stmt_cost.  */
2022   1,                                    /* scalar load_cost.  */
2023   1,                                    /* scalar_store_cost.  */
2024   1,                                    /* vec_stmt_cost.  */
2025   1,                                    /* vec_to_scalar_cost.  */
2026   1,                                    /* scalar_to_vec_cost.  */
2027   1,                                    /* vec_align_load_cost.  */
2028   2,                                    /* vec_unalign_load_cost.  */
2029   1,                                    /* vec_store_cost.  */
2030   3,                                    /* cond_taken_branch_cost.  */
2031   1,                                    /* cond_not_taken_branch_cost.  */
2032 };
2033
2034
2035 /* Set by -mtune.  */
2036 const struct processor_costs *ix86_tune_cost = &pentium_cost;
2037
2038 /* Set by -mtune or -Os.  */
2039 const struct processor_costs *ix86_cost = &pentium_cost;
2040
2041 /* Processor feature/optimization bitmasks.  */
2042 #define m_386 (1<<PROCESSOR_I386)
2043 #define m_486 (1<<PROCESSOR_I486)
2044 #define m_PENT (1<<PROCESSOR_PENTIUM)
2045 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
2046 #define m_PENT4 (1<<PROCESSOR_PENTIUM4)
2047 #define m_NOCONA (1<<PROCESSOR_NOCONA)
2048 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
2049 #define m_CORE2 (1<<PROCESSOR_CORE2)
2050 #define m_NEHALEM (1<<PROCESSOR_NEHALEM)
2051 #define m_SANDYBRIDGE (1<<PROCESSOR_SANDYBRIDGE)
2052 #define m_HASWELL (1<<PROCESSOR_HASWELL)
2053 #define m_CORE_ALL (m_CORE2 | m_NEHALEM  | m_SANDYBRIDGE | m_HASWELL)
2054 #define m_BONNELL (1<<PROCESSOR_BONNELL)
2055 #define m_SILVERMONT (1<<PROCESSOR_SILVERMONT)
2056 #define m_KNL (1<<PROCESSOR_KNL)
2057 #define m_INTEL (1<<PROCESSOR_INTEL)
2058
2059 #define m_GEODE (1<<PROCESSOR_GEODE)
2060 #define m_K6 (1<<PROCESSOR_K6)
2061 #define m_K6_GEODE (m_K6 | m_GEODE)
2062 #define m_K8 (1<<PROCESSOR_K8)
2063 #define m_ATHLON (1<<PROCESSOR_ATHLON)
2064 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
2065 #define m_AMDFAM10 (1<<PROCESSOR_AMDFAM10)
2066 #define m_BDVER1 (1<<PROCESSOR_BDVER1)
2067 #define m_BDVER2 (1<<PROCESSOR_BDVER2)
2068 #define m_BDVER3 (1<<PROCESSOR_BDVER3)
2069 #define m_BDVER4 (1<<PROCESSOR_BDVER4)
2070 #define m_BTVER1 (1<<PROCESSOR_BTVER1)
2071 #define m_BTVER2 (1<<PROCESSOR_BTVER2)
2072 #define m_BDVER (m_BDVER1 | m_BDVER2 | m_BDVER3 | m_BDVER4)
2073 #define m_BTVER (m_BTVER1 | m_BTVER2)
2074 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER)
2075
2076 #define m_GENERIC (1<<PROCESSOR_GENERIC)
2077
2078 const char* ix86_tune_feature_names[X86_TUNE_LAST] = {
2079 #undef DEF_TUNE
2080 #define DEF_TUNE(tune, name, selector) name,
2081 #include "x86-tune.def"
2082 #undef DEF_TUNE
2083 };
2084
2085 /* Feature tests against the various tunings.  */
2086 unsigned char ix86_tune_features[X86_TUNE_LAST];
2087
2088 /* Feature tests against the various tunings used to create ix86_tune_features
2089    based on the processor mask.  */
2090 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
2091 #undef DEF_TUNE
2092 #define DEF_TUNE(tune, name, selector) selector,
2093 #include "x86-tune.def"
2094 #undef DEF_TUNE
2095 };
2096
2097 /* Feature tests against the various architecture variations.  */
2098 unsigned char ix86_arch_features[X86_ARCH_LAST];
2099
2100 /* Feature tests against the various architecture variations, used to create
2101    ix86_arch_features based on the processor mask.  */
2102 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
2103   /* X86_ARCH_CMOV: Conditional move was added for pentiumpro.  */
2104   ~(m_386 | m_486 | m_PENT | m_K6),
2105
2106   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
2107   ~m_386,
2108
2109   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
2110   ~(m_386 | m_486),
2111
2112   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
2113   ~m_386,
2114
2115   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
2116   ~m_386,
2117 };
2118
2119 /* In case the average insn count for single function invocation is
2120    lower than this constant, emit fast (but longer) prologue and
2121    epilogue code.  */
2122 #define FAST_PROLOGUE_INSN_COUNT 20
2123
2124 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
2125 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
2126 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
2127 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
2128
2129 /* Array of the smallest class containing reg number REGNO, indexed by
2130    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
2131
2132 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
2133 {
2134   /* ax, dx, cx, bx */
2135   AREG, DREG, CREG, BREG,
2136   /* si, di, bp, sp */
2137   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
2138   /* FP registers */
2139   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
2140   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
2141   /* arg pointer */
2142   NON_Q_REGS,
2143   /* flags, fpsr, fpcr, frame */
2144   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
2145   /* SSE registers */
2146   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2147   SSE_REGS, SSE_REGS,
2148   /* MMX registers */
2149   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
2150   MMX_REGS, MMX_REGS,
2151   /* REX registers */
2152   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2153   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2154   /* SSE REX registers */
2155   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2156   SSE_REGS, SSE_REGS,
2157   /* AVX-512 SSE registers */
2158   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
2159   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
2160   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
2161   EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS, EVEX_SSE_REGS,
2162   /* Mask registers.  */
2163   MASK_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS,
2164   MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS, MASK_EVEX_REGS,
2165   /* MPX bound registers */
2166   BND_REGS, BND_REGS, BND_REGS, BND_REGS,
2167 };
2168
2169 /* The "default" register map used in 32bit mode.  */
2170
2171 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
2172 {
2173   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
2174   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
2175   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2176   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
2177   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
2178   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2179   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2180   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 16-23*/
2181   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 24-31*/
2182   93, 94, 95, 96, 97, 98, 99, 100,      /* Mask registers */
2183   101, 102, 103, 104,                   /* bound registers */
2184 };
2185
2186 /* The "default" register map used in 64bit mode.  */
2187
2188 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
2189 {
2190   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
2191   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
2192   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2193   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
2194   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
2195   8,9,10,11,12,13,14,15,                /* extended integer registers */
2196   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
2197   67, 68, 69, 70, 71, 72, 73, 74,       /* AVX-512 registers 16-23 */
2198   75, 76, 77, 78, 79, 80, 81, 82,       /* AVX-512 registers 24-31 */
2199   118, 119, 120, 121, 122, 123, 124, 125, /* Mask registers */
2200   126, 127, 128, 129,                   /* bound registers */
2201 };
2202
2203 /* Define the register numbers to be used in Dwarf debugging information.
2204    The SVR4 reference port C compiler uses the following register numbers
2205    in its Dwarf output code:
2206         0 for %eax (gcc regno = 0)
2207         1 for %ecx (gcc regno = 2)
2208         2 for %edx (gcc regno = 1)
2209         3 for %ebx (gcc regno = 3)
2210         4 for %esp (gcc regno = 7)
2211         5 for %ebp (gcc regno = 6)
2212         6 for %esi (gcc regno = 4)
2213         7 for %edi (gcc regno = 5)
2214    The following three DWARF register numbers are never generated by
2215    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
2216    believes these numbers have these meanings.
2217         8  for %eip    (no gcc equivalent)
2218         9  for %eflags (gcc regno = 17)
2219         10 for %trapno (no gcc equivalent)
2220    It is not at all clear how we should number the FP stack registers
2221    for the x86 architecture.  If the version of SDB on x86/svr4 were
2222    a bit less brain dead with respect to floating-point then we would
2223    have a precedent to follow with respect to DWARF register numbers
2224    for x86 FP registers, but the SDB on x86/svr4 is so completely
2225    broken with respect to FP registers that it is hardly worth thinking
2226    of it as something to strive for compatibility with.
2227    The version of x86/svr4 SDB I have at the moment does (partially)
2228    seem to believe that DWARF register number 11 is associated with
2229    the x86 register %st(0), but that's about all.  Higher DWARF
2230    register numbers don't seem to be associated with anything in
2231    particular, and even for DWARF regno 11, SDB only seems to under-
2232    stand that it should say that a variable lives in %st(0) (when
2233    asked via an `=' command) if we said it was in DWARF regno 11,
2234    but SDB still prints garbage when asked for the value of the
2235    variable in question (via a `/' command).
2236    (Also note that the labels SDB prints for various FP stack regs
2237    when doing an `x' command are all wrong.)
2238    Note that these problems generally don't affect the native SVR4
2239    C compiler because it doesn't allow the use of -O with -g and
2240    because when it is *not* optimizing, it allocates a memory
2241    location for each floating-point variable, and the memory
2242    location is what gets described in the DWARF AT_location
2243    attribute for the variable in question.
2244    Regardless of the severe mental illness of the x86/svr4 SDB, we
2245    do something sensible here and we use the following DWARF
2246    register numbers.  Note that these are all stack-top-relative
2247    numbers.
2248         11 for %st(0) (gcc regno = 8)
2249         12 for %st(1) (gcc regno = 9)
2250         13 for %st(2) (gcc regno = 10)
2251         14 for %st(3) (gcc regno = 11)
2252         15 for %st(4) (gcc regno = 12)
2253         16 for %st(5) (gcc regno = 13)
2254         17 for %st(6) (gcc regno = 14)
2255         18 for %st(7) (gcc regno = 15)
2256 */
2257 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
2258 {
2259   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
2260   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
2261   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
2262   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
2263   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
2264   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2265   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2266   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 16-23*/
2267   -1, -1, -1, -1, -1, -1, -1, -1,       /* AVX-512 registers 24-31*/
2268   93, 94, 95, 96, 97, 98, 99, 100,      /* Mask registers */
2269   101, 102, 103, 104,                   /* bound registers */
2270 };
2271
2272 /* Define parameter passing and return registers.  */
2273
2274 static int const x86_64_int_parameter_registers[6] =
2275 {
2276   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
2277 };
2278
2279 static int const x86_64_ms_abi_int_parameter_registers[4] =
2280 {
2281   CX_REG, DX_REG, R8_REG, R9_REG
2282 };
2283
2284 static int const x86_64_int_return_registers[4] =
2285 {
2286   AX_REG, DX_REG, DI_REG, SI_REG
2287 };
2288
2289 /* Additional registers that are clobbered by SYSV calls.  */
2290
2291 int const x86_64_ms_sysv_extra_clobbered_registers[12] =
2292 {
2293   SI_REG, DI_REG,
2294   XMM6_REG, XMM7_REG,
2295   XMM8_REG, XMM9_REG, XMM10_REG, XMM11_REG,
2296   XMM12_REG, XMM13_REG, XMM14_REG, XMM15_REG
2297 };
2298
2299 /* Define the structure for the machine field in struct function.  */
2300
2301 struct GTY(()) stack_local_entry {
2302   unsigned short mode;
2303   unsigned short n;
2304   rtx rtl;
2305   struct stack_local_entry *next;
2306 };
2307
2308 /* Structure describing stack frame layout.
2309    Stack grows downward:
2310
2311    [arguments]
2312                                         <- ARG_POINTER
2313    saved pc
2314
2315    saved static chain                   if ix86_static_chain_on_stack
2316
2317    saved frame pointer                  if frame_pointer_needed
2318                                         <- HARD_FRAME_POINTER
2319    [saved regs]
2320                                         <- regs_save_offset
2321    [padding0]
2322
2323    [saved SSE regs]
2324                                         <- sse_regs_save_offset
2325    [padding1]          |
2326                        |                <- FRAME_POINTER
2327    [va_arg registers]  |
2328                        |
2329    [frame]             |
2330                        |
2331    [padding2]          | = to_allocate
2332                                         <- STACK_POINTER
2333   */
2334 struct ix86_frame
2335 {
2336   int nsseregs;
2337   int nregs;
2338   int va_arg_size;
2339   int red_zone_size;
2340   int outgoing_arguments_size;
2341
2342   /* The offsets relative to ARG_POINTER.  */
2343   HOST_WIDE_INT frame_pointer_offset;
2344   HOST_WIDE_INT hard_frame_pointer_offset;
2345   HOST_WIDE_INT stack_pointer_offset;
2346   HOST_WIDE_INT hfp_save_offset;
2347   HOST_WIDE_INT reg_save_offset;
2348   HOST_WIDE_INT sse_reg_save_offset;
2349
2350   /* When save_regs_using_mov is set, emit prologue using
2351      move instead of push instructions.  */
2352   bool save_regs_using_mov;
2353 };
2354
2355 /* Which cpu are we scheduling for.  */
2356 enum attr_cpu ix86_schedule;
2357
2358 /* Which cpu are we optimizing for.  */
2359 enum processor_type ix86_tune;
2360
2361 /* Which instruction set architecture to use.  */
2362 enum processor_type ix86_arch;
2363
2364 /* True if processor has SSE prefetch instruction.  */
2365 unsigned char x86_prefetch_sse;
2366
2367 /* -mstackrealign option */
2368 static const char ix86_force_align_arg_pointer_string[]
2369   = "force_align_arg_pointer";
2370
2371 static rtx (*ix86_gen_leave) (void);
2372 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
2373 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
2374 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
2375 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
2376 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
2377 static rtx (*ix86_gen_monitorx) (rtx, rtx, rtx);
2378 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
2379 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
2380 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
2381 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
2382 static rtx (*ix86_gen_tls_global_dynamic_64) (rtx, rtx, rtx);
2383 static rtx (*ix86_gen_tls_local_dynamic_base_64) (rtx, rtx);
2384
2385 /* Preferred alignment for stack boundary in bits.  */
2386 unsigned int ix86_preferred_stack_boundary;
2387
2388 /* Alignment for incoming stack boundary in bits specified at
2389    command line.  */
2390 static unsigned int ix86_user_incoming_stack_boundary;
2391
2392 /* Default alignment for incoming stack boundary in bits.  */
2393 static unsigned int ix86_default_incoming_stack_boundary;
2394
2395 /* Alignment for incoming stack boundary in bits.  */
2396 unsigned int ix86_incoming_stack_boundary;
2397
2398 /* Calling abi specific va_list type nodes.  */
2399 static GTY(()) tree sysv_va_list_type_node;
2400 static GTY(()) tree ms_va_list_type_node;
2401
2402 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
2403 char internal_label_prefix[16];
2404 int internal_label_prefix_len;
2405
2406 /* Fence to use after loop using movnt.  */
2407 tree x86_mfence;
2408
2409 /* Register class used for passing given 64bit part of the argument.
2410    These represent classes as documented by the PS ABI, with the exception
2411    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
2412    use SF or DFmode move instead of DImode to avoid reformatting penalties.
2413
2414    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
2415    whenever possible (upper half does contain padding).  */
2416 enum x86_64_reg_class
2417   {
2418     X86_64_NO_CLASS,
2419     X86_64_INTEGER_CLASS,
2420     X86_64_INTEGERSI_CLASS,
2421     X86_64_SSE_CLASS,
2422     X86_64_SSESF_CLASS,
2423     X86_64_SSEDF_CLASS,
2424     X86_64_SSEUP_CLASS,
2425     X86_64_X87_CLASS,
2426     X86_64_X87UP_CLASS,
2427     X86_64_COMPLEX_X87_CLASS,
2428     X86_64_MEMORY_CLASS
2429   };
2430
2431 #define MAX_CLASSES 8
2432
2433 /* Table of constants used by fldpi, fldln2, etc....  */
2434 static REAL_VALUE_TYPE ext_80387_constants_table [5];
2435 static bool ext_80387_constants_init = 0;
2436
2437 \f
2438 static struct machine_function * ix86_init_machine_status (void);
2439 static rtx ix86_function_value (const_tree, const_tree, bool);
2440 static bool ix86_function_value_regno_p (const unsigned int);
2441 static unsigned int ix86_function_arg_boundary (machine_mode,
2442                                                 const_tree);
2443 static rtx ix86_static_chain (const_tree, bool);
2444 static int ix86_function_regparm (const_tree, const_tree);
2445 static void ix86_compute_frame_layout (struct ix86_frame *);
2446 static bool ix86_expand_vector_init_one_nonzero (bool, machine_mode,
2447                                                  rtx, rtx, int);
2448 static void ix86_add_new_builtins (HOST_WIDE_INT);
2449 static tree ix86_canonical_va_list_type (tree);
2450 static void predict_jump (int);
2451 static unsigned int split_stack_prologue_scratch_regno (void);
2452 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
2453
2454 enum ix86_function_specific_strings
2455 {
2456   IX86_FUNCTION_SPECIFIC_ARCH,
2457   IX86_FUNCTION_SPECIFIC_TUNE,
2458   IX86_FUNCTION_SPECIFIC_MAX
2459 };
2460
2461 static char *ix86_target_string (HOST_WIDE_INT, int, const char *,
2462                                  const char *, enum fpmath_unit, bool);
2463 static void ix86_function_specific_save (struct cl_target_option *,
2464                                          struct gcc_options *opts);
2465 static void ix86_function_specific_restore (struct gcc_options *opts,
2466                                             struct cl_target_option *);
2467 static void ix86_function_specific_post_stream_in (struct cl_target_option *);
2468 static void ix86_function_specific_print (FILE *, int,
2469                                           struct cl_target_option *);
2470 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
2471 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
2472                                                  struct gcc_options *,
2473                                                  struct gcc_options *,
2474                                                  struct gcc_options *);
2475 static bool ix86_can_inline_p (tree, tree);
2476 static void ix86_set_current_function (tree);
2477 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
2478
2479 static enum calling_abi ix86_function_abi (const_tree);
2480
2481 \f
2482 #ifndef SUBTARGET32_DEFAULT_CPU
2483 #define SUBTARGET32_DEFAULT_CPU "i386"
2484 #endif
2485
2486 /* Whether -mtune= or -march= were specified */
2487 static int ix86_tune_defaulted;
2488 static int ix86_arch_specified;
2489
2490 /* Vectorization library interface and handlers.  */
2491 static tree (*ix86_veclib_handler) (enum built_in_function, tree, tree);
2492
2493 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2494 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2495
2496 /* Processor target table, indexed by processor number */
2497 struct ptt
2498 {
2499   const char *const name;                       /* processor name  */
2500   const struct processor_costs *cost;           /* Processor costs */
2501   const int align_loop;                         /* Default alignments.  */
2502   const int align_loop_max_skip;
2503   const int align_jump;
2504   const int align_jump_max_skip;
2505   const int align_func;
2506 };
2507
2508 /* This table must be in sync with enum processor_type in i386.h.  */ 
2509 static const struct ptt processor_target_table[PROCESSOR_max] =
2510 {
2511   {"generic", &generic_cost, 16, 10, 16, 10, 16},
2512   {"i386", &i386_cost, 4, 3, 4, 3, 4},
2513   {"i486", &i486_cost, 16, 15, 16, 15, 16},
2514   {"pentium", &pentium_cost, 16, 7, 16, 7, 16},
2515   {"pentiumpro", &pentiumpro_cost, 16, 15, 16, 10, 16},
2516   {"pentium4", &pentium4_cost, 0, 0, 0, 0, 0},
2517   {"nocona", &nocona_cost, 0, 0, 0, 0, 0},
2518   {"core2", &core_cost, 16, 10, 16, 10, 16},
2519   {"nehalem", &core_cost, 16, 10, 16, 10, 16},
2520   {"sandybridge", &core_cost, 16, 10, 16, 10, 16},
2521   {"haswell", &core_cost, 16, 10, 16, 10, 16},
2522   {"bonnell", &atom_cost, 16, 15, 16, 7, 16},
2523   {"silvermont", &slm_cost, 16, 15, 16, 7, 16},
2524   {"knl", &slm_cost, 16, 15, 16, 7, 16},
2525   {"intel", &intel_cost, 16, 15, 16, 7, 16},
2526   {"geode", &geode_cost, 0, 0, 0, 0, 0},
2527   {"k6", &k6_cost, 32, 7, 32, 7, 32},
2528   {"athlon", &athlon_cost, 16, 7, 16, 7, 16},
2529   {"k8", &k8_cost, 16, 7, 16, 7, 16},
2530   {"amdfam10", &amdfam10_cost, 32, 24, 32, 7, 32},
2531   {"bdver1", &bdver1_cost, 16, 10, 16, 7, 11},
2532   {"bdver2", &bdver2_cost, 16, 10, 16, 7, 11},
2533   {"bdver3", &bdver3_cost, 16, 10, 16, 7, 11},
2534   {"bdver4", &bdver4_cost, 16, 10, 16, 7, 11},
2535   {"btver1", &btver1_cost, 16, 10, 16, 7, 11},
2536   {"btver2", &btver2_cost, 16, 10, 16, 7, 11}
2537 };
2538 \f
2539 static unsigned int
2540 rest_of_handle_insert_vzeroupper (void)
2541 {
2542   int i;
2543
2544   /* vzeroupper instructions are inserted immediately after reload to
2545      account for possible spills from 256bit registers.  The pass
2546      reuses mode switching infrastructure by re-running mode insertion
2547      pass, so disable entities that have already been processed.  */
2548   for (i = 0; i < MAX_386_ENTITIES; i++)
2549     ix86_optimize_mode_switching[i] = 0;
2550
2551   ix86_optimize_mode_switching[AVX_U128] = 1;
2552
2553   /* Call optimize_mode_switching.  */
2554   g->get_passes ()->execute_pass_mode_switching ();
2555   return 0;
2556 }
2557
2558 namespace {
2559
2560 const pass_data pass_data_insert_vzeroupper =
2561 {
2562   RTL_PASS, /* type */
2563   "vzeroupper", /* name */
2564   OPTGROUP_NONE, /* optinfo_flags */
2565   TV_NONE, /* tv_id */
2566   0, /* properties_required */
2567   0, /* properties_provided */
2568   0, /* properties_destroyed */
2569   0, /* todo_flags_start */
2570   TODO_df_finish, /* todo_flags_finish */
2571 };
2572
2573 class pass_insert_vzeroupper : public rtl_opt_pass
2574 {
2575 public:
2576   pass_insert_vzeroupper(gcc::context *ctxt)
2577     : rtl_opt_pass(pass_data_insert_vzeroupper, ctxt)
2578   {}
2579
2580   /* opt_pass methods: */
2581   virtual bool gate (function *)
2582     {
2583       return TARGET_AVX && !TARGET_AVX512F
2584              && TARGET_VZEROUPPER && flag_expensive_optimizations
2585              && !optimize_size;
2586     }
2587
2588   virtual unsigned int execute (function *)
2589     {
2590       return rest_of_handle_insert_vzeroupper ();
2591     }
2592
2593 }; // class pass_insert_vzeroupper
2594
2595 } // anon namespace
2596
2597 rtl_opt_pass *
2598 make_pass_insert_vzeroupper (gcc::context *ctxt)
2599 {
2600   return new pass_insert_vzeroupper (ctxt);
2601 }
2602
2603 /* Return true if a red-zone is in use.  */
2604
2605 static inline bool
2606 ix86_using_red_zone (void)
2607 {
2608   return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;
2609 }
2610 \f
2611 /* Return a string that documents the current -m options.  The caller is
2612    responsible for freeing the string.  */
2613
2614 static char *
2615 ix86_target_string (HOST_WIDE_INT isa, int flags, const char *arch,
2616                     const char *tune, enum fpmath_unit fpmath,
2617                     bool add_nl_p)
2618 {
2619   struct ix86_target_opts
2620   {
2621     const char *option;         /* option string */
2622     HOST_WIDE_INT mask;         /* isa mask options */
2623   };
2624
2625   /* This table is ordered so that options like -msse4.2 that imply
2626      preceding options while match those first.  */
2627   static struct ix86_target_opts isa_opts[] =
2628   {
2629     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2630     { "-mfma",          OPTION_MASK_ISA_FMA },
2631     { "-mxop",          OPTION_MASK_ISA_XOP },
2632     { "-mlwp",          OPTION_MASK_ISA_LWP },
2633     { "-mavx512f",      OPTION_MASK_ISA_AVX512F },
2634     { "-mavx512er",     OPTION_MASK_ISA_AVX512ER },
2635     { "-mavx512cd",     OPTION_MASK_ISA_AVX512CD },
2636     { "-mavx512pf",     OPTION_MASK_ISA_AVX512PF },
2637     { "-mavx512dq",     OPTION_MASK_ISA_AVX512DQ },
2638     { "-mavx512bw",     OPTION_MASK_ISA_AVX512BW },
2639     { "-mavx512vl",     OPTION_MASK_ISA_AVX512VL },
2640     { "-mavx512ifma",   OPTION_MASK_ISA_AVX512IFMA },
2641     { "-mavx512vbmi",   OPTION_MASK_ISA_AVX512VBMI },
2642     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2643     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2644     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2645     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2646     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2647     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2648     { "-msse",          OPTION_MASK_ISA_SSE },
2649     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2650     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2651     { "-mmmx",          OPTION_MASK_ISA_MMX },
2652     { "-mabm",          OPTION_MASK_ISA_ABM },
2653     { "-mbmi",          OPTION_MASK_ISA_BMI },
2654     { "-mbmi2",         OPTION_MASK_ISA_BMI2 },
2655     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2656     { "-mhle",          OPTION_MASK_ISA_HLE },
2657     { "-mfxsr",         OPTION_MASK_ISA_FXSR },
2658     { "-mrdseed",       OPTION_MASK_ISA_RDSEED },
2659     { "-mprfchw",       OPTION_MASK_ISA_PRFCHW },
2660     { "-madx",          OPTION_MASK_ISA_ADX },
2661     { "-mtbm",          OPTION_MASK_ISA_TBM },
2662     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2663     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2664     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2665     { "-maes",          OPTION_MASK_ISA_AES },
2666     { "-msha",          OPTION_MASK_ISA_SHA },
2667     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2668     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2669     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2670     { "-mf16c",         OPTION_MASK_ISA_F16C },
2671     { "-mrtm",          OPTION_MASK_ISA_RTM },
2672     { "-mxsave",        OPTION_MASK_ISA_XSAVE },
2673     { "-mxsaveopt",     OPTION_MASK_ISA_XSAVEOPT },
2674     { "-mprefetchwt1",  OPTION_MASK_ISA_PREFETCHWT1 },
2675     { "-mclflushopt",   OPTION_MASK_ISA_CLFLUSHOPT },
2676     { "-mxsavec",       OPTION_MASK_ISA_XSAVEC },
2677     { "-mxsaves",       OPTION_MASK_ISA_XSAVES },
2678     { "-mmpx",          OPTION_MASK_ISA_MPX },
2679     { "-mclwb",         OPTION_MASK_ISA_CLWB },
2680     { "-mpcommit",      OPTION_MASK_ISA_PCOMMIT },
2681     { "-mmwaitx",       OPTION_MASK_ISA_MWAITX  },
2682   };
2683
2684   /* Flag options.  */
2685   static struct ix86_target_opts flag_opts[] =
2686   {
2687     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2688     { "-mlong-double-128",              MASK_LONG_DOUBLE_128 },
2689     { "-mlong-double-64",               MASK_LONG_DOUBLE_64 },
2690     { "-m80387",                        MASK_80387 },
2691     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2692     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2693     { "-mcld",                          MASK_CLD },
2694     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2695     { "-mieee-fp",                      MASK_IEEE_FP },
2696     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2697     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2698     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2699     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2700     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2701     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2702     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2703     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2704     { "-mrecip",                        MASK_RECIP },
2705     { "-mrtd",                          MASK_RTD },
2706     { "-msseregparm",                   MASK_SSEREGPARM },
2707     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2708     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2709     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2710     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2711     { "-mvzeroupper",                   MASK_VZEROUPPER },
2712     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2713     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2714     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2715   };
2716
2717   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2718
2719   char isa_other[40];
2720   char target_other[40];
2721   unsigned num = 0;
2722   unsigned i, j;
2723   char *ret;
2724   char *ptr;
2725   size_t len;
2726   size_t line_len;
2727   size_t sep_len;
2728   const char *abi;
2729
2730   memset (opts, '\0', sizeof (opts));
2731
2732   /* Add -march= option.  */
2733   if (arch)
2734     {
2735       opts[num][0] = "-march=";
2736       opts[num++][1] = arch;
2737     }
2738
2739   /* Add -mtune= option.  */
2740   if (tune)
2741     {
2742       opts[num][0] = "-mtune=";
2743       opts[num++][1] = tune;
2744     }
2745
2746   /* Add -m32/-m64/-mx32.  */
2747   if ((isa & OPTION_MASK_ISA_64BIT) != 0)
2748     {
2749       if ((isa & OPTION_MASK_ABI_64) != 0)
2750         abi = "-m64";
2751       else
2752         abi = "-mx32";
2753       isa &= ~ (OPTION_MASK_ISA_64BIT
2754                 | OPTION_MASK_ABI_64
2755                 | OPTION_MASK_ABI_X32);
2756     }
2757   else
2758     abi = "-m32";
2759   opts[num++][0] = abi;
2760
2761   /* Pick out the options in isa options.  */
2762   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2763     {
2764       if ((isa & isa_opts[i].mask) != 0)
2765         {
2766           opts[num++][0] = isa_opts[i].option;
2767           isa &= ~ isa_opts[i].mask;
2768         }
2769     }
2770
2771   if (isa && add_nl_p)
2772     {
2773       opts[num++][0] = isa_other;
2774       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)",
2775                isa);
2776     }
2777
2778   /* Add flag options.  */
2779   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2780     {
2781       if ((flags & flag_opts[i].mask) != 0)
2782         {
2783           opts[num++][0] = flag_opts[i].option;
2784           flags &= ~ flag_opts[i].mask;
2785         }
2786     }
2787
2788   if (flags && add_nl_p)
2789     {
2790       opts[num++][0] = target_other;
2791       sprintf (target_other, "(other flags: %#x)", flags);
2792     }
2793
2794   /* Add -fpmath= option.  */
2795   if (fpmath)
2796     {
2797       opts[num][0] = "-mfpmath=";
2798       switch ((int) fpmath)
2799         {
2800         case FPMATH_387:
2801           opts[num++][1] = "387";
2802           break;
2803
2804         case FPMATH_SSE:
2805           opts[num++][1] = "sse";
2806           break;
2807
2808         case FPMATH_387 | FPMATH_SSE:
2809           opts[num++][1] = "sse+387";
2810           break;
2811
2812         default:
2813           gcc_unreachable ();
2814         }
2815     }
2816
2817   /* Any options?  */
2818   if (num == 0)
2819     return NULL;
2820
2821   gcc_assert (num < ARRAY_SIZE (opts));
2822
2823   /* Size the string.  */
2824   len = 0;
2825   sep_len = (add_nl_p) ? 3 : 1;
2826   for (i = 0; i < num; i++)
2827     {
2828       len += sep_len;
2829       for (j = 0; j < 2; j++)
2830         if (opts[i][j])
2831           len += strlen (opts[i][j]);
2832     }
2833
2834   /* Build the string.  */
2835   ret = ptr = (char *) xmalloc (len);
2836   line_len = 0;
2837
2838   for (i = 0; i < num; i++)
2839     {
2840       size_t len2[2];
2841
2842       for (j = 0; j < 2; j++)
2843         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2844
2845       if (i != 0)
2846         {
2847           *ptr++ = ' ';
2848           line_len++;
2849
2850           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2851             {
2852               *ptr++ = '\\';
2853               *ptr++ = '\n';
2854               line_len = 0;
2855             }
2856         }
2857
2858       for (j = 0; j < 2; j++)
2859         if (opts[i][j])
2860           {
2861             memcpy (ptr, opts[i][j], len2[j]);
2862             ptr += len2[j];
2863             line_len += len2[j];
2864           }
2865     }
2866
2867   *ptr = '\0';
2868   gcc_assert (ret + len >= ptr);
2869
2870   return ret;
2871 }
2872
2873 /* Return true, if profiling code should be emitted before
2874    prologue. Otherwise it returns false.
2875    Note: For x86 with "hotfix" it is sorried.  */
2876 static bool
2877 ix86_profile_before_prologue (void)
2878 {
2879   return flag_fentry != 0;
2880 }
2881
2882 /* Function that is callable from the debugger to print the current
2883    options.  */
2884 void ATTRIBUTE_UNUSED
2885 ix86_debug_options (void)
2886 {
2887   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2888                                    ix86_arch_string, ix86_tune_string,
2889                                    ix86_fpmath, true);
2890
2891   if (opts)
2892     {
2893       fprintf (stderr, "%s\n\n", opts);
2894       free (opts);
2895     }
2896   else
2897     fputs ("<no options>\n\n", stderr);
2898
2899   return;
2900 }
2901
2902 static const char *stringop_alg_names[] = {
2903 #define DEF_ENUM
2904 #define DEF_ALG(alg, name) #name,
2905 #include "stringop.def"
2906 #undef DEF_ENUM
2907 #undef DEF_ALG
2908 };
2909
2910 /* Parse parameter string passed to -mmemcpy-strategy= or -mmemset-strategy=.
2911    The string is of the following form (or comma separated list of it):
2912
2913      strategy_alg:max_size:[align|noalign]
2914
2915    where the full size range for the strategy is either [0, max_size] or