OSDN Git Service

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