OSDN Git Service

84b652f2f8129f6fb55257004c049b9ffe4d4934
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / i386.c
1 /* Subroutines used for code generation on IA-32.
2    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "tm_p.h"
29 #include "regs.h"
30 #include "hard-reg-set.h"
31 #include "real.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "output.h"
35 #include "insn-codes.h"
36 #include "insn-attr.h"
37 #include "flags.h"
38 #include "except.h"
39 #include "function.h"
40 #include "recog.h"
41 #include "expr.h"
42 #include "optabs.h"
43 #include "toplev.h"
44 #include "basic-block.h"
45 #include "ggc.h"
46 #include "target.h"
47 #include "target-def.h"
48 #include "langhooks.h"
49 #include "cgraph.h"
50 #include "gimple.h"
51 #include "dwarf2.h"
52 #include "df.h"
53 #include "tm-constrs.h"
54 #include "params.h"
55 #include "cselib.h"
56
57 static rtx legitimize_dllimport_symbol (rtx, bool);
58
59 #ifndef CHECK_STACK_LIMIT
60 #define CHECK_STACK_LIMIT (-1)
61 #endif
62
63 /* Return index of given mode in mult and division cost tables.  */
64 #define MODE_INDEX(mode)                                        \
65   ((mode) == QImode ? 0                                         \
66    : (mode) == HImode ? 1                                       \
67    : (mode) == SImode ? 2                                       \
68    : (mode) == DImode ? 3                                       \
69    : 4)
70
71 /* Processor costs (relative to an add) */
72 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
73 #define COSTS_N_BYTES(N) ((N) * 2)
74
75 #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall}}}
76
77 const
78 struct processor_costs ix86_size_cost = {/* costs for tuning for size */
79   COSTS_N_BYTES (2),                    /* cost of an add instruction */
80   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
81   COSTS_N_BYTES (2),                    /* variable shift costs */
82   COSTS_N_BYTES (3),                    /* constant shift costs */
83   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
84    COSTS_N_BYTES (3),                   /*                               HI */
85    COSTS_N_BYTES (3),                   /*                               SI */
86    COSTS_N_BYTES (3),                   /*                               DI */
87    COSTS_N_BYTES (5)},                  /*                            other */
88   0,                                    /* cost of multiply per each bit set */
89   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
90    COSTS_N_BYTES (3),                   /*                          HI */
91    COSTS_N_BYTES (3),                   /*                          SI */
92    COSTS_N_BYTES (3),                   /*                          DI */
93    COSTS_N_BYTES (5)},                  /*                       other */
94   COSTS_N_BYTES (3),                    /* cost of movsx */
95   COSTS_N_BYTES (3),                    /* cost of movzx */
96   0,                                    /* "large" insn */
97   2,                                    /* MOVE_RATIO */
98   2,                                    /* cost for loading QImode using movzbl */
99   {2, 2, 2},                            /* cost of loading integer registers
100                                            in QImode, HImode and SImode.
101                                            Relative to reg-reg move (2).  */
102   {2, 2, 2},                            /* cost of storing integer registers */
103   2,                                    /* cost of reg,reg fld/fst */
104   {2, 2, 2},                            /* cost of loading fp registers
105                                            in SFmode, DFmode and XFmode */
106   {2, 2, 2},                            /* cost of storing fp registers
107                                            in SFmode, DFmode and XFmode */
108   3,                                    /* cost of moving MMX register */
109   {3, 3},                               /* cost of loading MMX registers
110                                            in SImode and DImode */
111   {3, 3},                               /* cost of storing MMX registers
112                                            in SImode and DImode */
113   3,                                    /* cost of moving SSE register */
114   {3, 3, 3},                            /* cost of loading SSE registers
115                                            in SImode, DImode and TImode */
116   {3, 3, 3},                            /* cost of storing SSE registers
117                                            in SImode, DImode and TImode */
118   3,                                    /* MMX or SSE register to integer */
119   0,                                    /* size of l1 cache  */
120   0,                                    /* size of l2 cache  */
121   0,                                    /* size of prefetch block */
122   0,                                    /* number of parallel prefetches */
123   2,                                    /* Branch cost */
124   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
125   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
126   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
127   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
128   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
129   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
130   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
131    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
132   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
133    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
134   1,                                    /* scalar_stmt_cost.  */
135   1,                                    /* scalar load_cost.  */
136   1,                                    /* scalar_store_cost.  */
137   1,                                    /* vec_stmt_cost.  */
138   1,                                    /* vec_to_scalar_cost.  */
139   1,                                    /* scalar_to_vec_cost.  */
140   1,                                    /* vec_align_load_cost.  */
141   1,                                    /* vec_unalign_load_cost.  */
142   1,                                    /* vec_store_cost.  */
143   1,                                    /* cond_taken_branch_cost.  */
144   1,                                    /* cond_not_taken_branch_cost.  */
145 };
146
147 /* Processor costs (relative to an add) */
148 static const
149 struct processor_costs i386_cost = {    /* 386 specific costs */
150   COSTS_N_INSNS (1),                    /* cost of an add instruction */
151   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
152   COSTS_N_INSNS (3),                    /* variable shift costs */
153   COSTS_N_INSNS (2),                    /* constant shift costs */
154   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
155    COSTS_N_INSNS (6),                   /*                               HI */
156    COSTS_N_INSNS (6),                   /*                               SI */
157    COSTS_N_INSNS (6),                   /*                               DI */
158    COSTS_N_INSNS (6)},                  /*                               other */
159   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
160   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
161    COSTS_N_INSNS (23),                  /*                          HI */
162    COSTS_N_INSNS (23),                  /*                          SI */
163    COSTS_N_INSNS (23),                  /*                          DI */
164    COSTS_N_INSNS (23)},                 /*                          other */
165   COSTS_N_INSNS (3),                    /* cost of movsx */
166   COSTS_N_INSNS (2),                    /* cost of movzx */
167   15,                                   /* "large" insn */
168   3,                                    /* MOVE_RATIO */
169   4,                                    /* cost for loading QImode using movzbl */
170   {2, 4, 2},                            /* cost of loading integer registers
171                                            in QImode, HImode and SImode.
172                                            Relative to reg-reg move (2).  */
173   {2, 4, 2},                            /* cost of storing integer registers */
174   2,                                    /* cost of reg,reg fld/fst */
175   {8, 8, 8},                            /* cost of loading fp registers
176                                            in SFmode, DFmode and XFmode */
177   {8, 8, 8},                            /* cost of storing fp registers
178                                            in SFmode, DFmode and XFmode */
179   2,                                    /* cost of moving MMX register */
180   {4, 8},                               /* cost of loading MMX registers
181                                            in SImode and DImode */
182   {4, 8},                               /* cost of storing MMX registers
183                                            in SImode and DImode */
184   2,                                    /* cost of moving SSE register */
185   {4, 8, 16},                           /* cost of loading SSE registers
186                                            in SImode, DImode and TImode */
187   {4, 8, 16},                           /* 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   1,                                    /* Branch cost */
195   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
196   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
197   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
198   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
199   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
200   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
201   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
202    DUMMY_STRINGOP_ALGS},
203   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
204    DUMMY_STRINGOP_ALGS},
205   1,                                    /* scalar_stmt_cost.  */
206   1,                                    /* scalar load_cost.  */
207   1,                                    /* scalar_store_cost.  */
208   1,                                    /* vec_stmt_cost.  */
209   1,                                    /* vec_to_scalar_cost.  */
210   1,                                    /* scalar_to_vec_cost.  */
211   1,                                    /* vec_align_load_cost.  */
212   2,                                    /* vec_unalign_load_cost.  */
213   1,                                    /* vec_store_cost.  */
214   3,                                    /* cond_taken_branch_cost.  */
215   1,                                    /* cond_not_taken_branch_cost.  */
216 };
217
218 static const
219 struct processor_costs i486_cost = {    /* 486 specific costs */
220   COSTS_N_INSNS (1),                    /* cost of an add instruction */
221   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
222   COSTS_N_INSNS (3),                    /* variable shift costs */
223   COSTS_N_INSNS (2),                    /* constant shift costs */
224   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
225    COSTS_N_INSNS (12),                  /*                               HI */
226    COSTS_N_INSNS (12),                  /*                               SI */
227    COSTS_N_INSNS (12),                  /*                               DI */
228    COSTS_N_INSNS (12)},                 /*                               other */
229   1,                                    /* cost of multiply per each bit set */
230   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
231    COSTS_N_INSNS (40),                  /*                          HI */
232    COSTS_N_INSNS (40),                  /*                          SI */
233    COSTS_N_INSNS (40),                  /*                          DI */
234    COSTS_N_INSNS (40)},                 /*                          other */
235   COSTS_N_INSNS (3),                    /* cost of movsx */
236   COSTS_N_INSNS (2),                    /* cost of movzx */
237   15,                                   /* "large" insn */
238   3,                                    /* MOVE_RATIO */
239   4,                                    /* cost for loading QImode using movzbl */
240   {2, 4, 2},                            /* cost of loading integer registers
241                                            in QImode, HImode and SImode.
242                                            Relative to reg-reg move (2).  */
243   {2, 4, 2},                            /* cost of storing integer registers */
244   2,                                    /* cost of reg,reg fld/fst */
245   {8, 8, 8},                            /* cost of loading fp registers
246                                            in SFmode, DFmode and XFmode */
247   {8, 8, 8},                            /* cost of storing fp registers
248                                            in SFmode, DFmode and XFmode */
249   2,                                    /* cost of moving MMX register */
250   {4, 8},                               /* cost of loading MMX registers
251                                            in SImode and DImode */
252   {4, 8},                               /* cost of storing MMX registers
253                                            in SImode and DImode */
254   2,                                    /* cost of moving SSE register */
255   {4, 8, 16},                           /* cost of loading SSE registers
256                                            in SImode, DImode and TImode */
257   {4, 8, 16},                           /* cost of storing SSE registers
258                                            in SImode, DImode and TImode */
259   3,                                    /* MMX or SSE register to integer */
260   4,                                    /* size of l1 cache.  486 has 8kB cache
261                                            shared for code and data, so 4kB is
262                                            not really precise.  */
263   4,                                    /* size of l2 cache  */
264   0,                                    /* size of prefetch block */
265   0,                                    /* number of parallel prefetches */
266   1,                                    /* Branch cost */
267   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
268   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
269   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
270   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
271   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
272   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
273   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
274    DUMMY_STRINGOP_ALGS},
275   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
276    DUMMY_STRINGOP_ALGS},
277   1,                                    /* scalar_stmt_cost.  */
278   1,                                    /* scalar load_cost.  */
279   1,                                    /* scalar_store_cost.  */
280   1,                                    /* vec_stmt_cost.  */
281   1,                                    /* vec_to_scalar_cost.  */
282   1,                                    /* scalar_to_vec_cost.  */
283   1,                                    /* vec_align_load_cost.  */
284   2,                                    /* vec_unalign_load_cost.  */
285   1,                                    /* vec_store_cost.  */
286   3,                                    /* cond_taken_branch_cost.  */
287   1,                                    /* cond_not_taken_branch_cost.  */
288 };
289
290 static const
291 struct processor_costs pentium_cost = {
292   COSTS_N_INSNS (1),                    /* cost of an add instruction */
293   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
294   COSTS_N_INSNS (4),                    /* variable shift costs */
295   COSTS_N_INSNS (1),                    /* constant shift costs */
296   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
297    COSTS_N_INSNS (11),                  /*                               HI */
298    COSTS_N_INSNS (11),                  /*                               SI */
299    COSTS_N_INSNS (11),                  /*                               DI */
300    COSTS_N_INSNS (11)},                 /*                               other */
301   0,                                    /* cost of multiply per each bit set */
302   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
303    COSTS_N_INSNS (25),                  /*                          HI */
304    COSTS_N_INSNS (25),                  /*                          SI */
305    COSTS_N_INSNS (25),                  /*                          DI */
306    COSTS_N_INSNS (25)},                 /*                          other */
307   COSTS_N_INSNS (3),                    /* cost of movsx */
308   COSTS_N_INSNS (2),                    /* cost of movzx */
309   8,                                    /* "large" insn */
310   6,                                    /* MOVE_RATIO */
311   6,                                    /* cost for loading QImode using movzbl */
312   {2, 4, 2},                            /* cost of loading integer registers
313                                            in QImode, HImode and SImode.
314                                            Relative to reg-reg move (2).  */
315   {2, 4, 2},                            /* cost of storing integer registers */
316   2,                                    /* cost of reg,reg fld/fst */
317   {2, 2, 6},                            /* cost of loading fp registers
318                                            in SFmode, DFmode and XFmode */
319   {4, 4, 6},                            /* cost of storing fp registers
320                                            in SFmode, DFmode and XFmode */
321   8,                                    /* cost of moving MMX register */
322   {8, 8},                               /* cost of loading MMX registers
323                                            in SImode and DImode */
324   {8, 8},                               /* cost of storing MMX registers
325                                            in SImode and DImode */
326   2,                                    /* cost of moving SSE register */
327   {4, 8, 16},                           /* cost of loading SSE registers
328                                            in SImode, DImode and TImode */
329   {4, 8, 16},                           /* cost of storing SSE registers
330                                            in SImode, DImode and TImode */
331   3,                                    /* MMX or SSE register to integer */
332   8,                                    /* size of l1 cache.  */
333   8,                                    /* size of l2 cache  */
334   0,                                    /* size of prefetch block */
335   0,                                    /* number of parallel prefetches */
336   2,                                    /* Branch cost */
337   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
338   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
339   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
340   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
341   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
342   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
343   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
344    DUMMY_STRINGOP_ALGS},
345   {{libcall, {{-1, rep_prefix_4_byte}}},
346    DUMMY_STRINGOP_ALGS},
347   1,                                    /* scalar_stmt_cost.  */
348   1,                                    /* scalar load_cost.  */
349   1,                                    /* scalar_store_cost.  */
350   1,                                    /* vec_stmt_cost.  */
351   1,                                    /* vec_to_scalar_cost.  */
352   1,                                    /* scalar_to_vec_cost.  */
353   1,                                    /* vec_align_load_cost.  */
354   2,                                    /* vec_unalign_load_cost.  */
355   1,                                    /* vec_store_cost.  */
356   3,                                    /* cond_taken_branch_cost.  */
357   1,                                    /* cond_not_taken_branch_cost.  */
358 };
359
360 static const
361 struct processor_costs pentiumpro_cost = {
362   COSTS_N_INSNS (1),                    /* cost of an add instruction */
363   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
364   COSTS_N_INSNS (1),                    /* variable shift costs */
365   COSTS_N_INSNS (1),                    /* constant shift costs */
366   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
367    COSTS_N_INSNS (4),                   /*                               HI */
368    COSTS_N_INSNS (4),                   /*                               SI */
369    COSTS_N_INSNS (4),                   /*                               DI */
370    COSTS_N_INSNS (4)},                  /*                               other */
371   0,                                    /* cost of multiply per each bit set */
372   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
373    COSTS_N_INSNS (17),                  /*                          HI */
374    COSTS_N_INSNS (17),                  /*                          SI */
375    COSTS_N_INSNS (17),                  /*                          DI */
376    COSTS_N_INSNS (17)},                 /*                          other */
377   COSTS_N_INSNS (1),                    /* cost of movsx */
378   COSTS_N_INSNS (1),                    /* cost of movzx */
379   8,                                    /* "large" insn */
380   6,                                    /* MOVE_RATIO */
381   2,                                    /* cost for loading QImode using movzbl */
382   {4, 4, 4},                            /* cost of loading integer registers
383                                            in QImode, HImode and SImode.
384                                            Relative to reg-reg move (2).  */
385   {2, 2, 2},                            /* cost of storing integer registers */
386   2,                                    /* cost of reg,reg fld/fst */
387   {2, 2, 6},                            /* cost of loading fp registers
388                                            in SFmode, DFmode and XFmode */
389   {4, 4, 6},                            /* cost of storing fp registers
390                                            in SFmode, DFmode and XFmode */
391   2,                                    /* cost of moving MMX register */
392   {2, 2},                               /* cost of loading MMX registers
393                                            in SImode and DImode */
394   {2, 2},                               /* cost of storing MMX registers
395                                            in SImode and DImode */
396   2,                                    /* cost of moving SSE register */
397   {2, 2, 8},                            /* cost of loading SSE registers
398                                            in SImode, DImode and TImode */
399   {2, 2, 8},                            /* cost of storing SSE registers
400                                            in SImode, DImode and TImode */
401   3,                                    /* MMX or SSE register to integer */
402   8,                                    /* size of l1 cache.  */
403   256,                                  /* size of l2 cache  */
404   32,                                   /* size of prefetch block */
405   6,                                    /* number of parallel prefetches */
406   2,                                    /* Branch cost */
407   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
408   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
409   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
410   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
411   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
412   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
413   /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes (we ensure
414      the alignment).  For small blocks inline loop is still a noticeable win, for bigger
415      blocks either rep movsl or rep movsb is way to go.  Rep movsb has apparently
416      more expensive startup time in CPU, but after 4K the difference is down in the noise.
417    */
418   {{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
419                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
420    DUMMY_STRINGOP_ALGS},
421   {{rep_prefix_4_byte, {{1024, unrolled_loop},
422                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
423    DUMMY_STRINGOP_ALGS},
424   1,                                    /* scalar_stmt_cost.  */
425   1,                                    /* scalar load_cost.  */
426   1,                                    /* scalar_store_cost.  */
427   1,                                    /* vec_stmt_cost.  */
428   1,                                    /* vec_to_scalar_cost.  */
429   1,                                    /* scalar_to_vec_cost.  */
430   1,                                    /* vec_align_load_cost.  */
431   2,                                    /* vec_unalign_load_cost.  */
432   1,                                    /* vec_store_cost.  */
433   3,                                    /* cond_taken_branch_cost.  */
434   1,                                    /* cond_not_taken_branch_cost.  */
435 };
436
437 static const
438 struct processor_costs geode_cost = {
439   COSTS_N_INSNS (1),                    /* cost of an add instruction */
440   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
441   COSTS_N_INSNS (2),                    /* variable shift costs */
442   COSTS_N_INSNS (1),                    /* constant shift costs */
443   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
444    COSTS_N_INSNS (4),                   /*                               HI */
445    COSTS_N_INSNS (7),                   /*                               SI */
446    COSTS_N_INSNS (7),                   /*                               DI */
447    COSTS_N_INSNS (7)},                  /*                               other */
448   0,                                    /* cost of multiply per each bit set */
449   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
450    COSTS_N_INSNS (23),                  /*                          HI */
451    COSTS_N_INSNS (39),                  /*                          SI */
452    COSTS_N_INSNS (39),                  /*                          DI */
453    COSTS_N_INSNS (39)},                 /*                          other */
454   COSTS_N_INSNS (1),                    /* cost of movsx */
455   COSTS_N_INSNS (1),                    /* cost of movzx */
456   8,                                    /* "large" insn */
457   4,                                    /* MOVE_RATIO */
458   1,                                    /* cost for loading QImode using movzbl */
459   {1, 1, 1},                            /* cost of loading integer registers
460                                            in QImode, HImode and SImode.
461                                            Relative to reg-reg move (2).  */
462   {1, 1, 1},                            /* cost of storing integer registers */
463   1,                                    /* cost of reg,reg fld/fst */
464   {1, 1, 1},                            /* cost of loading fp registers
465                                            in SFmode, DFmode and XFmode */
466   {4, 6, 6},                            /* cost of storing fp registers
467                                            in SFmode, DFmode and XFmode */
468
469   1,                                    /* cost of moving MMX register */
470   {1, 1},                               /* cost of loading MMX registers
471                                            in SImode and DImode */
472   {1, 1},                               /* cost of storing MMX registers
473                                            in SImode and DImode */
474   1,                                    /* cost of moving SSE register */
475   {1, 1, 1},                            /* cost of loading SSE registers
476                                            in SImode, DImode and TImode */
477   {1, 1, 1},                            /* cost of storing SSE registers
478                                            in SImode, DImode and TImode */
479   1,                                    /* MMX or SSE register to integer */
480   64,                                   /* size of l1 cache.  */
481   128,                                  /* size of l2 cache.  */
482   32,                                   /* size of prefetch block */
483   1,                                    /* number of parallel prefetches */
484   1,                                    /* Branch cost */
485   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
486   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
487   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
488   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
489   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
490   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
491   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
492    DUMMY_STRINGOP_ALGS},
493   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
494    DUMMY_STRINGOP_ALGS},
495   1,                                    /* scalar_stmt_cost.  */
496   1,                                    /* scalar load_cost.  */
497   1,                                    /* scalar_store_cost.  */
498   1,                                    /* vec_stmt_cost.  */
499   1,                                    /* vec_to_scalar_cost.  */
500   1,                                    /* scalar_to_vec_cost.  */
501   1,                                    /* vec_align_load_cost.  */
502   2,                                    /* vec_unalign_load_cost.  */
503   1,                                    /* vec_store_cost.  */
504   3,                                    /* cond_taken_branch_cost.  */
505   1,                                    /* cond_not_taken_branch_cost.  */
506 };
507
508 static const
509 struct processor_costs k6_cost = {
510   COSTS_N_INSNS (1),                    /* cost of an add instruction */
511   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
512   COSTS_N_INSNS (1),                    /* variable shift costs */
513   COSTS_N_INSNS (1),                    /* constant shift costs */
514   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
515    COSTS_N_INSNS (3),                   /*                               HI */
516    COSTS_N_INSNS (3),                   /*                               SI */
517    COSTS_N_INSNS (3),                   /*                               DI */
518    COSTS_N_INSNS (3)},                  /*                               other */
519   0,                                    /* cost of multiply per each bit set */
520   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
521    COSTS_N_INSNS (18),                  /*                          HI */
522    COSTS_N_INSNS (18),                  /*                          SI */
523    COSTS_N_INSNS (18),                  /*                          DI */
524    COSTS_N_INSNS (18)},                 /*                          other */
525   COSTS_N_INSNS (2),                    /* cost of movsx */
526   COSTS_N_INSNS (2),                    /* cost of movzx */
527   8,                                    /* "large" insn */
528   4,                                    /* MOVE_RATIO */
529   3,                                    /* cost for loading QImode using movzbl */
530   {4, 5, 4},                            /* cost of loading integer registers
531                                            in QImode, HImode and SImode.
532                                            Relative to reg-reg move (2).  */
533   {2, 3, 2},                            /* cost of storing integer registers */
534   4,                                    /* cost of reg,reg fld/fst */
535   {6, 6, 6},                            /* cost of loading fp registers
536                                            in SFmode, DFmode and XFmode */
537   {4, 4, 4},                            /* cost of storing fp registers
538                                            in SFmode, DFmode and XFmode */
539   2,                                    /* cost of moving MMX register */
540   {2, 2},                               /* cost of loading MMX registers
541                                            in SImode and DImode */
542   {2, 2},                               /* cost of storing MMX registers
543                                            in SImode and DImode */
544   2,                                    /* cost of moving SSE register */
545   {2, 2, 8},                            /* cost of loading SSE registers
546                                            in SImode, DImode and TImode */
547   {2, 2, 8},                            /* cost of storing SSE registers
548                                            in SImode, DImode and TImode */
549   6,                                    /* MMX or SSE register to integer */
550   32,                                   /* size of l1 cache.  */
551   32,                                   /* size of l2 cache.  Some models
552                                            have integrated l2 cache, but
553                                            optimizing for k6 is not important
554                                            enough to worry about that.  */
555   32,                                   /* size of prefetch block */
556   1,                                    /* number of parallel prefetches */
557   1,                                    /* Branch cost */
558   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
559   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
560   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
561   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
562   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
563   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
564   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
565    DUMMY_STRINGOP_ALGS},
566   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
567    DUMMY_STRINGOP_ALGS},
568   1,                                    /* scalar_stmt_cost.  */
569   1,                                    /* scalar load_cost.  */
570   1,                                    /* scalar_store_cost.  */
571   1,                                    /* vec_stmt_cost.  */
572   1,                                    /* vec_to_scalar_cost.  */
573   1,                                    /* scalar_to_vec_cost.  */
574   1,                                    /* vec_align_load_cost.  */
575   2,                                    /* vec_unalign_load_cost.  */
576   1,                                    /* vec_store_cost.  */
577   3,                                    /* cond_taken_branch_cost.  */
578   1,                                    /* cond_not_taken_branch_cost.  */
579 };
580
581 static const
582 struct processor_costs athlon_cost = {
583   COSTS_N_INSNS (1),                    /* cost of an add instruction */
584   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
585   COSTS_N_INSNS (1),                    /* variable shift costs */
586   COSTS_N_INSNS (1),                    /* constant shift costs */
587   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
588    COSTS_N_INSNS (5),                   /*                               HI */
589    COSTS_N_INSNS (5),                   /*                               SI */
590    COSTS_N_INSNS (5),                   /*                               DI */
591    COSTS_N_INSNS (5)},                  /*                               other */
592   0,                                    /* cost of multiply per each bit set */
593   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
594    COSTS_N_INSNS (26),                  /*                          HI */
595    COSTS_N_INSNS (42),                  /*                          SI */
596    COSTS_N_INSNS (74),                  /*                          DI */
597    COSTS_N_INSNS (74)},                 /*                          other */
598   COSTS_N_INSNS (1),                    /* cost of movsx */
599   COSTS_N_INSNS (1),                    /* cost of movzx */
600   8,                                    /* "large" insn */
601   9,                                    /* MOVE_RATIO */
602   4,                                    /* cost for loading QImode using movzbl */
603   {3, 4, 3},                            /* cost of loading integer registers
604                                            in QImode, HImode and SImode.
605                                            Relative to reg-reg move (2).  */
606   {3, 4, 3},                            /* cost of storing integer registers */
607   4,                                    /* cost of reg,reg fld/fst */
608   {4, 4, 12},                           /* cost of loading fp registers
609                                            in SFmode, DFmode and XFmode */
610   {6, 6, 8},                            /* cost of storing fp registers
611                                            in SFmode, DFmode and XFmode */
612   2,                                    /* cost of moving MMX register */
613   {4, 4},                               /* cost of loading MMX registers
614                                            in SImode and DImode */
615   {4, 4},                               /* cost of storing MMX registers
616                                            in SImode and DImode */
617   2,                                    /* cost of moving SSE register */
618   {4, 4, 6},                            /* cost of loading SSE registers
619                                            in SImode, DImode and TImode */
620   {4, 4, 5},                            /* cost of storing SSE registers
621                                            in SImode, DImode and TImode */
622   5,                                    /* MMX or SSE register to integer */
623   64,                                   /* size of l1 cache.  */
624   256,                                  /* size of l2 cache.  */
625   64,                                   /* size of prefetch block */
626   6,                                    /* number of parallel prefetches */
627   5,                                    /* Branch cost */
628   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
629   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
630   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
631   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
632   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
633   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
634   /* For some reason, Athlon deals better with REP prefix (relative to loops)
635      compared to K8. Alignment becomes important after 8 bytes for memcpy and
636      128 bytes for memset.  */
637   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
638    DUMMY_STRINGOP_ALGS},
639   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
640    DUMMY_STRINGOP_ALGS},
641   1,                                    /* scalar_stmt_cost.  */
642   1,                                    /* scalar load_cost.  */
643   1,                                    /* scalar_store_cost.  */
644   1,                                    /* vec_stmt_cost.  */
645   1,                                    /* vec_to_scalar_cost.  */
646   1,                                    /* scalar_to_vec_cost.  */
647   1,                                    /* vec_align_load_cost.  */
648   2,                                    /* vec_unalign_load_cost.  */
649   1,                                    /* vec_store_cost.  */
650   3,                                    /* cond_taken_branch_cost.  */
651   1,                                    /* cond_not_taken_branch_cost.  */
652 };
653
654 static const
655 struct processor_costs k8_cost = {
656   COSTS_N_INSNS (1),                    /* cost of an add instruction */
657   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
658   COSTS_N_INSNS (1),                    /* variable shift costs */
659   COSTS_N_INSNS (1),                    /* constant shift costs */
660   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
661    COSTS_N_INSNS (4),                   /*                               HI */
662    COSTS_N_INSNS (3),                   /*                               SI */
663    COSTS_N_INSNS (4),                   /*                               DI */
664    COSTS_N_INSNS (5)},                  /*                               other */
665   0,                                    /* cost of multiply per each bit set */
666   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
667    COSTS_N_INSNS (26),                  /*                          HI */
668    COSTS_N_INSNS (42),                  /*                          SI */
669    COSTS_N_INSNS (74),                  /*                          DI */
670    COSTS_N_INSNS (74)},                 /*                          other */
671   COSTS_N_INSNS (1),                    /* cost of movsx */
672   COSTS_N_INSNS (1),                    /* cost of movzx */
673   8,                                    /* "large" insn */
674   9,                                    /* MOVE_RATIO */
675   4,                                    /* cost for loading QImode using movzbl */
676   {3, 4, 3},                            /* cost of loading integer registers
677                                            in QImode, HImode and SImode.
678                                            Relative to reg-reg move (2).  */
679   {3, 4, 3},                            /* cost of storing integer registers */
680   4,                                    /* cost of reg,reg fld/fst */
681   {4, 4, 12},                           /* cost of loading fp registers
682                                            in SFmode, DFmode and XFmode */
683   {6, 6, 8},                            /* cost of storing fp registers
684                                            in SFmode, DFmode and XFmode */
685   2,                                    /* cost of moving MMX register */
686   {3, 3},                               /* cost of loading MMX registers
687                                            in SImode and DImode */
688   {4, 4},                               /* cost of storing MMX registers
689                                            in SImode and DImode */
690   2,                                    /* cost of moving SSE register */
691   {4, 3, 6},                            /* cost of loading SSE registers
692                                            in SImode, DImode and TImode */
693   {4, 4, 5},                            /* cost of storing SSE registers
694                                            in SImode, DImode and TImode */
695   5,                                    /* MMX or SSE register to integer */
696   64,                                   /* size of l1 cache.  */
697   512,                                  /* size of l2 cache.  */
698   64,                                   /* size of prefetch block */
699   /* New AMD processors never drop prefetches; if they cannot be performed
700      immediately, they are queued.  We set number of simultaneous prefetches
701      to a large constant to reflect this (it probably is not a good idea not
702      to limit number of prefetches at all, as their execution also takes some
703      time).  */
704   100,                                  /* number of parallel prefetches */
705   3,                                    /* Branch cost */
706   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
707   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
708   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
709   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
710   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
711   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
712   /* K8 has optimized REP instruction for medium sized blocks, but for very small
713      blocks it is better to use loop. For large blocks, libcall can do
714      nontemporary accesses and beat inline considerably.  */
715   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
716    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
717   {{libcall, {{8, loop}, {24, unrolled_loop},
718               {2048, rep_prefix_4_byte}, {-1, libcall}}},
719    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
720   4,                                    /* scalar_stmt_cost.  */
721   2,                                    /* scalar load_cost.  */
722   2,                                    /* scalar_store_cost.  */
723   5,                                    /* vec_stmt_cost.  */
724   0,                                    /* vec_to_scalar_cost.  */
725   2,                                    /* scalar_to_vec_cost.  */
726   2,                                    /* vec_align_load_cost.  */
727   3,                                    /* vec_unalign_load_cost.  */
728   3,                                    /* vec_store_cost.  */
729   3,                                    /* cond_taken_branch_cost.  */
730   2,                                    /* cond_not_taken_branch_cost.  */
731 };
732
733 struct processor_costs amdfam10_cost = {
734   COSTS_N_INSNS (1),                    /* cost of an add instruction */
735   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
736   COSTS_N_INSNS (1),                    /* variable shift costs */
737   COSTS_N_INSNS (1),                    /* constant shift costs */
738   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
739    COSTS_N_INSNS (4),                   /*                               HI */
740    COSTS_N_INSNS (3),                   /*                               SI */
741    COSTS_N_INSNS (4),                   /*                               DI */
742    COSTS_N_INSNS (5)},                  /*                               other */
743   0,                                    /* cost of multiply per each bit set */
744   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
745    COSTS_N_INSNS (35),                  /*                          HI */
746    COSTS_N_INSNS (51),                  /*                          SI */
747    COSTS_N_INSNS (83),                  /*                          DI */
748    COSTS_N_INSNS (83)},                 /*                          other */
749   COSTS_N_INSNS (1),                    /* cost of movsx */
750   COSTS_N_INSNS (1),                    /* cost of movzx */
751   8,                                    /* "large" insn */
752   9,                                    /* MOVE_RATIO */
753   4,                                    /* cost for loading QImode using movzbl */
754   {3, 4, 3},                            /* cost of loading integer registers
755                                            in QImode, HImode and SImode.
756                                            Relative to reg-reg move (2).  */
757   {3, 4, 3},                            /* cost of storing integer registers */
758   4,                                    /* cost of reg,reg fld/fst */
759   {4, 4, 12},                           /* cost of loading fp registers
760                                            in SFmode, DFmode and XFmode */
761   {6, 6, 8},                            /* cost of storing fp registers
762                                            in SFmode, DFmode and XFmode */
763   2,                                    /* cost of moving MMX register */
764   {3, 3},                               /* cost of loading MMX registers
765                                            in SImode and DImode */
766   {4, 4},                               /* cost of storing MMX registers
767                                            in SImode and DImode */
768   2,                                    /* cost of moving SSE register */
769   {4, 4, 3},                            /* cost of loading SSE registers
770                                            in SImode, DImode and TImode */
771   {4, 4, 5},                            /* cost of storing SSE registers
772                                            in SImode, DImode and TImode */
773   3,                                    /* MMX or SSE register to integer */
774                                         /* On K8
775                                             MOVD reg64, xmmreg  Double  FSTORE 4
776                                             MOVD reg32, xmmreg  Double  FSTORE 4
777                                            On AMDFAM10
778                                             MOVD reg64, xmmreg  Double  FADD 3
779                                                                 1/1  1/1
780                                             MOVD reg32, xmmreg  Double  FADD 3
781                                                                 1/1  1/1 */
782   64,                                   /* size of l1 cache.  */
783   512,                                  /* size of l2 cache.  */
784   64,                                   /* size of prefetch block */
785   /* New AMD processors never drop prefetches; if they cannot be performed
786      immediately, they are queued.  We set number of simultaneous prefetches
787      to a large constant to reflect this (it probably is not a good idea not
788      to limit number of prefetches at all, as their execution also takes some
789      time).  */
790   100,                                  /* number of parallel prefetches */
791   2,                                    /* Branch cost */
792   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
793   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
794   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
795   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
796   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
797   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
798
799   /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
800      very small blocks it is better to use loop. For large blocks, libcall can
801      do nontemporary accesses and beat inline considerably.  */
802   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
803    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
804   {{libcall, {{8, loop}, {24, unrolled_loop},
805               {2048, rep_prefix_4_byte}, {-1, libcall}}},
806    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
807   4,                                    /* scalar_stmt_cost.  */
808   2,                                    /* scalar load_cost.  */
809   2,                                    /* scalar_store_cost.  */
810   6,                                    /* vec_stmt_cost.  */
811   0,                                    /* vec_to_scalar_cost.  */
812   2,                                    /* scalar_to_vec_cost.  */
813   2,                                    /* vec_align_load_cost.  */
814   2,                                    /* vec_unalign_load_cost.  */
815   2,                                    /* vec_store_cost.  */
816   2,                                    /* cond_taken_branch_cost.  */
817   1,                                    /* cond_not_taken_branch_cost.  */
818 };
819
820 static const
821 struct processor_costs pentium4_cost = {
822   COSTS_N_INSNS (1),                    /* cost of an add instruction */
823   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
824   COSTS_N_INSNS (4),                    /* variable shift costs */
825   COSTS_N_INSNS (4),                    /* constant shift costs */
826   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
827    COSTS_N_INSNS (15),                  /*                               HI */
828    COSTS_N_INSNS (15),                  /*                               SI */
829    COSTS_N_INSNS (15),                  /*                               DI */
830    COSTS_N_INSNS (15)},                 /*                               other */
831   0,                                    /* cost of multiply per each bit set */
832   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
833    COSTS_N_INSNS (56),                  /*                          HI */
834    COSTS_N_INSNS (56),                  /*                          SI */
835    COSTS_N_INSNS (56),                  /*                          DI */
836    COSTS_N_INSNS (56)},                 /*                          other */
837   COSTS_N_INSNS (1),                    /* cost of movsx */
838   COSTS_N_INSNS (1),                    /* cost of movzx */
839   16,                                   /* "large" insn */
840   6,                                    /* MOVE_RATIO */
841   2,                                    /* cost for loading QImode using movzbl */
842   {4, 5, 4},                            /* cost of loading integer registers
843                                            in QImode, HImode and SImode.
844                                            Relative to reg-reg move (2).  */
845   {2, 3, 2},                            /* cost of storing integer registers */
846   2,                                    /* cost of reg,reg fld/fst */
847   {2, 2, 6},                            /* cost of loading fp registers
848                                            in SFmode, DFmode and XFmode */
849   {4, 4, 6},                            /* cost of storing fp registers
850                                            in SFmode, DFmode and XFmode */
851   2,                                    /* cost of moving MMX register */
852   {2, 2},                               /* cost of loading MMX registers
853                                            in SImode and DImode */
854   {2, 2},                               /* cost of storing MMX registers
855                                            in SImode and DImode */
856   12,                                   /* cost of moving SSE register */
857   {12, 12, 12},                         /* cost of loading SSE registers
858                                            in SImode, DImode and TImode */
859   {2, 2, 8},                            /* cost of storing SSE registers
860                                            in SImode, DImode and TImode */
861   10,                                   /* MMX or SSE register to integer */
862   8,                                    /* size of l1 cache.  */
863   256,                                  /* size of l2 cache.  */
864   64,                                   /* size of prefetch block */
865   6,                                    /* number of parallel prefetches */
866   2,                                    /* Branch cost */
867   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
868   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
869   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
870   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
871   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
872   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
873   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
874    DUMMY_STRINGOP_ALGS},
875   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
876    {-1, libcall}}},
877    DUMMY_STRINGOP_ALGS},
878   1,                                    /* scalar_stmt_cost.  */
879   1,                                    /* scalar load_cost.  */
880   1,                                    /* scalar_store_cost.  */
881   1,                                    /* vec_stmt_cost.  */
882   1,                                    /* vec_to_scalar_cost.  */
883   1,                                    /* scalar_to_vec_cost.  */
884   1,                                    /* vec_align_load_cost.  */
885   2,                                    /* vec_unalign_load_cost.  */
886   1,                                    /* vec_store_cost.  */
887   3,                                    /* cond_taken_branch_cost.  */
888   1,                                    /* cond_not_taken_branch_cost.  */
889 };
890
891 static const
892 struct processor_costs nocona_cost = {
893   COSTS_N_INSNS (1),                    /* cost of an add instruction */
894   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
895   COSTS_N_INSNS (1),                    /* variable shift costs */
896   COSTS_N_INSNS (1),                    /* constant shift costs */
897   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
898    COSTS_N_INSNS (10),                  /*                               HI */
899    COSTS_N_INSNS (10),                  /*                               SI */
900    COSTS_N_INSNS (10),                  /*                               DI */
901    COSTS_N_INSNS (10)},                 /*                               other */
902   0,                                    /* cost of multiply per each bit set */
903   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
904    COSTS_N_INSNS (66),                  /*                          HI */
905    COSTS_N_INSNS (66),                  /*                          SI */
906    COSTS_N_INSNS (66),                  /*                          DI */
907    COSTS_N_INSNS (66)},                 /*                          other */
908   COSTS_N_INSNS (1),                    /* cost of movsx */
909   COSTS_N_INSNS (1),                    /* cost of movzx */
910   16,                                   /* "large" insn */
911   17,                                   /* MOVE_RATIO */
912   4,                                    /* cost for loading QImode using movzbl */
913   {4, 4, 4},                            /* cost of loading integer registers
914                                            in QImode, HImode and SImode.
915                                            Relative to reg-reg move (2).  */
916   {4, 4, 4},                            /* cost of storing integer registers */
917   3,                                    /* cost of reg,reg fld/fst */
918   {12, 12, 12},                         /* cost of loading fp registers
919                                            in SFmode, DFmode and XFmode */
920   {4, 4, 4},                            /* cost of storing fp registers
921                                            in SFmode, DFmode and XFmode */
922   6,                                    /* cost of moving MMX register */
923   {12, 12},                             /* cost of loading MMX registers
924                                            in SImode and DImode */
925   {12, 12},                             /* cost of storing MMX registers
926                                            in SImode and DImode */
927   6,                                    /* cost of moving SSE register */
928   {12, 12, 12},                         /* cost of loading SSE registers
929                                            in SImode, DImode and TImode */
930   {12, 12, 12},                         /* cost of storing SSE registers
931                                            in SImode, DImode and TImode */
932   8,                                    /* MMX or SSE register to integer */
933   8,                                    /* size of l1 cache.  */
934   1024,                                 /* size of l2 cache.  */
935   128,                                  /* size of prefetch block */
936   8,                                    /* number of parallel prefetches */
937   1,                                    /* Branch cost */
938   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
939   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
940   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
941   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
942   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
943   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
944   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
945    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
946               {100000, unrolled_loop}, {-1, libcall}}}},
947   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
948    {-1, libcall}}},
949    {libcall, {{24, loop}, {64, unrolled_loop},
950               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
951   1,                                    /* scalar_stmt_cost.  */
952   1,                                    /* scalar load_cost.  */
953   1,                                    /* scalar_store_cost.  */
954   1,                                    /* vec_stmt_cost.  */
955   1,                                    /* vec_to_scalar_cost.  */
956   1,                                    /* scalar_to_vec_cost.  */
957   1,                                    /* vec_align_load_cost.  */
958   2,                                    /* vec_unalign_load_cost.  */
959   1,                                    /* vec_store_cost.  */
960   3,                                    /* cond_taken_branch_cost.  */
961   1,                                    /* cond_not_taken_branch_cost.  */
962 };
963
964 static const
965 struct processor_costs core2_cost = {
966   COSTS_N_INSNS (1),                    /* cost of an add instruction */
967   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
968   COSTS_N_INSNS (1),                    /* variable shift costs */
969   COSTS_N_INSNS (1),                    /* constant shift costs */
970   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
971    COSTS_N_INSNS (3),                   /*                               HI */
972    COSTS_N_INSNS (3),                   /*                               SI */
973    COSTS_N_INSNS (3),                   /*                               DI */
974    COSTS_N_INSNS (3)},                  /*                               other */
975   0,                                    /* cost of multiply per each bit set */
976   {COSTS_N_INSNS (22),                  /* cost of a divide/mod for QI */
977    COSTS_N_INSNS (22),                  /*                          HI */
978    COSTS_N_INSNS (22),                  /*                          SI */
979    COSTS_N_INSNS (22),                  /*                          DI */
980    COSTS_N_INSNS (22)},                 /*                          other */
981   COSTS_N_INSNS (1),                    /* cost of movsx */
982   COSTS_N_INSNS (1),                    /* cost of movzx */
983   8,                                    /* "large" insn */
984   16,                                   /* MOVE_RATIO */
985   2,                                    /* cost for loading QImode using movzbl */
986   {6, 6, 6},                            /* cost of loading integer registers
987                                            in QImode, HImode and SImode.
988                                            Relative to reg-reg move (2).  */
989   {4, 4, 4},                            /* cost of storing integer registers */
990   2,                                    /* cost of reg,reg fld/fst */
991   {6, 6, 6},                            /* cost of loading fp registers
992                                            in SFmode, DFmode and XFmode */
993   {4, 4, 4},                            /* cost of storing fp registers
994                                            in SFmode, DFmode and XFmode */
995   2,                                    /* cost of moving MMX register */
996   {6, 6},                               /* cost of loading MMX registers
997                                            in SImode and DImode */
998   {4, 4},                               /* cost of storing MMX registers
999                                            in SImode and DImode */
1000   2,                                    /* cost of moving SSE register */
1001   {6, 6, 6},                            /* cost of loading SSE registers
1002                                            in SImode, DImode and TImode */
1003   {4, 4, 4},                            /* cost of storing SSE registers
1004                                            in SImode, DImode and TImode */
1005   2,                                    /* MMX or SSE register to integer */
1006   32,                                   /* size of l1 cache.  */
1007   2048,                                 /* size of l2 cache.  */
1008   128,                                  /* size of prefetch block */
1009   8,                                    /* number of parallel prefetches */
1010   3,                                    /* Branch cost */
1011   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
1012   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
1013   COSTS_N_INSNS (32),                   /* cost of FDIV instruction.  */
1014   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
1015   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
1016   COSTS_N_INSNS (58),                   /* cost of FSQRT instruction.  */
1017   {{libcall, {{11, loop}, {-1, rep_prefix_4_byte}}},
1018    {libcall, {{32, loop}, {64, rep_prefix_4_byte},
1019               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1020   {{libcall, {{8, loop}, {15, unrolled_loop},
1021               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1022    {libcall, {{24, loop}, {32, unrolled_loop},
1023               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1024   1,                                    /* scalar_stmt_cost.  */
1025   1,                                    /* scalar load_cost.  */
1026   1,                                    /* scalar_store_cost.  */
1027   1,                                    /* vec_stmt_cost.  */
1028   1,                                    /* vec_to_scalar_cost.  */
1029   1,                                    /* scalar_to_vec_cost.  */
1030   1,                                    /* vec_align_load_cost.  */
1031   2,                                    /* vec_unalign_load_cost.  */
1032   1,                                    /* vec_store_cost.  */
1033   3,                                    /* cond_taken_branch_cost.  */
1034   1,                                    /* cond_not_taken_branch_cost.  */
1035 };
1036
1037 static const
1038 struct processor_costs atom_cost = {
1039   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1040   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1041   COSTS_N_INSNS (1),                    /* variable shift costs */
1042   COSTS_N_INSNS (1),                    /* constant shift costs */
1043   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1044    COSTS_N_INSNS (4),                   /*                               HI */
1045    COSTS_N_INSNS (3),                   /*                               SI */
1046    COSTS_N_INSNS (4),                   /*                               DI */
1047    COSTS_N_INSNS (2)},                  /*                               other */
1048   0,                                    /* cost of multiply per each bit set */
1049   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1050    COSTS_N_INSNS (26),                  /*                          HI */
1051    COSTS_N_INSNS (42),                  /*                          SI */
1052    COSTS_N_INSNS (74),                  /*                          DI */
1053    COSTS_N_INSNS (74)},                 /*                          other */
1054   COSTS_N_INSNS (1),                    /* cost of movsx */
1055   COSTS_N_INSNS (1),                    /* cost of movzx */
1056   8,                                    /* "large" insn */
1057   17,                                   /* MOVE_RATIO */
1058   2,                                    /* cost for loading QImode using movzbl */
1059   {4, 4, 4},                            /* cost of loading integer registers
1060                                            in QImode, HImode and SImode.
1061                                            Relative to reg-reg move (2).  */
1062   {4, 4, 4},                            /* cost of storing integer registers */
1063   4,                                    /* cost of reg,reg fld/fst */
1064   {12, 12, 12},                         /* cost of loading fp registers
1065                                            in SFmode, DFmode and XFmode */
1066   {6, 6, 8},                            /* cost of storing fp registers
1067                                            in SFmode, DFmode and XFmode */
1068   2,                                    /* cost of moving MMX register */
1069   {8, 8},                               /* cost of loading MMX registers
1070                                            in SImode and DImode */
1071   {8, 8},                               /* cost of storing MMX registers
1072                                            in SImode and DImode */
1073   2,                                    /* cost of moving SSE register */
1074   {8, 8, 8},                            /* cost of loading SSE registers
1075                                            in SImode, DImode and TImode */
1076   {8, 8, 8},                            /* cost of storing SSE registers
1077                                            in SImode, DImode and TImode */
1078   5,                                    /* MMX or SSE register to integer */
1079   32,                                   /* size of l1 cache.  */
1080   256,                                  /* size of l2 cache.  */
1081   64,                                   /* size of prefetch block */
1082   6,                                    /* number of parallel prefetches */
1083   3,                                    /* Branch cost */
1084   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1085   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1086   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1087   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1088   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1089   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1090   {{libcall, {{11, loop}, {-1, rep_prefix_4_byte}}},
1091    {libcall, {{32, loop}, {64, rep_prefix_4_byte},
1092           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1093   {{libcall, {{8, loop}, {15, unrolled_loop},
1094           {2048, rep_prefix_4_byte}, {-1, libcall}}},
1095    {libcall, {{24, loop}, {32, unrolled_loop},
1096           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1097   1,                                    /* scalar_stmt_cost.  */
1098   1,                                    /* scalar load_cost.  */
1099   1,                                    /* scalar_store_cost.  */
1100   1,                                    /* vec_stmt_cost.  */
1101   1,                                    /* vec_to_scalar_cost.  */
1102   1,                                    /* scalar_to_vec_cost.  */
1103   1,                                    /* vec_align_load_cost.  */
1104   2,                                    /* vec_unalign_load_cost.  */
1105   1,                                    /* vec_store_cost.  */
1106   3,                                    /* cond_taken_branch_cost.  */
1107   1,                                    /* cond_not_taken_branch_cost.  */
1108 };
1109
1110 /* Generic64 should produce code tuned for Nocona and K8.  */
1111 static const
1112 struct processor_costs generic64_cost = {
1113   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1114   /* On all chips taken into consideration lea is 2 cycles and more.  With
1115      this cost however our current implementation of synth_mult results in
1116      use of unnecessary temporary registers causing regression on several
1117      SPECfp benchmarks.  */
1118   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1119   COSTS_N_INSNS (1),                    /* variable shift costs */
1120   COSTS_N_INSNS (1),                    /* constant shift costs */
1121   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1122    COSTS_N_INSNS (4),                   /*                               HI */
1123    COSTS_N_INSNS (3),                   /*                               SI */
1124    COSTS_N_INSNS (4),                   /*                               DI */
1125    COSTS_N_INSNS (2)},                  /*                               other */
1126   0,                                    /* cost of multiply per each bit set */
1127   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1128    COSTS_N_INSNS (26),                  /*                          HI */
1129    COSTS_N_INSNS (42),                  /*                          SI */
1130    COSTS_N_INSNS (74),                  /*                          DI */
1131    COSTS_N_INSNS (74)},                 /*                          other */
1132   COSTS_N_INSNS (1),                    /* cost of movsx */
1133   COSTS_N_INSNS (1),                    /* cost of movzx */
1134   8,                                    /* "large" insn */
1135   17,                                   /* MOVE_RATIO */
1136   4,                                    /* cost for loading QImode using movzbl */
1137   {4, 4, 4},                            /* cost of loading integer registers
1138                                            in QImode, HImode and SImode.
1139                                            Relative to reg-reg move (2).  */
1140   {4, 4, 4},                            /* cost of storing integer registers */
1141   4,                                    /* cost of reg,reg fld/fst */
1142   {12, 12, 12},                         /* cost of loading fp registers
1143                                            in SFmode, DFmode and XFmode */
1144   {6, 6, 8},                            /* cost of storing fp registers
1145                                            in SFmode, DFmode and XFmode */
1146   2,                                    /* cost of moving MMX register */
1147   {8, 8},                               /* cost of loading MMX registers
1148                                            in SImode and DImode */
1149   {8, 8},                               /* cost of storing MMX registers
1150                                            in SImode and DImode */
1151   2,                                    /* cost of moving SSE register */
1152   {8, 8, 8},                            /* cost of loading SSE registers
1153                                            in SImode, DImode and TImode */
1154   {8, 8, 8},                            /* cost of storing SSE registers
1155                                            in SImode, DImode and TImode */
1156   5,                                    /* MMX or SSE register to integer */
1157   32,                                   /* size of l1 cache.  */
1158   512,                                  /* size of l2 cache.  */
1159   64,                                   /* size of prefetch block */
1160   6,                                    /* number of parallel prefetches */
1161   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this value
1162      is increased to perhaps more appropriate value of 5.  */
1163   3,                                    /* Branch cost */
1164   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1165   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1166   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1167   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1168   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1169   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1170   {DUMMY_STRINGOP_ALGS,
1171    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1172   {DUMMY_STRINGOP_ALGS,
1173    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1174   1,                                    /* scalar_stmt_cost.  */
1175   1,                                    /* scalar load_cost.  */
1176   1,                                    /* scalar_store_cost.  */
1177   1,                                    /* vec_stmt_cost.  */
1178   1,                                    /* vec_to_scalar_cost.  */
1179   1,                                    /* scalar_to_vec_cost.  */
1180   1,                                    /* vec_align_load_cost.  */
1181   2,                                    /* vec_unalign_load_cost.  */
1182   1,                                    /* vec_store_cost.  */
1183   3,                                    /* cond_taken_branch_cost.  */
1184   1,                                    /* cond_not_taken_branch_cost.  */
1185 };
1186
1187 /* Generic32 should produce code tuned for Athlon, PPro, Pentium4, Nocona and K8.  */
1188 static const
1189 struct processor_costs generic32_cost = {
1190   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1191   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1192   COSTS_N_INSNS (1),                    /* variable shift costs */
1193   COSTS_N_INSNS (1),                    /* constant shift costs */
1194   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1195    COSTS_N_INSNS (4),                   /*                               HI */
1196    COSTS_N_INSNS (3),                   /*                               SI */
1197    COSTS_N_INSNS (4),                   /*                               DI */
1198    COSTS_N_INSNS (2)},                  /*                               other */
1199   0,                                    /* cost of multiply per each bit set */
1200   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1201    COSTS_N_INSNS (26),                  /*                          HI */
1202    COSTS_N_INSNS (42),                  /*                          SI */
1203    COSTS_N_INSNS (74),                  /*                          DI */
1204    COSTS_N_INSNS (74)},                 /*                          other */
1205   COSTS_N_INSNS (1),                    /* cost of movsx */
1206   COSTS_N_INSNS (1),                    /* cost of movzx */
1207   8,                                    /* "large" insn */
1208   17,                                   /* MOVE_RATIO */
1209   4,                                    /* cost for loading QImode using movzbl */
1210   {4, 4, 4},                            /* cost of loading integer registers
1211                                            in QImode, HImode and SImode.
1212                                            Relative to reg-reg move (2).  */
1213   {4, 4, 4},                            /* cost of storing integer registers */
1214   4,                                    /* cost of reg,reg fld/fst */
1215   {12, 12, 12},                         /* cost of loading fp registers
1216                                            in SFmode, DFmode and XFmode */
1217   {6, 6, 8},                            /* cost of storing fp registers
1218                                            in SFmode, DFmode and XFmode */
1219   2,                                    /* cost of moving MMX register */
1220   {8, 8},                               /* cost of loading MMX registers
1221                                            in SImode and DImode */
1222   {8, 8},                               /* cost of storing MMX registers
1223                                            in SImode and DImode */
1224   2,                                    /* cost of moving SSE register */
1225   {8, 8, 8},                            /* cost of loading SSE registers
1226                                            in SImode, DImode and TImode */
1227   {8, 8, 8},                            /* cost of storing SSE registers
1228                                            in SImode, DImode and TImode */
1229   5,                                    /* MMX or SSE register to integer */
1230   32,                                   /* size of l1 cache.  */
1231   256,                                  /* size of l2 cache.  */
1232   64,                                   /* size of prefetch block */
1233   6,                                    /* number of parallel prefetches */
1234   3,                                    /* Branch cost */
1235   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1236   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1237   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1238   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1239   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1240   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1241   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1242    DUMMY_STRINGOP_ALGS},
1243   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1244    DUMMY_STRINGOP_ALGS},
1245   1,                                    /* scalar_stmt_cost.  */
1246   1,                                    /* scalar load_cost.  */
1247   1,                                    /* scalar_store_cost.  */
1248   1,                                    /* vec_stmt_cost.  */
1249   1,                                    /* vec_to_scalar_cost.  */
1250   1,                                    /* scalar_to_vec_cost.  */
1251   1,                                    /* vec_align_load_cost.  */
1252   2,                                    /* vec_unalign_load_cost.  */
1253   1,                                    /* vec_store_cost.  */
1254   3,                                    /* cond_taken_branch_cost.  */
1255   1,                                    /* cond_not_taken_branch_cost.  */
1256 };
1257
1258 const struct processor_costs *ix86_cost = &pentium_cost;
1259
1260 /* Processor feature/optimization bitmasks.  */
1261 #define m_386 (1<<PROCESSOR_I386)
1262 #define m_486 (1<<PROCESSOR_I486)
1263 #define m_PENT (1<<PROCESSOR_PENTIUM)
1264 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
1265 #define m_PENT4  (1<<PROCESSOR_PENTIUM4)
1266 #define m_NOCONA  (1<<PROCESSOR_NOCONA)
1267 #define m_CORE2  (1<<PROCESSOR_CORE2)
1268 #define m_ATOM  (1<<PROCESSOR_ATOM)
1269
1270 #define m_GEODE  (1<<PROCESSOR_GEODE)
1271 #define m_K6  (1<<PROCESSOR_K6)
1272 #define m_K6_GEODE  (m_K6 | m_GEODE)
1273 #define m_K8  (1<<PROCESSOR_K8)
1274 #define m_ATHLON  (1<<PROCESSOR_ATHLON)
1275 #define m_ATHLON_K8  (m_K8 | m_ATHLON)
1276 #define m_AMDFAM10  (1<<PROCESSOR_AMDFAM10)
1277 #define m_AMD_MULTIPLE  (m_K8 | m_ATHLON | m_AMDFAM10)
1278
1279 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
1280 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
1281
1282 /* Generic instruction choice should be common subset of supported CPUs
1283    (PPro/PENT4/NOCONA/CORE2/Athlon/K8).  */
1284 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
1285
1286 /* Feature tests against the various tunings.  */
1287 unsigned char ix86_tune_features[X86_TUNE_LAST];
1288
1289 /* Feature tests against the various tunings used to create ix86_tune_features
1290    based on the processor mask.  */
1291 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
1292   /* X86_TUNE_USE_LEAVE: Leave does not affect Nocona SPEC2000 results
1293      negatively, so enabling for Generic64 seems like good code size
1294      tradeoff.  We can't enable it for 32bit generic because it does not
1295      work well with PPro base chips.  */
1296   m_386 | m_K6_GEODE | m_AMD_MULTIPLE | m_CORE2 | m_GENERIC64,
1297
1298   /* X86_TUNE_PUSH_MEMORY */
1299   m_386 | m_K6_GEODE | m_AMD_MULTIPLE | m_PENT4
1300   | m_NOCONA | m_CORE2 | m_GENERIC,
1301
1302   /* X86_TUNE_ZERO_EXTEND_WITH_AND */
1303   m_486 | m_PENT,
1304
1305   /* X86_TUNE_UNROLL_STRLEN */
1306   m_486 | m_PENT | m_ATOM | m_PPRO | m_AMD_MULTIPLE | m_K6
1307   | m_CORE2 | m_GENERIC,
1308
1309   /* X86_TUNE_DEEP_BRANCH_PREDICTION */
1310   m_ATOM | m_PPRO | m_K6_GEODE | m_AMD_MULTIPLE | m_PENT4 | m_GENERIC,
1311
1312   /* X86_TUNE_BRANCH_PREDICTION_HINTS: Branch hints were put in P4 based
1313      on simulation result. But after P4 was made, no performance benefit
1314      was observed with branch hints.  It also increases the code size.
1315      As a result, icc never generates branch hints.  */
1316   0,
1317
1318   /* X86_TUNE_DOUBLE_WITH_ADD */
1319   ~m_386,
1320
1321   /* X86_TUNE_USE_SAHF */
1322   m_ATOM | m_PPRO | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_PENT4
1323   | m_NOCONA | m_CORE2 | m_GENERIC,
1324
1325   /* X86_TUNE_MOVX: Enable to zero extend integer registers to avoid
1326      partial dependencies.  */
1327   m_AMD_MULTIPLE | m_ATOM | m_PPRO | m_PENT4 | m_NOCONA
1328   | m_CORE2 | m_GENERIC | m_GEODE /* m_386 | m_K6 */,
1329
1330   /* X86_TUNE_PARTIAL_REG_STALL: We probably ought to watch for partial
1331      register stalls on Generic32 compilation setting as well.  However
1332      in current implementation the partial register stalls are not eliminated
1333      very well - they can be introduced via subregs synthesized by combine
1334      and can happen in caller/callee saving sequences.  Because this option
1335      pays back little on PPro based chips and is in conflict with partial reg
1336      dependencies used by Athlon/P4 based chips, it is better to leave it off
1337      for generic32 for now.  */
1338   m_PPRO,
1339
1340   /* X86_TUNE_PARTIAL_FLAG_REG_STALL */
1341   m_CORE2 | m_GENERIC,
1342
1343   /* X86_TUNE_USE_HIMODE_FIOP */
1344   m_386 | m_486 | m_K6_GEODE,
1345
1346   /* X86_TUNE_USE_SIMODE_FIOP */
1347   ~(m_PPRO | m_AMD_MULTIPLE | m_PENT | m_ATOM | m_CORE2 | m_GENERIC),
1348
1349   /* X86_TUNE_USE_MOV0 */
1350   m_K6,
1351
1352   /* X86_TUNE_USE_CLTD */
1353   ~(m_PENT | m_ATOM | m_K6 | m_CORE2 | m_GENERIC),
1354
1355   /* X86_TUNE_USE_XCHGB: Use xchgb %rh,%rl instead of rolw/rorw $8,rx.  */
1356   m_PENT4,
1357
1358   /* X86_TUNE_SPLIT_LONG_MOVES */
1359   m_PPRO,
1360
1361   /* X86_TUNE_READ_MODIFY_WRITE */
1362   ~m_PENT,
1363
1364   /* X86_TUNE_READ_MODIFY */
1365   ~(m_PENT | m_PPRO),
1366
1367   /* X86_TUNE_PROMOTE_QIMODE */
1368   m_K6_GEODE | m_PENT | m_ATOM | m_386 | m_486 | m_AMD_MULTIPLE
1369   | m_CORE2 | m_GENERIC /* | m_PENT4 ? */,
1370
1371   /* X86_TUNE_FAST_PREFIX */
1372   ~(m_PENT | m_486 | m_386),
1373
1374   /* X86_TUNE_SINGLE_STRINGOP */
1375   m_386 | m_PENT4 | m_NOCONA,
1376
1377   /* X86_TUNE_QIMODE_MATH */
1378   ~0,
1379
1380   /* X86_TUNE_HIMODE_MATH: On PPro this flag is meant to avoid partial
1381      register stalls.  Just like X86_TUNE_PARTIAL_REG_STALL this option
1382      might be considered for Generic32 if our scheme for avoiding partial
1383      stalls was more effective.  */
1384   ~m_PPRO,
1385
1386   /* X86_TUNE_PROMOTE_QI_REGS */
1387   0,
1388
1389   /* X86_TUNE_PROMOTE_HI_REGS */
1390   m_PPRO,
1391
1392   /* X86_TUNE_ADD_ESP_4: Enable if add/sub is preferred over 1/2 push/pop.  */
1393   m_ATOM | m_AMD_MULTIPLE | m_K6_GEODE | m_PENT4 | m_NOCONA
1394   | m_CORE2 | m_GENERIC,
1395
1396   /* X86_TUNE_ADD_ESP_8 */
1397   m_AMD_MULTIPLE | m_ATOM | m_PPRO | m_K6_GEODE | m_386
1398   | m_486 | m_PENT4 | m_NOCONA | m_CORE2 | m_GENERIC,
1399
1400   /* X86_TUNE_SUB_ESP_4 */
1401   m_AMD_MULTIPLE | m_ATOM | m_PPRO | m_PENT4 | m_NOCONA | m_CORE2
1402   | m_GENERIC,
1403
1404   /* X86_TUNE_SUB_ESP_8 */
1405   m_AMD_MULTIPLE | m_ATOM | m_PPRO | m_386 | m_486
1406   | m_PENT4 | m_NOCONA | m_CORE2 | m_GENERIC,
1407
1408   /* X86_TUNE_INTEGER_DFMODE_MOVES: Enable if integer moves are preferred
1409      for DFmode copies */
1410   ~(m_AMD_MULTIPLE | m_ATOM | m_PENT4 | m_NOCONA | m_PPRO | m_CORE2
1411     | m_GENERIC | m_GEODE),
1412
1413   /* X86_TUNE_PARTIAL_REG_DEPENDENCY */
1414   m_AMD_MULTIPLE | m_ATOM | m_PENT4 | m_NOCONA | m_CORE2 | m_GENERIC,
1415
1416   /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: In the Generic model we have a
1417      conflict here in between PPro/Pentium4 based chips that thread 128bit
1418      SSE registers as single units versus K8 based chips that divide SSE
1419      registers to two 64bit halves.  This knob promotes all store destinations
1420      to be 128bit to allow register renaming on 128bit SSE units, but usually
1421      results in one extra microop on 64bit SSE units.  Experimental results
1422      shows that disabling this option on P4 brings over 20% SPECfp regression,
1423      while enabling it on K8 brings roughly 2.4% regression that can be partly
1424      masked by careful scheduling of moves.  */
1425   m_ATOM | m_PENT4 | m_NOCONA | m_PPRO | m_CORE2 | m_GENERIC
1426   | m_AMDFAM10,
1427
1428   /* X86_TUNE_SSE_UNALIGNED_MOVE_OPTIMAL */
1429   m_AMDFAM10,
1430
1431   /* X86_TUNE_SSE_SPLIT_REGS: Set for machines where the type and dependencies
1432      are resolved on SSE register parts instead of whole registers, so we may
1433      maintain just lower part of scalar values in proper format leaving the
1434      upper part undefined.  */
1435   m_ATHLON_K8,
1436
1437   /* X86_TUNE_SSE_TYPELESS_STORES */
1438   m_AMD_MULTIPLE,
1439
1440   /* X86_TUNE_SSE_LOAD0_BY_PXOR */
1441   m_PPRO | m_PENT4 | m_NOCONA,
1442
1443   /* X86_TUNE_MEMORY_MISMATCH_STALL */
1444   m_AMD_MULTIPLE | m_ATOM | m_PENT4 | m_NOCONA | m_CORE2 | m_GENERIC,
1445
1446   /* X86_TUNE_PROLOGUE_USING_MOVE */
1447   m_ATHLON_K8 | m_ATOM | m_PPRO | m_CORE2 | m_GENERIC,
1448
1449   /* X86_TUNE_EPILOGUE_USING_MOVE */
1450   m_ATHLON_K8 | m_ATOM | m_PPRO | m_CORE2 | m_GENERIC,
1451
1452   /* X86_TUNE_SHIFT1 */
1453   ~m_486,
1454
1455   /* X86_TUNE_USE_FFREEP */
1456   m_AMD_MULTIPLE,
1457
1458   /* X86_TUNE_INTER_UNIT_MOVES */
1459   ~(m_AMD_MULTIPLE | m_ATOM | m_GENERIC),
1460
1461   /* X86_TUNE_INTER_UNIT_CONVERSIONS */
1462   ~(m_AMDFAM10),
1463
1464   /* X86_TUNE_FOUR_JUMP_LIMIT: Some CPU cores are not able to predict more
1465      than 4 branch instructions in the 16 byte window.  */
1466   m_ATOM | m_PPRO | m_AMD_MULTIPLE | m_PENT4 | m_NOCONA | m_CORE2
1467   | m_GENERIC,
1468
1469   /* X86_TUNE_SCHEDULE */
1470   m_PPRO | m_AMD_MULTIPLE | m_K6_GEODE | m_PENT | m_ATOM | m_CORE2
1471   | m_GENERIC,
1472
1473   /* X86_TUNE_USE_BT */
1474   m_AMD_MULTIPLE | m_ATOM | m_CORE2 | m_GENERIC,
1475
1476   /* X86_TUNE_USE_INCDEC */
1477   ~(m_PENT4 | m_NOCONA | m_GENERIC | m_ATOM),
1478
1479   /* X86_TUNE_PAD_RETURNS */
1480   m_AMD_MULTIPLE | m_CORE2 | m_GENERIC,
1481
1482   /* X86_TUNE_EXT_80387_CONSTANTS */
1483   m_K6_GEODE | m_ATHLON_K8 | m_ATOM | m_PENT4 | m_NOCONA | m_PPRO
1484   | m_CORE2 | m_GENERIC,
1485
1486   /* X86_TUNE_SHORTEN_X87_SSE */
1487   ~m_K8,
1488
1489   /* X86_TUNE_AVOID_VECTOR_DECODE */
1490   m_K8 | m_GENERIC64,
1491
1492   /* X86_TUNE_PROMOTE_HIMODE_IMUL: Modern CPUs have same latency for HImode
1493      and SImode multiply, but 386 and 486 do HImode multiply faster.  */
1494   ~(m_386 | m_486),
1495
1496   /* X86_TUNE_SLOW_IMUL_IMM32_MEM: Imul of 32-bit constant and memory is
1497      vector path on AMD machines.  */
1498   m_K8 | m_GENERIC64 | m_AMDFAM10,
1499
1500   /* X86_TUNE_SLOW_IMUL_IMM8: Imul of 8-bit constant is vector path on AMD
1501      machines.  */
1502   m_K8 | m_GENERIC64 | m_AMDFAM10,
1503
1504   /* X86_TUNE_MOVE_M1_VIA_OR: On pentiums, it is faster to load -1 via OR
1505      than a MOV.  */
1506   m_PENT,
1507
1508   /* X86_TUNE_NOT_UNPAIRABLE: NOT is not pairable on Pentium, while XOR is,
1509      but one byte longer.  */
1510   m_PENT,
1511
1512   /* X86_TUNE_NOT_VECTORMODE: On AMD K6, NOT is vector decoded with memory
1513      operand that cannot be represented using a modRM byte.  The XOR
1514      replacement is long decoded, so this split helps here as well.  */
1515   m_K6,
1516
1517   /* X86_TUNE_USE_VECTOR_FP_CONVERTS: Prefer vector packed SSE conversion
1518      from FP to FP. */
1519   m_AMDFAM10 | m_GENERIC,
1520
1521   /* X86_TUNE_USE_VECTOR_CONVERTS: Prefer vector packed SSE conversion
1522      from integer to FP. */
1523   m_AMDFAM10,
1524
1525   /* X86_TUNE_FUSE_CMP_AND_BRANCH: Fuse a compare or test instruction
1526      with a subsequent conditional jump instruction into a single
1527      compare-and-branch uop.  */
1528   m_CORE2,
1529
1530   /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
1531      will impact LEA instruction selection. */
1532   m_ATOM,
1533 };
1534
1535 /* Feature tests against the various architecture variations.  */
1536 unsigned char ix86_arch_features[X86_ARCH_LAST];
1537
1538 /* Feature tests against the various architecture variations, used to create
1539    ix86_arch_features based on the processor mask.  */
1540 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
1541   /* X86_ARCH_CMOVE: Conditional move was added for pentiumpro.  */
1542   ~(m_386 | m_486 | m_PENT | m_K6),
1543
1544   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
1545   ~m_386,
1546
1547   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
1548   ~(m_386 | m_486),
1549
1550   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
1551   ~m_386,
1552
1553   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
1554   ~m_386,
1555 };
1556
1557 static const unsigned int x86_accumulate_outgoing_args
1558   = m_AMD_MULTIPLE | m_ATOM | m_PENT4 | m_NOCONA | m_PPRO | m_CORE2
1559     | m_GENERIC;
1560
1561 static const unsigned int x86_arch_always_fancy_math_387
1562   = m_PENT | m_ATOM | m_PPRO | m_AMD_MULTIPLE | m_PENT4
1563     | m_NOCONA | m_CORE2 | m_GENERIC;
1564
1565 static enum stringop_alg stringop_alg = no_stringop;
1566
1567 /* In case the average insn count for single function invocation is
1568    lower than this constant, emit fast (but longer) prologue and
1569    epilogue code.  */
1570 #define FAST_PROLOGUE_INSN_COUNT 20
1571
1572 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
1573 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
1574 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
1575 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
1576
1577 /* Array of the smallest class containing reg number REGNO, indexed by
1578    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
1579
1580 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
1581 {
1582   /* ax, dx, cx, bx */
1583   AREG, DREG, CREG, BREG,
1584   /* si, di, bp, sp */
1585   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
1586   /* FP registers */
1587   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
1588   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
1589   /* arg pointer */
1590   NON_Q_REGS,
1591   /* flags, fpsr, fpcr, frame */
1592   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
1593   /* SSE registers */
1594   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
1595   SSE_REGS, SSE_REGS,
1596   /* MMX registers */
1597   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
1598   MMX_REGS, MMX_REGS,
1599   /* REX registers */
1600   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
1601   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
1602   /* SSE REX registers */
1603   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
1604   SSE_REGS, SSE_REGS,
1605 };
1606
1607 /* The "default" register map used in 32bit mode.  */
1608
1609 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
1610 {
1611   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
1612   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
1613   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
1614   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
1615   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
1616   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
1617   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
1618 };
1619
1620 /* The "default" register map used in 64bit mode.  */
1621
1622 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
1623 {
1624   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
1625   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
1626   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
1627   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
1628   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
1629   8,9,10,11,12,13,14,15,                /* extended integer registers */
1630   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
1631 };
1632
1633 /* Define the register numbers to be used in Dwarf debugging information.
1634    The SVR4 reference port C compiler uses the following register numbers
1635    in its Dwarf output code:
1636         0 for %eax (gcc regno = 0)
1637         1 for %ecx (gcc regno = 2)
1638         2 for %edx (gcc regno = 1)
1639         3 for %ebx (gcc regno = 3)
1640         4 for %esp (gcc regno = 7)
1641         5 for %ebp (gcc regno = 6)
1642         6 for %esi (gcc regno = 4)
1643         7 for %edi (gcc regno = 5)
1644    The following three DWARF register numbers are never generated by
1645    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
1646    believes these numbers have these meanings.
1647         8  for %eip    (no gcc equivalent)
1648         9  for %eflags (gcc regno = 17)
1649         10 for %trapno (no gcc equivalent)
1650    It is not at all clear how we should number the FP stack registers
1651    for the x86 architecture.  If the version of SDB on x86/svr4 were
1652    a bit less brain dead with respect to floating-point then we would
1653    have a precedent to follow with respect to DWARF register numbers
1654    for x86 FP registers, but the SDB on x86/svr4 is so completely
1655    broken with respect to FP registers that it is hardly worth thinking
1656    of it as something to strive for compatibility with.
1657    The version of x86/svr4 SDB I have at the moment does (partially)
1658    seem to believe that DWARF register number 11 is associated with
1659    the x86 register %st(0), but that's about all.  Higher DWARF
1660    register numbers don't seem to be associated with anything in
1661    particular, and even for DWARF regno 11, SDB only seems to under-
1662    stand that it should say that a variable lives in %st(0) (when
1663    asked via an `=' command) if we said it was in DWARF regno 11,
1664    but SDB still prints garbage when asked for the value of the
1665    variable in question (via a `/' command).
1666    (Also note that the labels SDB prints for various FP stack regs
1667    when doing an `x' command are all wrong.)
1668    Note that these problems generally don't affect the native SVR4
1669    C compiler because it doesn't allow the use of -O with -g and
1670    because when it is *not* optimizing, it allocates a memory
1671    location for each floating-point variable, and the memory
1672    location is what gets described in the DWARF AT_location
1673    attribute for the variable in question.
1674    Regardless of the severe mental illness of the x86/svr4 SDB, we
1675    do something sensible here and we use the following DWARF
1676    register numbers.  Note that these are all stack-top-relative
1677    numbers.
1678         11 for %st(0) (gcc regno = 8)
1679         12 for %st(1) (gcc regno = 9)
1680         13 for %st(2) (gcc regno = 10)
1681         14 for %st(3) (gcc regno = 11)
1682         15 for %st(4) (gcc regno = 12)
1683         16 for %st(5) (gcc regno = 13)
1684         17 for %st(6) (gcc regno = 14)
1685         18 for %st(7) (gcc regno = 15)
1686 */
1687 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
1688 {
1689   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
1690   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
1691   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
1692   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
1693   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
1694   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
1695   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
1696 };
1697
1698 /* Test and compare insns in i386.md store the information needed to
1699    generate branch and scc insns here.  */
1700
1701 rtx ix86_compare_op0 = NULL_RTX;
1702 rtx ix86_compare_op1 = NULL_RTX;
1703
1704 /* Define parameter passing and return registers.  */
1705
1706 static int const x86_64_int_parameter_registers[6] =
1707 {
1708   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
1709 };
1710
1711 static int const x86_64_ms_abi_int_parameter_registers[4] =
1712 {
1713   CX_REG, DX_REG, R8_REG, R9_REG
1714 };
1715
1716 static int const x86_64_int_return_registers[4] =
1717 {
1718   AX_REG, DX_REG, DI_REG, SI_REG
1719 };
1720
1721 /* Define the structure for the machine field in struct function.  */
1722
1723 struct GTY(()) stack_local_entry {
1724   unsigned short mode;
1725   unsigned short n;
1726   rtx rtl;
1727   struct stack_local_entry *next;
1728 };
1729
1730 /* Structure describing stack frame layout.
1731    Stack grows downward:
1732
1733    [arguments]
1734                                               <- ARG_POINTER
1735    saved pc
1736
1737    saved frame pointer if frame_pointer_needed
1738                                               <- HARD_FRAME_POINTER
1739    [saved regs]
1740
1741    [padding0]
1742
1743    [saved SSE regs]
1744
1745    [padding1]          \
1746                         )
1747    [va_arg registers]  (
1748                         > to_allocate         <- FRAME_POINTER
1749    [frame]             (
1750                         )
1751    [padding2]          /
1752   */
1753 struct ix86_frame
1754 {
1755   int padding0;
1756   int nsseregs;
1757   int nregs;
1758   int padding1;
1759   int va_arg_size;
1760   HOST_WIDE_INT frame;
1761   int padding2;
1762   int outgoing_arguments_size;
1763   int red_zone_size;
1764
1765   HOST_WIDE_INT to_allocate;
1766   /* The offsets relative to ARG_POINTER.  */
1767   HOST_WIDE_INT frame_pointer_offset;
1768   HOST_WIDE_INT hard_frame_pointer_offset;
1769   HOST_WIDE_INT stack_pointer_offset;
1770
1771   /* When save_regs_using_mov is set, emit prologue using
1772      move instead of push instructions.  */
1773   bool save_regs_using_mov;
1774 };
1775
1776 /* Code model option.  */
1777 enum cmodel ix86_cmodel;
1778 /* Asm dialect.  */
1779 enum asm_dialect ix86_asm_dialect = ASM_ATT;
1780 /* TLS dialects.  */
1781 enum tls_dialect ix86_tls_dialect = TLS_DIALECT_GNU;
1782
1783 /* Which unit we are generating floating point math for.  */
1784 enum fpmath_unit ix86_fpmath;
1785
1786 /* Which cpu are we scheduling for.  */
1787 enum attr_cpu ix86_schedule;
1788
1789 /* Which cpu are we optimizing for.  */
1790 enum processor_type ix86_tune;
1791
1792 /* Which instruction set architecture to use.  */
1793 enum processor_type ix86_arch;
1794
1795 /* true if sse prefetch instruction is not NOOP.  */
1796 int x86_prefetch_sse;
1797
1798 /* ix86_regparm_string as a number */
1799 static int ix86_regparm;
1800
1801 /* -mstackrealign option */
1802 extern int ix86_force_align_arg_pointer;
1803 static const char ix86_force_align_arg_pointer_string[]
1804   = "force_align_arg_pointer";
1805
1806 static rtx (*ix86_gen_leave) (void);
1807 static rtx (*ix86_gen_pop1) (rtx);
1808 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
1809 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
1810 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
1811 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
1812 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
1813 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
1814
1815 /* Preferred alignment for stack boundary in bits.  */
1816 unsigned int ix86_preferred_stack_boundary;
1817
1818 /* Alignment for incoming stack boundary in bits specified at
1819    command line.  */
1820 static unsigned int ix86_user_incoming_stack_boundary;
1821
1822 /* Default alignment for incoming stack boundary in bits.  */
1823 static unsigned int ix86_default_incoming_stack_boundary;
1824
1825 /* Alignment for incoming stack boundary in bits.  */
1826 unsigned int ix86_incoming_stack_boundary;
1827
1828 /* The abi used by target.  */
1829 enum calling_abi ix86_abi;
1830
1831 /* Values 1-5: see jump.c */
1832 int ix86_branch_cost;
1833
1834 /* Calling abi specific va_list type nodes.  */
1835 static GTY(()) tree sysv_va_list_type_node;
1836 static GTY(()) tree ms_va_list_type_node;
1837
1838 /* Variables which are this size or smaller are put in the data/bss
1839    or ldata/lbss sections.  */
1840
1841 int ix86_section_threshold = 65536;
1842
1843 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
1844 char internal_label_prefix[16];
1845 int internal_label_prefix_len;
1846
1847 /* Fence to use after loop using movnt.  */
1848 tree x86_mfence;
1849
1850 /* Register class used for passing given 64bit part of the argument.
1851    These represent classes as documented by the PS ABI, with the exception
1852    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
1853    use SF or DFmode move instead of DImode to avoid reformatting penalties.
1854
1855    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
1856    whenever possible (upper half does contain padding).  */
1857 enum x86_64_reg_class
1858   {
1859     X86_64_NO_CLASS,
1860     X86_64_INTEGER_CLASS,
1861     X86_64_INTEGERSI_CLASS,
1862     X86_64_SSE_CLASS,
1863     X86_64_SSESF_CLASS,
1864     X86_64_SSEDF_CLASS,
1865     X86_64_SSEUP_CLASS,
1866     X86_64_X87_CLASS,
1867     X86_64_X87UP_CLASS,
1868     X86_64_COMPLEX_X87_CLASS,
1869     X86_64_MEMORY_CLASS
1870   };
1871
1872 #define MAX_CLASSES 4
1873
1874 /* Table of constants used by fldpi, fldln2, etc....  */
1875 static REAL_VALUE_TYPE ext_80387_constants_table [5];
1876 static bool ext_80387_constants_init = 0;
1877
1878 \f
1879 static struct machine_function * ix86_init_machine_status (void);
1880 static rtx ix86_function_value (const_tree, const_tree, bool);
1881 static rtx ix86_static_chain (const_tree, bool);
1882 static int ix86_function_regparm (const_tree, const_tree);
1883 static void ix86_compute_frame_layout (struct ix86_frame *);
1884 static bool ix86_expand_vector_init_one_nonzero (bool, enum machine_mode,
1885                                                  rtx, rtx, int);
1886 static void ix86_add_new_builtins (int);
1887 static rtx ix86_expand_vec_perm_builtin (tree);
1888
1889 enum ix86_function_specific_strings
1890 {
1891   IX86_FUNCTION_SPECIFIC_ARCH,
1892   IX86_FUNCTION_SPECIFIC_TUNE,
1893   IX86_FUNCTION_SPECIFIC_FPMATH,
1894   IX86_FUNCTION_SPECIFIC_MAX
1895 };
1896
1897 static char *ix86_target_string (int, int, const char *, const char *,
1898                                  const char *, bool);
1899 static void ix86_debug_options (void) ATTRIBUTE_UNUSED;
1900 static void ix86_function_specific_save (struct cl_target_option *);
1901 static void ix86_function_specific_restore (struct cl_target_option *);
1902 static void ix86_function_specific_print (FILE *, int,
1903                                           struct cl_target_option *);
1904 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
1905 static bool ix86_valid_target_attribute_inner_p (tree, char *[]);
1906 static bool ix86_can_inline_p (tree, tree);
1907 static void ix86_set_current_function (tree);
1908 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
1909
1910 static enum calling_abi ix86_function_abi (const_tree);
1911
1912 \f
1913 /* The svr4 ABI for the i386 says that records and unions are returned
1914    in memory.  */
1915 #ifndef DEFAULT_PCC_STRUCT_RETURN
1916 #define DEFAULT_PCC_STRUCT_RETURN 1
1917 #endif
1918
1919 /* Whether -mtune= or -march= were specified */
1920 static int ix86_tune_defaulted;
1921 static int ix86_arch_specified;
1922
1923 /* Bit flags that specify the ISA we are compiling for.  */
1924 int ix86_isa_flags = TARGET_64BIT_DEFAULT | TARGET_SUBTARGET_ISA_DEFAULT;
1925
1926 /* A mask of ix86_isa_flags that includes bit X if X
1927    was set or cleared on the command line.  */
1928 static int ix86_isa_flags_explicit;
1929
1930 /* Define a set of ISAs which are available when a given ISA is
1931    enabled.  MMX and SSE ISAs are handled separately.  */
1932
1933 #define OPTION_MASK_ISA_MMX_SET OPTION_MASK_ISA_MMX
1934 #define OPTION_MASK_ISA_3DNOW_SET \
1935   (OPTION_MASK_ISA_3DNOW | OPTION_MASK_ISA_MMX_SET)
1936
1937 #define OPTION_MASK_ISA_SSE_SET OPTION_MASK_ISA_SSE
1938 #define OPTION_MASK_ISA_SSE2_SET \
1939   (OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE_SET)
1940 #define OPTION_MASK_ISA_SSE3_SET \
1941   (OPTION_MASK_ISA_SSE3 | OPTION_MASK_ISA_SSE2_SET)
1942 #define OPTION_MASK_ISA_SSSE3_SET \
1943   (OPTION_MASK_ISA_SSSE3 | OPTION_MASK_ISA_SSE3_SET)
1944 #define OPTION_MASK_ISA_SSE4_1_SET \
1945   (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_SSSE3_SET)
1946 #define OPTION_MASK_ISA_SSE4_2_SET \
1947   (OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_SSE4_1_SET)
1948 #define OPTION_MASK_ISA_AVX_SET \
1949   (OPTION_MASK_ISA_AVX | OPTION_MASK_ISA_SSE4_2_SET)
1950 #define OPTION_MASK_ISA_FMA_SET \
1951   (OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_AVX_SET)
1952
1953 /* SSE4 includes both SSE4.1 and SSE4.2. -msse4 should be the same
1954    as -msse4.2.  */
1955 #define OPTION_MASK_ISA_SSE4_SET OPTION_MASK_ISA_SSE4_2_SET
1956
1957 #define OPTION_MASK_ISA_SSE4A_SET \
1958   (OPTION_MASK_ISA_SSE4A | OPTION_MASK_ISA_SSE3_SET)
1959 #define OPTION_MASK_ISA_FMA4_SET \
1960   (OPTION_MASK_ISA_FMA4 | OPTION_MASK_ISA_SSE4A_SET \
1961    | OPTION_MASK_ISA_AVX_SET)
1962 #define OPTION_MASK_ISA_XOP_SET \
1963   (OPTION_MASK_ISA_XOP | OPTION_MASK_ISA_FMA4_SET)
1964 #define OPTION_MASK_ISA_LWP_SET \
1965   OPTION_MASK_ISA_LWP
1966
1967 /* AES and PCLMUL need SSE2 because they use xmm registers */
1968 #define OPTION_MASK_ISA_AES_SET \
1969   (OPTION_MASK_ISA_AES | OPTION_MASK_ISA_SSE2_SET)
1970 #define OPTION_MASK_ISA_PCLMUL_SET \
1971   (OPTION_MASK_ISA_PCLMUL | OPTION_MASK_ISA_SSE2_SET)
1972
1973 #define OPTION_MASK_ISA_ABM_SET \
1974   (OPTION_MASK_ISA_ABM | OPTION_MASK_ISA_POPCNT)
1975
1976 #define OPTION_MASK_ISA_POPCNT_SET OPTION_MASK_ISA_POPCNT
1977 #define OPTION_MASK_ISA_CX16_SET OPTION_MASK_ISA_CX16
1978 #define OPTION_MASK_ISA_SAHF_SET OPTION_MASK_ISA_SAHF
1979 #define OPTION_MASK_ISA_MOVBE_SET OPTION_MASK_ISA_MOVBE
1980 #define OPTION_MASK_ISA_CRC32_SET OPTION_MASK_ISA_CRC32
1981
1982 /* Define a set of ISAs which aren't available when a given ISA is
1983    disabled.  MMX and SSE ISAs are handled separately.  */
1984
1985 #define OPTION_MASK_ISA_MMX_UNSET \
1986   (OPTION_MASK_ISA_MMX | OPTION_MASK_ISA_3DNOW_UNSET)
1987 #define OPTION_MASK_ISA_3DNOW_UNSET \
1988   (OPTION_MASK_ISA_3DNOW | OPTION_MASK_ISA_3DNOW_A_UNSET)
1989 #define OPTION_MASK_ISA_3DNOW_A_UNSET OPTION_MASK_ISA_3DNOW_A
1990
1991 #define OPTION_MASK_ISA_SSE_UNSET \
1992   (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_SSE2_UNSET)
1993 #define OPTION_MASK_ISA_SSE2_UNSET \
1994   (OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE3_UNSET)
1995 #define OPTION_MASK_ISA_SSE3_UNSET \
1996   (OPTION_MASK_ISA_SSE3 \
1997    | OPTION_MASK_ISA_SSSE3_UNSET \
1998    | OPTION_MASK_ISA_SSE4A_UNSET )
1999 #define OPTION_MASK_ISA_SSSE3_UNSET \
2000   (OPTION_MASK_ISA_SSSE3 | OPTION_MASK_ISA_SSE4_1_UNSET)
2001 #define OPTION_MASK_ISA_SSE4_1_UNSET \
2002   (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_SSE4_2_UNSET)
2003 #define OPTION_MASK_ISA_SSE4_2_UNSET \
2004   (OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_AVX_UNSET )
2005 #define OPTION_MASK_ISA_AVX_UNSET \
2006   (OPTION_MASK_ISA_AVX | OPTION_MASK_ISA_FMA_UNSET \
2007    | OPTION_MASK_ISA_FMA4_UNSET)
2008 #define OPTION_MASK_ISA_FMA_UNSET OPTION_MASK_ISA_FMA
2009
2010 /* SSE4 includes both SSE4.1 and SSE4.2.  -mno-sse4 should the same
2011    as -mno-sse4.1. */
2012 #define OPTION_MASK_ISA_SSE4_UNSET OPTION_MASK_ISA_SSE4_1_UNSET
2013
2014 #define OPTION_MASK_ISA_SSE4A_UNSET \
2015   (OPTION_MASK_ISA_SSE4A | OPTION_MASK_ISA_FMA4_UNSET)
2016
2017 #define OPTION_MASK_ISA_FMA4_UNSET \
2018   (OPTION_MASK_ISA_FMA4 | OPTION_MASK_ISA_XOP_UNSET)
2019 #define OPTION_MASK_ISA_XOP_UNSET OPTION_MASK_ISA_XOP
2020 #define OPTION_MASK_ISA_LWP_UNSET OPTION_MASK_ISA_LWP
2021
2022 #define OPTION_MASK_ISA_AES_UNSET OPTION_MASK_ISA_AES
2023 #define OPTION_MASK_ISA_PCLMUL_UNSET OPTION_MASK_ISA_PCLMUL
2024 #define OPTION_MASK_ISA_ABM_UNSET OPTION_MASK_ISA_ABM
2025 #define OPTION_MASK_ISA_POPCNT_UNSET OPTION_MASK_ISA_POPCNT
2026 #define OPTION_MASK_ISA_CX16_UNSET OPTION_MASK_ISA_CX16
2027 #define OPTION_MASK_ISA_SAHF_UNSET OPTION_MASK_ISA_SAHF
2028 #define OPTION_MASK_ISA_MOVBE_UNSET OPTION_MASK_ISA_MOVBE
2029 #define OPTION_MASK_ISA_CRC32_UNSET OPTION_MASK_ISA_CRC32
2030
2031 /* Vectorization library interface and handlers.  */
2032 tree (*ix86_veclib_handler)(enum built_in_function, tree, tree) = NULL;
2033 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2034 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2035
2036 /* Processor target table, indexed by processor number */
2037 struct ptt
2038 {
2039   const struct processor_costs *cost;           /* Processor costs */
2040   const int align_loop;                         /* Default alignments.  */
2041   const int align_loop_max_skip;
2042   const int align_jump;
2043   const int align_jump_max_skip;
2044   const int align_func;
2045 };
2046
2047 static const struct ptt processor_target_table[PROCESSOR_max] =
2048 {
2049   {&i386_cost, 4, 3, 4, 3, 4},
2050   {&i486_cost, 16, 15, 16, 15, 16},
2051   {&pentium_cost, 16, 7, 16, 7, 16},
2052   {&pentiumpro_cost, 16, 15, 16, 10, 16},
2053   {&geode_cost, 0, 0, 0, 0, 0},
2054   {&k6_cost, 32, 7, 32, 7, 32},
2055   {&athlon_cost, 16, 7, 16, 7, 16},
2056   {&pentium4_cost, 0, 0, 0, 0, 0},
2057   {&k8_cost, 16, 7, 16, 7, 16},
2058   {&nocona_cost, 0, 0, 0, 0, 0},
2059   {&core2_cost, 16, 10, 16, 10, 16},
2060   {&generic32_cost, 16, 7, 16, 7, 16},
2061   {&generic64_cost, 16, 10, 16, 10, 16},
2062   {&amdfam10_cost, 32, 24, 32, 7, 32},
2063   {&atom_cost, 16, 7, 16, 7, 16}
2064 };
2065
2066 static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2067 {
2068   "generic",
2069   "i386",
2070   "i486",
2071   "pentium",
2072   "pentium-mmx",
2073   "pentiumpro",
2074   "pentium2",
2075   "pentium3",
2076   "pentium4",
2077   "pentium-m",
2078   "prescott",
2079   "nocona",
2080   "core2",
2081   "atom",
2082   "geode",
2083   "k6",
2084   "k6-2",
2085   "k6-3",
2086   "athlon",
2087   "athlon-4",
2088   "k8",
2089   "amdfam10"
2090 };
2091 \f
2092 /* Implement TARGET_HANDLE_OPTION.  */
2093
2094 static bool
2095 ix86_handle_option (size_t code, const char *arg ATTRIBUTE_UNUSED, int value)
2096 {
2097   switch (code)
2098     {
2099     case OPT_mmmx:
2100       if (value)
2101         {
2102           ix86_isa_flags |= OPTION_MASK_ISA_MMX_SET;
2103           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_SET;
2104         }
2105       else
2106         {
2107           ix86_isa_flags &= ~OPTION_MASK_ISA_MMX_UNSET;
2108           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_UNSET;
2109         }
2110       return true;
2111
2112     case OPT_m3dnow:
2113       if (value)
2114         {
2115           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_SET;
2116           ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_SET;
2117         }
2118       else
2119         {
2120           ix86_isa_flags &= ~OPTION_MASK_ISA_3DNOW_UNSET;
2121           ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_UNSET;
2122         }
2123       return true;
2124
2125     case OPT_m3dnowa:
2126       return false;
2127
2128     case OPT_msse:
2129       if (value)
2130         {
2131           ix86_isa_flags |= OPTION_MASK_ISA_SSE_SET;
2132           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_SET;
2133         }
2134       else
2135         {
2136           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE_UNSET;
2137           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_UNSET;
2138         }
2139       return true;
2140
2141     case OPT_msse2:
2142       if (value)
2143         {
2144           ix86_isa_flags |= OPTION_MASK_ISA_SSE2_SET;
2145           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_SET;
2146         }
2147       else
2148         {
2149           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE2_UNSET;
2150           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_UNSET;
2151         }
2152       return true;
2153
2154     case OPT_msse3:
2155       if (value)
2156         {
2157           ix86_isa_flags |= OPTION_MASK_ISA_SSE3_SET;
2158           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_SET;
2159         }
2160       else
2161         {
2162           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE3_UNSET;
2163           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_UNSET;
2164         }
2165       return true;
2166
2167     case OPT_mssse3:
2168       if (value)
2169         {
2170           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3_SET;
2171           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_SET;
2172         }
2173       else
2174         {
2175           ix86_isa_flags &= ~OPTION_MASK_ISA_SSSE3_UNSET;
2176           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_UNSET;
2177         }
2178       return true;
2179
2180     case OPT_msse4_1:
2181       if (value)
2182         {
2183           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1_SET;
2184           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_SET;
2185         }
2186       else
2187         {
2188           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_1_UNSET;
2189           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_UNSET;
2190         }
2191       return true;
2192
2193     case OPT_msse4_2:
2194       if (value)
2195         {
2196           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2_SET;
2197           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_SET;
2198         }
2199       else
2200         {
2201           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_2_UNSET;
2202           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_UNSET;
2203         }
2204       return true;
2205
2206     case OPT_mavx:
2207       if (value)
2208         {
2209           ix86_isa_flags |= OPTION_MASK_ISA_AVX_SET;
2210           ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX_SET;
2211         }
2212       else
2213         {
2214           ix86_isa_flags &= ~OPTION_MASK_ISA_AVX_UNSET;
2215           ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX_UNSET;
2216         }
2217       return true;
2218
2219     case OPT_mfma:
2220       if (value)
2221         {
2222           ix86_isa_flags |= OPTION_MASK_ISA_FMA_SET;
2223           ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA_SET;
2224         }
2225       else
2226         {
2227           ix86_isa_flags &= ~OPTION_MASK_ISA_FMA_UNSET;
2228           ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA_UNSET;
2229         }
2230       return true;
2231
2232     case OPT_msse4:
2233       ix86_isa_flags |= OPTION_MASK_ISA_SSE4_SET;
2234       ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_SET;
2235       return true;
2236
2237     case OPT_mno_sse4:
2238       ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_UNSET;
2239       ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_UNSET;
2240       return true;
2241
2242     case OPT_msse4a:
2243       if (value)
2244         {
2245           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A_SET;
2246           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_SET;
2247         }
2248       else
2249         {
2250           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4A_UNSET;
2251           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_UNSET;
2252         }
2253       return true;
2254
2255     case OPT_mfma4:
2256       if (value)
2257         {
2258           ix86_isa_flags |= OPTION_MASK_ISA_FMA4_SET;
2259           ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA4_SET;
2260         }
2261       else
2262         {
2263           ix86_isa_flags &= ~OPTION_MASK_ISA_FMA4_UNSET;
2264           ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA4_UNSET;
2265         }
2266       return true;
2267
2268    case OPT_mxop:
2269       if (value)
2270         {
2271           ix86_isa_flags |= OPTION_MASK_ISA_XOP_SET;
2272           ix86_isa_flags_explicit |= OPTION_MASK_ISA_XOP_SET;
2273         }
2274       else
2275         {
2276           ix86_isa_flags &= ~OPTION_MASK_ISA_XOP_UNSET;
2277           ix86_isa_flags_explicit |= OPTION_MASK_ISA_XOP_UNSET;
2278         }
2279       return true;
2280
2281    case OPT_mlwp:
2282       if (value)
2283         {
2284           ix86_isa_flags |= OPTION_MASK_ISA_LWP_SET;
2285           ix86_isa_flags_explicit |= OPTION_MASK_ISA_LWP_SET;
2286         }
2287       else
2288         {
2289           ix86_isa_flags &= ~OPTION_MASK_ISA_LWP_UNSET;
2290           ix86_isa_flags_explicit |= OPTION_MASK_ISA_LWP_UNSET;
2291         }
2292       return true;
2293
2294     case OPT_mabm:
2295       if (value)
2296         {
2297           ix86_isa_flags |= OPTION_MASK_ISA_ABM_SET;
2298           ix86_isa_flags_explicit |= OPTION_MASK_ISA_ABM_SET;
2299         }
2300       else
2301         {
2302           ix86_isa_flags &= ~OPTION_MASK_ISA_ABM_UNSET;
2303           ix86_isa_flags_explicit |= OPTION_MASK_ISA_ABM_UNSET;
2304         }
2305       return true;
2306
2307     case OPT_mpopcnt:
2308       if (value)
2309         {
2310           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT_SET;
2311           ix86_isa_flags_explicit |= OPTION_MASK_ISA_POPCNT_SET;
2312         }
2313       else
2314         {
2315           ix86_isa_flags &= ~OPTION_MASK_ISA_POPCNT_UNSET;
2316           ix86_isa_flags_explicit |= OPTION_MASK_ISA_POPCNT_UNSET;
2317         }
2318       return true;
2319
2320     case OPT_msahf:
2321       if (value)
2322         {
2323           ix86_isa_flags |= OPTION_MASK_ISA_SAHF_SET;
2324           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SAHF_SET;
2325         }
2326       else
2327         {
2328           ix86_isa_flags &= ~OPTION_MASK_ISA_SAHF_UNSET;
2329           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SAHF_UNSET;
2330         }
2331       return true;
2332
2333     case OPT_mcx16:
2334       if (value)
2335         {
2336           ix86_isa_flags |= OPTION_MASK_ISA_CX16_SET;
2337           ix86_isa_flags_explicit |= OPTION_MASK_ISA_CX16_SET;
2338         }
2339       else
2340         {
2341           ix86_isa_flags &= ~OPTION_MASK_ISA_CX16_UNSET;
2342           ix86_isa_flags_explicit |= OPTION_MASK_ISA_CX16_UNSET;
2343         }
2344       return true;
2345
2346     case OPT_mmovbe:
2347       if (value)
2348         {
2349           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE_SET;
2350           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MOVBE_SET;
2351         }
2352       else
2353         {
2354           ix86_isa_flags &= ~OPTION_MASK_ISA_MOVBE_UNSET;
2355           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MOVBE_UNSET;
2356         }
2357       return true;
2358
2359     case OPT_mcrc32:
2360       if (value)
2361         {
2362           ix86_isa_flags |= OPTION_MASK_ISA_CRC32_SET;
2363           ix86_isa_flags_explicit |= OPTION_MASK_ISA_CRC32_SET;
2364         }
2365       else
2366         {
2367           ix86_isa_flags &= ~OPTION_MASK_ISA_CRC32_UNSET;
2368           ix86_isa_flags_explicit |= OPTION_MASK_ISA_CRC32_UNSET;
2369         }
2370       return true;
2371
2372     case OPT_maes:
2373       if (value)
2374         {
2375           ix86_isa_flags |= OPTION_MASK_ISA_AES_SET;
2376           ix86_isa_flags_explicit |= OPTION_MASK_ISA_AES_SET;
2377         }
2378       else
2379         {
2380           ix86_isa_flags &= ~OPTION_MASK_ISA_AES_UNSET;
2381           ix86_isa_flags_explicit |= OPTION_MASK_ISA_AES_UNSET;
2382         }
2383       return true;
2384
2385     case OPT_mpclmul:
2386       if (value)
2387         {
2388           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL_SET;
2389           ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCLMUL_SET;
2390         }
2391       else
2392         {
2393           ix86_isa_flags &= ~OPTION_MASK_ISA_PCLMUL_UNSET;
2394           ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCLMUL_UNSET;
2395         }
2396       return true;
2397
2398     default:
2399       return true;
2400     }
2401 }
2402 \f
2403 /* Return a string the documents the current -m options.  The caller is
2404    responsible for freeing the string.  */
2405
2406 static char *
2407 ix86_target_string (int isa, int flags, const char *arch, const char *tune,
2408                     const char *fpmath, bool add_nl_p)
2409 {
2410   struct ix86_target_opts
2411   {
2412     const char *option;         /* option string */
2413     int mask;                   /* isa mask options */
2414   };
2415
2416   /* This table is ordered so that options like -msse4.2 that imply
2417      preceding options while match those first.  */
2418   static struct ix86_target_opts isa_opts[] =
2419   {
2420     { "-m64",           OPTION_MASK_ISA_64BIT },
2421     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2422     { "-mxop",          OPTION_MASK_ISA_XOP },
2423     { "-mlwp",          OPTION_MASK_ISA_LWP },
2424     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2425     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2426     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2427     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2428     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2429     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2430     { "-msse",          OPTION_MASK_ISA_SSE },
2431     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2432     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2433     { "-mmmx",          OPTION_MASK_ISA_MMX },
2434     { "-mabm",          OPTION_MASK_ISA_ABM },
2435     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2436     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2437     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2438     { "-maes",          OPTION_MASK_ISA_AES },
2439     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2440   };
2441
2442   /* Flag options.  */
2443   static struct ix86_target_opts flag_opts[] =
2444   {
2445     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2446     { "-m80387",                        MASK_80387 },
2447     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2448     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2449     { "-mcld",                          MASK_CLD },
2450     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2451     { "-mieee-fp",                      MASK_IEEE_FP },
2452     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2453     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2454     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2455     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2456     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2457     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2458     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2459     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2460     { "-mrecip",                        MASK_RECIP },
2461     { "-mrtd",                          MASK_RTD },
2462     { "-msseregparm",                   MASK_SSEREGPARM },
2463     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2464     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2465   };
2466
2467   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2468
2469   char isa_other[40];
2470   char target_other[40];
2471   unsigned num = 0;
2472   unsigned i, j;
2473   char *ret;
2474   char *ptr;
2475   size_t len;
2476   size_t line_len;
2477   size_t sep_len;
2478
2479   memset (opts, '\0', sizeof (opts));
2480
2481   /* Add -march= option.  */
2482   if (arch)
2483     {
2484       opts[num][0] = "-march=";
2485       opts[num++][1] = arch;
2486     }
2487
2488   /* Add -mtune= option.  */
2489   if (tune)
2490     {
2491       opts[num][0] = "-mtune=";
2492       opts[num++][1] = tune;
2493     }
2494
2495   /* Pick out the options in isa options.  */
2496   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2497     {
2498       if ((isa & isa_opts[i].mask) != 0)
2499         {
2500           opts[num++][0] = isa_opts[i].option;
2501           isa &= ~ isa_opts[i].mask;
2502         }
2503     }
2504
2505   if (isa && add_nl_p)
2506     {
2507       opts[num++][0] = isa_other;
2508       sprintf (isa_other, "(other isa: 0x%x)", isa);
2509     }
2510
2511   /* Add flag options.  */
2512   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2513     {
2514       if ((flags & flag_opts[i].mask) != 0)
2515         {
2516           opts[num++][0] = flag_opts[i].option;
2517           flags &= ~ flag_opts[i].mask;
2518         }
2519     }
2520
2521   if (flags && add_nl_p)
2522     {
2523       opts[num++][0] = target_other;
2524       sprintf (target_other, "(other flags: 0x%x)", isa);
2525     }
2526
2527   /* Add -fpmath= option.  */
2528   if (fpmath)
2529     {
2530       opts[num][0] = "-mfpmath=";
2531       opts[num++][1] = fpmath;
2532     }
2533
2534   /* Any options?  */
2535   if (num == 0)
2536     return NULL;
2537
2538   gcc_assert (num < ARRAY_SIZE (opts));
2539
2540   /* Size the string.  */
2541   len = 0;
2542   sep_len = (add_nl_p) ? 3 : 1;
2543   for (i = 0; i < num; i++)
2544     {
2545       len += sep_len;
2546       for (j = 0; j < 2; j++)
2547         if (opts[i][j])
2548           len += strlen (opts[i][j]);
2549     }
2550
2551   /* Build the string.  */
2552   ret = ptr = (char *) xmalloc (len);
2553   line_len = 0;
2554
2555   for (i = 0; i < num; i++)
2556     {
2557       size_t len2[2];
2558
2559       for (j = 0; j < 2; j++)
2560         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2561
2562       if (i != 0)
2563         {
2564           *ptr++ = ' ';
2565           line_len++;
2566
2567           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2568             {
2569               *ptr++ = '\\';
2570               *ptr++ = '\n';
2571               line_len = 0;
2572             }
2573         }
2574
2575       for (j = 0; j < 2; j++)
2576         if (opts[i][j])
2577           {
2578             memcpy (ptr, opts[i][j], len2[j]);
2579             ptr += len2[j];
2580             line_len += len2[j];
2581           }
2582     }
2583
2584   *ptr = '\0';
2585   gcc_assert (ret + len >= ptr);
2586
2587   return ret;
2588 }
2589
2590 /* Function that is callable from the debugger to print the current
2591    options.  */
2592 void
2593 ix86_debug_options (void)
2594 {
2595   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2596                                    ix86_arch_string, ix86_tune_string,
2597                                    ix86_fpmath_string, true);
2598
2599   if (opts)
2600     {
2601       fprintf (stderr, "%s\n\n", opts);
2602       free (opts);
2603     }
2604   else
2605     fputs ("<no options>\n\n", stderr);
2606
2607   return;
2608 }
2609 \f
2610 /* Sometimes certain combinations of command options do not make
2611    sense on a particular target machine.  You can define a macro
2612    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
2613    defined, is executed once just after all the command options have
2614    been parsed.
2615
2616    Don't use this macro to turn on various extra optimizations for
2617    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
2618
2619 void
2620 override_options (bool main_args_p)
2621 {
2622   int i;
2623   unsigned int ix86_arch_mask, ix86_tune_mask;
2624   const char *prefix;
2625   const char *suffix;
2626   const char *sw;
2627
2628   /* Comes from final.c -- no real reason to change it.  */
2629 #define MAX_CODE_ALIGN 16
2630
2631   enum pta_flags
2632     {
2633       PTA_SSE = 1 << 0,
2634       PTA_SSE2 = 1 << 1,
2635       PTA_SSE3 = 1 << 2,
2636       PTA_MMX = 1 << 3,
2637       PTA_PREFETCH_SSE = 1 << 4,
2638       PTA_3DNOW = 1 << 5,
2639       PTA_3DNOW_A = 1 << 6,
2640       PTA_64BIT = 1 << 7,
2641       PTA_SSSE3 = 1 << 8,
2642       PTA_CX16 = 1 << 9,
2643       PTA_POPCNT = 1 << 10,
2644       PTA_ABM = 1 << 11,
2645       PTA_SSE4A = 1 << 12,
2646       PTA_NO_SAHF = 1 << 13,
2647       PTA_SSE4_1 = 1 << 14,
2648       PTA_SSE4_2 = 1 << 15,
2649       PTA_AES = 1 << 16,
2650       PTA_PCLMUL = 1 << 17,
2651       PTA_AVX = 1 << 18,
2652       PTA_FMA = 1 << 19,
2653       PTA_MOVBE = 1 << 20,
2654       PTA_FMA4 = 1 << 21,
2655       PTA_XOP = 1 << 22,
2656       PTA_LWP = 1 << 23
2657     };
2658
2659   static struct pta
2660     {
2661       const char *const name;           /* processor name or nickname.  */
2662       const enum processor_type processor;
2663       const enum attr_cpu schedule;
2664       const unsigned /*enum pta_flags*/ flags;
2665     }
2666   const processor_alias_table[] =
2667     {
2668       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2669       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2670       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2671       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2672       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2673       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2674       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2675       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2676       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2677       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2678       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2679       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2680       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2681         PTA_MMX | PTA_SSE},
2682       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2683         PTA_MMX | PTA_SSE},
2684       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2685         PTA_MMX | PTA_SSE | PTA_SSE2},
2686       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2687         PTA_MMX |PTA_SSE | PTA_SSE2},
2688       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2689         PTA_MMX | PTA_SSE | PTA_SSE2},
2690       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2691         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2692       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2693         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2694         | PTA_CX16 | PTA_NO_SAHF},
2695       {"core2", PROCESSOR_CORE2, CPU_CORE2,
2696         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2697         | PTA_SSSE3 | PTA_CX16},
2698       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2699         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2700         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2701       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2702         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2703       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2704       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2705       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2706       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
2707         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2708       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
2709         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2710       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
2711         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2712       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
2713         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2714       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
2715         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2716       {"x86-64", PROCESSOR_K8, CPU_K8,
2717         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
2718       {"k8", PROCESSOR_K8, CPU_K8,
2719         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2720         | PTA_SSE2 | PTA_NO_SAHF},
2721       {"k8-sse3", PROCESSOR_K8, CPU_K8,
2722         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2723         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
2724       {"opteron", PROCESSOR_K8, CPU_K8,
2725         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2726         | PTA_SSE2 | PTA_NO_SAHF},
2727       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
2728         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2729         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
2730       {"athlon64", PROCESSOR_K8, CPU_K8,
2731         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2732         | PTA_SSE2 | PTA_NO_SAHF},
2733       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
2734         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2735         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
2736       {"athlon-fx", PROCESSOR_K8, CPU_K8,
2737         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2738         | PTA_SSE2 | PTA_NO_SAHF},
2739       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
2740         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2741         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
2742       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
2743         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2744         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
2745       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
2746         0 /* flags are only used for -march switch.  */ },
2747       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
2748         PTA_64BIT /* flags are only used for -march switch.  */ },
2749     };
2750
2751   int const pta_size = ARRAY_SIZE (processor_alias_table);
2752
2753   /* Set up prefix/suffix so the error messages refer to either the command
2754      line argument, or the attribute(target).  */
2755   if (main_args_p)
2756     {
2757       prefix = "-m";
2758       suffix = "";
2759       sw = "switch";
2760     }
2761   else
2762     {
2763       prefix = "option(\"";
2764       suffix = "\")";
2765       sw = "attribute";
2766     }
2767
2768 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2769   SUBTARGET_OVERRIDE_OPTIONS;
2770 #endif
2771
2772 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2773   SUBSUBTARGET_OVERRIDE_OPTIONS;
2774 #endif
2775
2776   /* -fPIC is the default for x86_64.  */
2777   if (TARGET_MACHO && TARGET_64BIT)
2778     flag_pic = 2;
2779
2780   /* Set the default values for switches whose default depends on TARGET_64BIT
2781      in case they weren't overwritten by command line options.  */
2782   if (TARGET_64BIT)
2783     {
2784       /* Mach-O doesn't support omitting the frame pointer for now.  */
2785       if (flag_omit_frame_pointer == 2)
2786         flag_omit_frame_pointer = (TARGET_MACHO ? 0 : 1);
2787       if (flag_asynchronous_unwind_tables == 2)
2788         flag_asynchronous_unwind_tables = 1;
2789       if (flag_pcc_struct_return == 2)
2790         flag_pcc_struct_return = 0;
2791     }
2792   else
2793     {
2794       if (flag_omit_frame_pointer == 2)
2795         flag_omit_frame_pointer = 0;
2796       if (flag_asynchronous_unwind_tables == 2)
2797         flag_asynchronous_unwind_tables = 0;
2798       if (flag_pcc_struct_return == 2)
2799         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
2800     }
2801
2802   /* Need to check -mtune=generic first.  */
2803   if (ix86_tune_string)
2804     {
2805       if (!strcmp (ix86_tune_string, "generic")
2806           || !strcmp (ix86_tune_string, "i686")
2807           /* As special support for cross compilers we read -mtune=native
2808              as -mtune=generic.  With native compilers we won't see the
2809              -mtune=native, as it was changed by the driver.  */
2810           || !strcmp (ix86_tune_string, "native"))
2811         {
2812           if (TARGET_64BIT)
2813             ix86_tune_string = "generic64";
2814           else
2815             ix86_tune_string = "generic32";
2816         }
2817       /* If this call is for setting the option attribute, allow the
2818          generic32/generic64 that was previously set.  */
2819       else if (!main_args_p
2820                && (!strcmp (ix86_tune_string, "generic32")
2821                    || !strcmp (ix86_tune_string, "generic64")))
2822         ;
2823       else if (!strncmp (ix86_tune_string, "generic", 7))
2824         error ("bad value (%s) for %stune=%s %s",
2825                ix86_tune_string, prefix, suffix, sw);
2826     }
2827   else
2828     {
2829       if (ix86_arch_string)
2830         ix86_tune_string = ix86_arch_string;
2831       if (!ix86_tune_string)
2832         {
2833           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
2834           ix86_tune_defaulted = 1;
2835         }
2836
2837       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
2838          need to use a sensible tune option.  */
2839       if (!strcmp (ix86_tune_string, "generic")
2840           || !strcmp (ix86_tune_string, "x86-64")
2841           || !strcmp (ix86_tune_string, "i686"))
2842         {
2843           if (TARGET_64BIT)
2844             ix86_tune_string = "generic64";
2845           else
2846             ix86_tune_string = "generic32";
2847         }
2848     }
2849   if (ix86_stringop_string)
2850     {
2851       if (!strcmp (ix86_stringop_string, "rep_byte"))
2852         stringop_alg = rep_prefix_1_byte;
2853       else if (!strcmp (ix86_stringop_string, "libcall"))
2854         stringop_alg = libcall;
2855       else if (!strcmp (ix86_stringop_string, "rep_4byte"))
2856         stringop_alg = rep_prefix_4_byte;
2857       else if (!strcmp (ix86_stringop_string, "rep_8byte")
2858                && TARGET_64BIT)
2859         /* rep; movq isn't available in 32-bit code.  */
2860         stringop_alg = rep_prefix_8_byte;
2861       else if (!strcmp (ix86_stringop_string, "byte_loop"))
2862         stringop_alg = loop_1_byte;
2863       else if (!strcmp (ix86_stringop_string, "loop"))
2864         stringop_alg = loop;
2865       else if (!strcmp (ix86_stringop_string, "unrolled_loop"))
2866         stringop_alg = unrolled_loop;
2867       else
2868         error ("bad value (%s) for %sstringop-strategy=%s %s",
2869                ix86_stringop_string, prefix, suffix, sw);
2870     }
2871   if (!strcmp (ix86_tune_string, "x86-64"))
2872     warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated.  Use "
2873              "%stune=k8%s or %stune=generic%s instead as appropriate.",
2874              prefix, suffix, prefix, suffix, prefix, suffix);
2875
2876   if (!ix86_arch_string)
2877     ix86_arch_string = TARGET_64BIT ? "x86-64" : "i386";
2878   else
2879     ix86_arch_specified = 1;
2880
2881   if (!strcmp (ix86_arch_string, "generic"))
2882     error ("generic CPU can be used only for %stune=%s %s",
2883            prefix, suffix, sw);
2884   if (!strncmp (ix86_arch_string, "generic", 7))
2885     error ("bad value (%s) for %sarch=%s %s",
2886            ix86_arch_string, prefix, suffix, sw);
2887
2888   /* Validate -mabi= value.  */
2889   if (ix86_abi_string)
2890     {
2891       if (strcmp (ix86_abi_string, "sysv") == 0)
2892         ix86_abi = SYSV_ABI;
2893       else if (strcmp (ix86_abi_string, "ms") == 0)
2894         ix86_abi = MS_ABI;
2895       else
2896         error ("unknown ABI (%s) for %sabi=%s %s",
2897                ix86_abi_string, prefix, suffix, sw);
2898     }
2899   else
2900     ix86_abi = DEFAULT_ABI;
2901
2902   if (ix86_cmodel_string != 0)
2903     {
2904       if (!strcmp (ix86_cmodel_string, "small"))
2905         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
2906       else if (!strcmp (ix86_cmodel_string, "medium"))
2907         ix86_cmodel = flag_pic ? CM_MEDIUM_PIC : CM_MEDIUM;
2908       else if (!strcmp (ix86_cmodel_string, "large"))
2909         ix86_cmodel = flag_pic ? CM_LARGE_PIC : CM_LARGE;
2910       else if (flag_pic)
2911         error ("code model %s does not support PIC mode", ix86_cmodel_string);
2912       else if (!strcmp (ix86_cmodel_string, "32"))
2913         ix86_cmodel = CM_32;
2914       else if (!strcmp (ix86_cmodel_string, "kernel") && !flag_pic)
2915         ix86_cmodel = CM_KERNEL;
2916       else
2917         error ("bad value (%s) for %scmodel=%s %s",
2918                ix86_cmodel_string, prefix, suffix, sw);
2919     }
2920   else
2921     {
2922       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
2923          use of rip-relative addressing.  This eliminates fixups that
2924          would otherwise be needed if this object is to be placed in a
2925          DLL, and is essentially just as efficient as direct addressing.  */
2926       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
2927         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
2928       else if (TARGET_64BIT)
2929         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
2930       else
2931         ix86_cmodel = CM_32;
2932     }
2933   if (ix86_asm_string != 0)
2934     {
2935       if (! TARGET_MACHO
2936           && !strcmp (ix86_asm_string, "intel"))
2937         ix86_asm_dialect = ASM_INTEL;
2938       else if (!strcmp (ix86_asm_string, "att"))
2939         ix86_asm_dialect = ASM_ATT;
2940       else
2941         error ("bad value (%s) for %sasm=%s %s",
2942                ix86_asm_string, prefix, suffix, sw);
2943     }
2944   if ((TARGET_64BIT == 0) != (ix86_cmodel == CM_32))
2945     error ("code model %qs not supported in the %s bit mode",
2946            ix86_cmodel_string, TARGET_64BIT ? "64" : "32");
2947   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
2948     sorry ("%i-bit mode not compiled in",
2949            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
2950
2951   for (i = 0; i < pta_size; i++)
2952     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
2953       {
2954         ix86_schedule = processor_alias_table[i].schedule;
2955         ix86_arch = processor_alias_table[i].processor;
2956         /* Default cpu tuning to the architecture.  */
2957         ix86_tune = ix86_arch;
2958
2959         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
2960           error ("CPU you selected does not support x86-64 "
2961                  "instruction set");
2962
2963         if (processor_alias_table[i].flags & PTA_MMX
2964             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
2965           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
2966         if (processor_alias_table[i].flags & PTA_3DNOW
2967             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
2968           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
2969         if (processor_alias_table[i].flags & PTA_3DNOW_A
2970             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
2971           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
2972         if (processor_alias_table[i].flags & PTA_SSE
2973             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
2974           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
2975         if (processor_alias_table[i].flags & PTA_SSE2
2976             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
2977           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
2978         if (processor_alias_table[i].flags & PTA_SSE3
2979             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
2980           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
2981         if (processor_alias_table[i].flags & PTA_SSSE3
2982             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
2983           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
2984         if (processor_alias_table[i].flags & PTA_SSE4_1
2985             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
2986           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
2987         if (processor_alias_table[i].flags & PTA_SSE4_2
2988             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
2989           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
2990         if (processor_alias_table[i].flags & PTA_AVX
2991             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
2992           ix86_isa_flags |= OPTION_MASK_ISA_AVX;
2993         if (processor_alias_table[i].flags & PTA_FMA
2994             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
2995           ix86_isa_flags |= OPTION_MASK_ISA_FMA;
2996         if (processor_alias_table[i].flags & PTA_SSE4A
2997             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
2998           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
2999         if (processor_alias_table[i].flags & PTA_FMA4
3000             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
3001           ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
3002         if (processor_alias_table[i].flags & PTA_XOP
3003             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
3004           ix86_isa_flags |= OPTION_MASK_ISA_XOP;
3005         if (processor_alias_table[i].flags & PTA_LWP
3006             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
3007           ix86_isa_flags |= OPTION_MASK_ISA_LWP;
3008         if (processor_alias_table[i].flags & PTA_ABM
3009             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
3010           ix86_isa_flags |= OPTION_MASK_ISA_ABM;
3011         if (processor_alias_table[i].flags & PTA_CX16
3012             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_CX16))
3013           ix86_isa_flags |= OPTION_MASK_ISA_CX16;
3014         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)
3015             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
3016           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
3017         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF))
3018             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
3019           ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
3020         if (processor_alias_table[i].flags & PTA_MOVBE
3021             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MOVBE))
3022           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE;
3023         if (processor_alias_table[i].flags & PTA_AES
3024             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
3025           ix86_isa_flags |= OPTION_MASK_ISA_AES;
3026         if (processor_alias_table[i].flags & PTA_PCLMUL
3027             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
3028           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
3029         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
3030           x86_prefetch_sse = true;
3031
3032         break;
3033       }
3034
3035   if (i == pta_size)
3036     error ("bad value (%s) for %sarch=%s %s",
3037            ix86_arch_string, prefix, suffix, sw);
3038
3039   ix86_arch_mask = 1u << ix86_arch;
3040   for (i = 0; i < X86_ARCH_LAST; ++i)
3041     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3042
3043   for (i = 0; i < pta_size; i++)
3044     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
3045       {
3046         ix86_schedule = processor_alias_table[i].schedule;
3047         ix86_tune = processor_alias_table[i].processor;
3048         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
3049           {
3050             if (ix86_tune_defaulted)
3051               {
3052                 ix86_tune_string = "x86-64";
3053                 for (i = 0; i < pta_size; i++)
3054                   if (! strcmp (ix86_tune_string,
3055                                 processor_alias_table[i].name))
3056                     break;
3057                 ix86_schedule = processor_alias_table[i].schedule;
3058                 ix86_tune = processor_alias_table[i].processor;
3059               }
3060             else
3061               error ("CPU you selected does not support x86-64 "
3062                      "instruction set");
3063           }
3064         /* Intel CPUs have always interpreted SSE prefetch instructions as
3065            NOPs; so, we can enable SSE prefetch instructions even when
3066            -mtune (rather than -march) points us to a processor that has them.
3067            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
3068            higher processors.  */
3069         if (TARGET_CMOVE
3070             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
3071           x86_prefetch_sse = true;
3072         break;
3073       }
3074   if (i == pta_size)
3075     error ("bad value (%s) for %stune=%s %s",
3076            ix86_tune_string, prefix, suffix, sw);
3077
3078   ix86_tune_mask = 1u << ix86_tune;
3079   for (i = 0; i < X86_TUNE_LAST; ++i)
3080     ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3081
3082   if (optimize_size)
3083     ix86_cost = &ix86_size_cost;
3084   else
3085     ix86_cost = processor_target_table[ix86_tune].cost;
3086
3087   /* Arrange to set up i386_stack_locals for all functions.  */
3088   init_machine_status = ix86_init_machine_status;
3089
3090   /* Validate -mregparm= value.  */
3091   if (ix86_regparm_string)
3092     {
3093       if (TARGET_64BIT)
3094         warning (0, "%sregparm%s is ignored in 64-bit mode", prefix, suffix);
3095       i = atoi (ix86_regparm_string);
3096       if (i < 0 || i > REGPARM_MAX)
3097         error ("%sregparm=%d%s is not between 0 and %d",
3098                prefix, i, suffix, REGPARM_MAX);
3099       else
3100         ix86_regparm = i;
3101     }
3102   if (TARGET_64BIT)
3103     ix86_regparm = REGPARM_MAX;
3104
3105   /* If the user has provided any of the -malign-* options,
3106      warn and use that value only if -falign-* is not set.
3107      Remove this code in GCC 3.2 or later.  */
3108   if (ix86_align_loops_string)
3109     {
3110       warning (0, "%salign-loops%s is obsolete, use -falign-loops%s",
3111                prefix, suffix, suffix);
3112       if (align_loops == 0)
3113         {
3114           i = atoi (ix86_align_loops_string);
3115           if (i < 0 || i > MAX_CODE_ALIGN)
3116             error ("%salign-loops=%d%s is not between 0 and %d",
3117                    prefix, i, suffix, MAX_CODE_ALIGN);
3118           else
3119             align_loops = 1 << i;
3120         }
3121     }
3122
3123   if (ix86_align_jumps_string)
3124     {
3125       warning (0, "%salign-jumps%s is obsolete, use -falign-jumps%s",
3126                prefix, suffix, suffix);
3127       if (align_jumps == 0)
3128         {
3129           i = atoi (ix86_align_jumps_string);
3130           if (i < 0 || i > MAX_CODE_ALIGN)
3131             error ("%salign-loops=%d%s is not between 0 and %d",
3132                    prefix, i, suffix, MAX_CODE_ALIGN);
3133           else
3134             align_jumps = 1 << i;
3135         }
3136     }
3137
3138   if (ix86_align_funcs_string)
3139     {
3140       warning (0, "%salign-functions%s is obsolete, use -falign-functions%s",
3141                prefix, suffix, suffix);
3142       if (align_functions == 0)
3143         {
3144           i = atoi (ix86_align_funcs_string);
3145           if (i < 0 || i > MAX_CODE_ALIGN)
3146             error ("%salign-loops=%d%s is not between 0 and %d",
3147                    prefix, i, suffix, MAX_CODE_ALIGN);
3148           else
3149             align_functions = 1 << i;
3150         }
3151     }
3152
3153   /* Default align_* from the processor table.  */
3154   if (align_loops == 0)
3155     {
3156       align_loops = processor_target_table[ix86_tune].align_loop;
3157       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3158     }
3159   if (align_jumps == 0)
3160     {
3161       align_jumps = processor_target_table[ix86_tune].align_jump;
3162       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3163     }
3164   if (align_functions == 0)
3165     {
3166       align_functions = processor_target_table[ix86_tune].align_func;
3167     }
3168
3169   /* Validate -mbranch-cost= value, or provide default.  */
3170   ix86_branch_cost = ix86_cost->branch_cost;
3171   if (ix86_branch_cost_string)
3172     {
3173       i = atoi (ix86_branch_cost_string);
3174       if (i < 0 || i > 5)
3175         error ("%sbranch-cost=%d%s is not between 0 and 5", prefix, i, suffix);
3176       else
3177         ix86_branch_cost = i;
3178     }
3179   if (ix86_section_threshold_string)
3180     {
3181       i = atoi (ix86_section_threshold_string);
3182       if (i < 0)
3183         error ("%slarge-data-threshold=%d%s is negative", prefix, i, suffix);
3184       else
3185         ix86_section_threshold = i;
3186     }
3187
3188   if (ix86_tls_dialect_string)
3189     {
3190       if (strcmp (ix86_tls_dialect_string, "gnu") == 0)
3191         ix86_tls_dialect = TLS_DIALECT_GNU;
3192       else if (strcmp (ix86_tls_dialect_string, "gnu2") == 0)
3193         ix86_tls_dialect = TLS_DIALECT_GNU2;
3194       else if (strcmp (ix86_tls_dialect_string, "sun") == 0)
3195         ix86_tls_dialect = TLS_DIALECT_SUN;
3196       else
3197         error ("bad value (%s) for %stls-dialect=%s %s",
3198                ix86_tls_dialect_string, prefix, suffix, sw);
3199     }
3200
3201   if (ix87_precision_string)
3202     {
3203       i = atoi (ix87_precision_string);
3204       if (i != 32 && i != 64 && i != 80)
3205         error ("pc%d is not valid precision setting (32, 64 or 80)", i);
3206     }
3207
3208   if (TARGET_64BIT)
3209     {
3210       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
3211
3212       /* Enable by default the SSE and MMX builtins.  Do allow the user to
3213          explicitly disable any of these.  In particular, disabling SSE and
3214          MMX for kernel code is extremely useful.  */
3215       if (!ix86_arch_specified)
3216       ix86_isa_flags
3217         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
3218              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
3219
3220       if (TARGET_RTD)
3221         warning (0, "%srtd%s is ignored in 64bit mode", prefix, suffix);
3222     }
3223   else
3224     {
3225       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
3226
3227       if (!ix86_arch_specified)
3228       ix86_isa_flags
3229         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
3230
3231       /* i386 ABI does not specify red zone.  It still makes sense to use it
3232          when programmer takes care to stack from being destroyed.  */
3233       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
3234         target_flags |= MASK_NO_RED_ZONE;
3235     }
3236
3237   /* Keep nonleaf frame pointers.  */
3238   if (flag_omit_frame_pointer)
3239     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
3240   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
3241     flag_omit_frame_pointer = 1;
3242
3243   /* If we're doing fast math, we don't care about comparison order
3244      wrt NaNs.  This lets us use a shorter comparison sequence.  */
3245   if (flag_finite_math_only)
3246     target_flags &= ~MASK_IEEE_FP;
3247
3248   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
3249      since the insns won't need emulation.  */
3250   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
3251     target_flags &= ~MASK_NO_FANCY_MATH_387;
3252
3253   /* Likewise, if the target doesn't have a 387, or we've specified
3254      software floating point, don't use 387 inline intrinsics.  */
3255   if (!TARGET_80387)
3256     target_flags |= MASK_NO_FANCY_MATH_387;
3257
3258   /* Turn on MMX builtins for -msse.  */
3259   if (TARGET_SSE)
3260     {
3261       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
3262       x86_prefetch_sse = true;
3263     }
3264
3265   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
3266   if (TARGET_SSE4_2 || TARGET_ABM)
3267     ix86_isa_flags |= OPTION_MASK_ISA_POPCNT & ~ix86_isa_flags_explicit;
3268
3269   /* Validate -mpreferred-stack-boundary= value or default it to
3270      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
3271   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
3272   if (ix86_preferred_stack_boundary_string)
3273     {
3274       i = atoi (ix86_preferred_stack_boundary_string);
3275       if (i < (TARGET_64BIT ? 4 : 2) || i > 12)
3276         error ("%spreferred-stack-boundary=%d%s is not between %d and 12",
3277                prefix, i, suffix, TARGET_64BIT ? 4 : 2);
3278       else
3279         ix86_preferred_stack_boundary = (1 << i) * BITS_PER_UNIT;
3280     }
3281
3282   /* Set the default value for -mstackrealign.  */
3283   if (ix86_force_align_arg_pointer == -1)
3284     ix86_force_align_arg_pointer = STACK_REALIGN_DEFAULT;
3285
3286   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
3287
3288   /* Validate -mincoming-stack-boundary= value or default it to
3289      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
3290   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
3291   if (ix86_incoming_stack_boundary_string)
3292     {
3293       i = atoi (ix86_incoming_stack_boundary_string);
3294       if (i < (TARGET_64BIT ? 4 : 2) || i > 12)
3295         error ("-mincoming-stack-boundary=%d is not between %d and 12",
3296                i, TARGET_64BIT ? 4 : 2);
3297       else
3298         {
3299    &nb