OSDN Git Service

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