OSDN Git Service

Revert:
[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_acml (enum built_in_function, tree, tree);
1834
1835 /* Implement TARGET_HANDLE_OPTION.  */
1836
1837 static bool
1838 ix86_handle_option (size_t code, const char *arg ATTRIBUTE_UNUSED, int value)
1839 {
1840   switch (code)
1841     {
1842     case OPT_mmmx:
1843       if (value)
1844         {
1845           ix86_isa_flags |= OPTION_MASK_ISA_MMX_SET;
1846           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_SET;
1847         }
1848       else
1849         {
1850           ix86_isa_flags &= ~OPTION_MASK_ISA_MMX_UNSET;
1851           ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_UNSET;
1852         }
1853       return true;
1854
1855     case OPT_m3dnow:
1856       if (value)
1857         {
1858           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_SET;
1859           ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_SET;
1860         }
1861       else
1862         {
1863           ix86_isa_flags &= ~OPTION_MASK_ISA_3DNOW_UNSET;
1864           ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_UNSET;
1865         }
1866       return true;
1867
1868     case OPT_m3dnowa:
1869       return false;
1870
1871     case OPT_msse:
1872       if (value)
1873         {
1874           ix86_isa_flags |= OPTION_MASK_ISA_SSE_SET;
1875           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_SET;
1876         }
1877       else
1878         {
1879           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE_UNSET;
1880           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_UNSET;
1881         }
1882       return true;
1883
1884     case OPT_msse2:
1885       if (value)
1886         {
1887           ix86_isa_flags |= OPTION_MASK_ISA_SSE2_SET;
1888           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_SET;
1889         }
1890       else
1891         {
1892           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE2_UNSET;
1893           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_UNSET;
1894         }
1895       return true;
1896
1897     case OPT_msse3:
1898       if (value)
1899         {
1900           ix86_isa_flags |= OPTION_MASK_ISA_SSE3_SET;
1901           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_SET;
1902         }
1903       else
1904         {
1905           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE3_UNSET;
1906           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_UNSET;
1907         }
1908       return true;
1909
1910     case OPT_mssse3:
1911       if (value)
1912         {
1913           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3_SET;
1914           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_SET;
1915         }
1916       else
1917         {
1918           ix86_isa_flags &= ~OPTION_MASK_ISA_SSSE3_UNSET;
1919           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_UNSET;
1920         }
1921       return true;
1922
1923     case OPT_msse4_1:
1924       if (value)
1925         {
1926           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1_SET;
1927           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_SET;
1928         }
1929       else
1930         {
1931           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_1_UNSET;
1932           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_UNSET;
1933         }
1934       return true;
1935
1936     case OPT_msse4_2:
1937       if (value)
1938         {
1939           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2_SET;
1940           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_SET;
1941         }
1942       else
1943         {
1944           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_2_UNSET;
1945           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_UNSET;
1946         }
1947       return true;
1948
1949     case OPT_msse4:
1950       ix86_isa_flags |= OPTION_MASK_ISA_SSE4_SET;
1951       ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_SET;
1952       return true;
1953
1954     case OPT_mno_sse4:
1955       ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_UNSET;
1956       ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_UNSET;
1957       return true;
1958
1959     case OPT_msse4a:
1960       if (value)
1961         {
1962           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A_SET;
1963           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_SET;
1964         }
1965       else
1966         {
1967           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4A_UNSET;
1968           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_UNSET;
1969         }
1970       return true;
1971
1972     case OPT_msse5:
1973       if (value)
1974         {
1975           ix86_isa_flags |= OPTION_MASK_ISA_SSE5_SET;
1976           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE5_SET;
1977         }
1978       else
1979         {
1980           ix86_isa_flags &= ~OPTION_MASK_ISA_SSE5_UNSET;
1981           ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE5_UNSET;
1982         }
1983       return true;
1984
1985     default:
1986       return true;
1987     }
1988 }
1989
1990 /* Sometimes certain combinations of command options do not make
1991    sense on a particular target machine.  You can define a macro
1992    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
1993    defined, is executed once just after all the command options have
1994    been parsed.
1995
1996    Don't use this macro to turn on various extra optimizations for
1997    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
1998
1999 void
2000 override_options (void)
2001 {
2002   int i;
2003   int ix86_tune_defaulted = 0;
2004   int ix86_arch_specified = 0;
2005   unsigned int ix86_arch_mask, ix86_tune_mask;
2006
2007   /* Comes from final.c -- no real reason to change it.  */
2008 #define MAX_CODE_ALIGN 16
2009
2010   static struct ptt
2011     {
2012       const struct processor_costs *cost;       /* Processor costs */
2013       const int align_loop;                     /* Default alignments.  */
2014       const int align_loop_max_skip;
2015       const int align_jump;
2016       const int align_jump_max_skip;
2017       const int align_func;
2018     }
2019   const processor_target_table[PROCESSOR_max] =
2020     {
2021       {&i386_cost, 4, 3, 4, 3, 4},
2022       {&i486_cost, 16, 15, 16, 15, 16},
2023       {&pentium_cost, 16, 7, 16, 7, 16},
2024       {&pentiumpro_cost, 16, 15, 16, 10, 16},
2025       {&geode_cost, 0, 0, 0, 0, 0},
2026       {&k6_cost, 32, 7, 32, 7, 32},
2027       {&athlon_cost, 16, 7, 16, 7, 16},
2028       {&pentium4_cost, 0, 0, 0, 0, 0},
2029       {&k8_cost, 16, 7, 16, 7, 16},
2030       {&nocona_cost, 0, 0, 0, 0, 0},
2031       {&core2_cost, 16, 10, 16, 10, 16},
2032       {&generic32_cost, 16, 7, 16, 7, 16},
2033       {&generic64_cost, 16, 10, 16, 10, 16},
2034       {&amdfam10_cost, 32, 24, 32, 7, 32}
2035     };
2036
2037   static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2038     {
2039       "generic",
2040       "i386",
2041       "i486",
2042       "pentium",
2043       "pentium-mmx",
2044       "pentiumpro",
2045       "pentium2",
2046       "pentium3",
2047       "pentium4",
2048       "pentium-m",
2049       "prescott",
2050       "nocona",
2051       "core2",
2052       "geode",
2053       "k6",
2054       "k6-2",
2055       "k6-3",
2056       "athlon",
2057       "athlon-4",
2058       "k8",
2059       "amdfam10"
2060     };
2061
2062   enum pta_flags
2063     {
2064       PTA_SSE = 1 << 0,
2065       PTA_SSE2 = 1 << 1,
2066       PTA_SSE3 = 1 << 2,
2067       PTA_MMX = 1 << 3,
2068       PTA_PREFETCH_SSE = 1 << 4,
2069       PTA_3DNOW = 1 << 5,
2070       PTA_3DNOW_A = 1 << 6,
2071       PTA_64BIT = 1 << 7,
2072       PTA_SSSE3 = 1 << 8,
2073       PTA_CX16 = 1 << 9,
2074       PTA_POPCNT = 1 << 10,
2075       PTA_ABM = 1 << 11,
2076       PTA_SSE4A = 1 << 12,
2077       PTA_NO_SAHF = 1 << 13,
2078       PTA_SSE4_1 = 1 << 14,
2079       PTA_SSE4_2 = 1 << 15,
2080       PTA_SSE5 = 1 << 16
2081     };
2082
2083   static struct pta
2084     {
2085       const char *const name;           /* processor name or nickname.  */
2086       const enum processor_type processor;
2087       const unsigned /*enum pta_flags*/ flags;
2088     }
2089   const processor_alias_table[] =
2090     {
2091       {"i386", PROCESSOR_I386, 0},
2092       {"i486", PROCESSOR_I486, 0},
2093       {"i586", PROCESSOR_PENTIUM, 0},
2094       {"pentium", PROCESSOR_PENTIUM, 0},
2095       {"pentium-mmx", PROCESSOR_PENTIUM, PTA_MMX},
2096       {"winchip-c6", PROCESSOR_I486, PTA_MMX},
2097       {"winchip2", PROCESSOR_I486, PTA_MMX | PTA_3DNOW},
2098       {"c3", PROCESSOR_I486, PTA_MMX | PTA_3DNOW},
2099       {"c3-2", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE},
2100       {"i686", PROCESSOR_PENTIUMPRO, 0},
2101       {"pentiumpro", PROCESSOR_PENTIUMPRO, 0},
2102       {"pentium2", PROCESSOR_PENTIUMPRO, PTA_MMX},
2103       {"pentium3", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE},
2104       {"pentium3m", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE},
2105       {"pentium-m", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE | PTA_SSE2},
2106       {"pentium4", PROCESSOR_PENTIUM4, PTA_MMX |PTA_SSE | PTA_SSE2},
2107       {"pentium4m", PROCESSOR_PENTIUM4, PTA_MMX | PTA_SSE | PTA_SSE2},
2108       {"prescott", PROCESSOR_NOCONA, PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2109       {"nocona", PROCESSOR_NOCONA, (PTA_64BIT
2110                                     | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2111                                     | PTA_CX16 | PTA_NO_SAHF)},
2112       {"core2", PROCESSOR_CORE2, (PTA_64BIT
2113                                   | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2114                                   | PTA_SSSE3
2115                                   | PTA_CX16)},
2116       {"geode", PROCESSOR_GEODE, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2117                                   |PTA_PREFETCH_SSE)},
2118       {"k6", PROCESSOR_K6, PTA_MMX},
2119       {"k6-2", PROCESSOR_K6, PTA_MMX | PTA_3DNOW},
2120       {"k6-3", PROCESSOR_K6, PTA_MMX | PTA_3DNOW},
2121       {"athlon", PROCESSOR_ATHLON, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2122                                     | PTA_PREFETCH_SSE)},
2123       {"athlon-tbird", PROCESSOR_ATHLON, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2124                                           | PTA_PREFETCH_SSE)},
2125       {"athlon-4", PROCESSOR_ATHLON, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2126                                       | PTA_SSE)},
2127       {"athlon-xp", PROCESSOR_ATHLON, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2128                                        | PTA_SSE)},
2129       {"athlon-mp", PROCESSOR_ATHLON, (PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2130                                        | PTA_SSE)},
2131       {"x86-64", PROCESSOR_K8, (PTA_64BIT
2132                                 | PTA_MMX | PTA_SSE | PTA_SSE2
2133                                 | PTA_NO_SAHF)},
2134       {"k8", PROCESSOR_K8, (PTA_64BIT
2135                             | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2136                             | PTA_SSE | PTA_SSE2
2137                             | PTA_NO_SAHF)},
2138       {"k8-sse3", PROCESSOR_K8, (PTA_64BIT
2139                                  | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2140                                  | PTA_SSE | PTA_SSE2 | PTA_SSE3
2141                                  | PTA_NO_SAHF)},
2142       {"opteron", PROCESSOR_K8, (PTA_64BIT
2143                                  | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2144                                  | PTA_SSE | PTA_SSE2
2145                                  | PTA_NO_SAHF)},
2146       {"opteron-sse3", PROCESSOR_K8, (PTA_64BIT
2147                                       | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2148                                       | PTA_SSE | PTA_SSE2 | PTA_SSE3
2149                                       | PTA_NO_SAHF)},
2150       {"athlon64", PROCESSOR_K8, (PTA_64BIT
2151                                   | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2152                                   | PTA_SSE | PTA_SSE2
2153                                   | PTA_NO_SAHF)},
2154       {"athlon64-sse3", PROCESSOR_K8, (PTA_64BIT
2155                                        | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2156                                        | PTA_SSE | PTA_SSE2 | PTA_SSE3
2157                                        | PTA_NO_SAHF)},
2158       {"athlon-fx", PROCESSOR_K8, (PTA_64BIT
2159                                    | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2160                                    | PTA_SSE | PTA_SSE2
2161                                    | PTA_NO_SAHF)},
2162       {"amdfam10", PROCESSOR_AMDFAM10, (PTA_64BIT
2163                                         | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2164                                         | PTA_SSE | PTA_SSE2 | PTA_SSE3
2165                                         | PTA_SSE4A
2166                                         | PTA_CX16 | PTA_ABM)},
2167       {"barcelona", PROCESSOR_AMDFAM10, (PTA_64BIT
2168                                          | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A
2169                                          | PTA_SSE | PTA_SSE2 | PTA_SSE3
2170                                          | PTA_SSE4A
2171                                          | PTA_CX16 | PTA_ABM)},
2172       {"generic32", PROCESSOR_GENERIC32, 0 /* flags are only used for -march switch.  */ },
2173       {"generic64", PROCESSOR_GENERIC64, PTA_64BIT /* flags are only used for -march switch.  */ },
2174     };
2175
2176   int const pta_size = ARRAY_SIZE (processor_alias_table);
2177
2178 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2179   SUBTARGET_OVERRIDE_OPTIONS;
2180 #endif
2181
2182 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2183   SUBSUBTARGET_OVERRIDE_OPTIONS;
2184 #endif
2185
2186   /* -fPIC is the default for x86_64.  */
2187   if (TARGET_MACHO && TARGET_64BIT)
2188     flag_pic = 2;
2189
2190   /* Set the default values for switches whose default depends on TARGET_64BIT
2191      in case they weren't overwritten by command line options.  */
2192   if (TARGET_64BIT)
2193     {
2194       /* Mach-O doesn't support omitting the frame pointer for now.  */
2195       if (flag_omit_frame_pointer == 2)
2196         flag_omit_frame_pointer = (TARGET_MACHO ? 0 : 1);
2197       if (flag_asynchronous_unwind_tables == 2)
2198         flag_asynchronous_unwind_tables = 1;
2199       if (flag_pcc_struct_return == 2)
2200         flag_pcc_struct_return = 0;
2201     }
2202   else
2203     {
2204       if (flag_omit_frame_pointer == 2)
2205         flag_omit_frame_pointer = 0;
2206       if (flag_asynchronous_unwind_tables == 2)
2207         flag_asynchronous_unwind_tables = 0;
2208       if (flag_pcc_struct_return == 2)
2209         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
2210     }
2211
2212   /* Need to check -mtune=generic first.  */
2213   if (ix86_tune_string)
2214     {
2215       if (!strcmp (ix86_tune_string, "generic")
2216           || !strcmp (ix86_tune_string, "i686")
2217           /* As special support for cross compilers we read -mtune=native
2218              as -mtune=generic.  With native compilers we won't see the
2219              -mtune=native, as it was changed by the driver.  */
2220           || !strcmp (ix86_tune_string, "native"))
2221         {
2222           if (TARGET_64BIT)
2223             ix86_tune_string = "generic64";
2224           else
2225             ix86_tune_string = "generic32";
2226         }
2227       else if (!strncmp (ix86_tune_string, "generic", 7))
2228         error ("bad value (%s) for -mtune= switch", ix86_tune_string);
2229     }
2230   else
2231     {
2232       if (ix86_arch_string)
2233         ix86_tune_string = ix86_arch_string;
2234       if (!ix86_tune_string)
2235         {
2236           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
2237           ix86_tune_defaulted = 1;
2238         }
2239
2240       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
2241          need to use a sensible tune option.  */
2242       if (!strcmp (ix86_tune_string, "generic")
2243           || !strcmp (ix86_tune_string, "x86-64")
2244           || !strcmp (ix86_tune_string, "i686"))
2245         {
2246           if (TARGET_64BIT)
2247             ix86_tune_string = "generic64";
2248           else
2249             ix86_tune_string = "generic32";
2250         }
2251     }
2252   if (ix86_stringop_string)
2253     {
2254       if (!strcmp (ix86_stringop_string, "rep_byte"))
2255         stringop_alg = rep_prefix_1_byte;
2256       else if (!strcmp (ix86_stringop_string, "libcall"))
2257         stringop_alg = libcall;
2258       else if (!strcmp (ix86_stringop_string, "rep_4byte"))
2259         stringop_alg = rep_prefix_4_byte;
2260       else if (!strcmp (ix86_stringop_string, "rep_8byte"))
2261         stringop_alg = rep_prefix_8_byte;
2262       else if (!strcmp (ix86_stringop_string, "byte_loop"))
2263         stringop_alg = loop_1_byte;
2264       else if (!strcmp (ix86_stringop_string, "loop"))
2265         stringop_alg = loop;
2266       else if (!strcmp (ix86_stringop_string, "unrolled_loop"))
2267         stringop_alg = unrolled_loop;
2268       else
2269         error ("bad value (%s) for -mstringop-strategy= switch", ix86_stringop_string);
2270     }
2271   if (!strcmp (ix86_tune_string, "x86-64"))
2272     warning (OPT_Wdeprecated, "-mtune=x86-64 is deprecated.  Use -mtune=k8 or "
2273              "-mtune=generic instead as appropriate.");
2274
2275   if (!ix86_arch_string)
2276     ix86_arch_string = TARGET_64BIT ? "x86-64" : "i386";
2277   else
2278     ix86_arch_specified = 1;
2279
2280   if (!strcmp (ix86_arch_string, "generic"))
2281     error ("generic CPU can be used only for -mtune= switch");
2282   if (!strncmp (ix86_arch_string, "generic", 7))
2283     error ("bad value (%s) for -march= switch", ix86_arch_string);
2284
2285   if (ix86_cmodel_string != 0)
2286     {
2287       if (!strcmp (ix86_cmodel_string, "small"))
2288         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
2289       else if (!strcmp (ix86_cmodel_string, "medium"))
2290         ix86_cmodel = flag_pic ? CM_MEDIUM_PIC : CM_MEDIUM;
2291       else if (!strcmp (ix86_cmodel_string, "large"))
2292         ix86_cmodel = flag_pic ? CM_LARGE_PIC : CM_LARGE;
2293       else if (flag_pic)
2294         error ("code model %s does not support PIC mode", ix86_cmodel_string);
2295       else if (!strcmp (ix86_cmodel_string, "32"))
2296         ix86_cmodel = CM_32;
2297       else if (!strcmp (ix86_cmodel_string, "kernel") && !flag_pic)
2298         ix86_cmodel = CM_KERNEL;
2299       else
2300         error ("bad value (%s) for -mcmodel= switch", ix86_cmodel_string);
2301     }
2302   else
2303     {
2304       /* For TARGET_64BIT_MS_ABI, force pic on, in order to enable the
2305          use of rip-relative addressing.  This eliminates fixups that
2306          would otherwise be needed if this object is to be placed in a
2307          DLL, and is essentially just as efficient as direct addressing.  */
2308       if (TARGET_64BIT_MS_ABI)
2309         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
2310       else if (TARGET_64BIT)
2311         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
2312       else
2313         ix86_cmodel = CM_32;
2314     }
2315   if (ix86_asm_string != 0)
2316     {
2317       if (! TARGET_MACHO
2318           && !strcmp (ix86_asm_string, "intel"))
2319         ix86_asm_dialect = ASM_INTEL;
2320       else if (!strcmp (ix86_asm_string, "att"))
2321         ix86_asm_dialect = ASM_ATT;
2322       else
2323         error ("bad value (%s) for -masm= switch", ix86_asm_string);
2324     }
2325   if ((TARGET_64BIT == 0) != (ix86_cmodel == CM_32))
2326     error ("code model %qs not supported in the %s bit mode",
2327            ix86_cmodel_string, TARGET_64BIT ? "64" : "32");
2328   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
2329     sorry ("%i-bit mode not compiled in",
2330            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
2331
2332   for (i = 0; i < pta_size; i++)
2333     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
2334       {
2335         ix86_arch = processor_alias_table[i].processor;
2336         /* Default cpu tuning to the architecture.  */
2337         ix86_tune = ix86_arch;
2338
2339         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
2340           error ("CPU you selected does not support x86-64 "
2341                  "instruction set");
2342
2343         if (processor_alias_table[i].flags & PTA_MMX
2344             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
2345           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
2346         if (processor_alias_table[i].flags & PTA_3DNOW
2347             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
2348           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
2349         if (processor_alias_table[i].flags & PTA_3DNOW_A
2350             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
2351           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
2352         if (processor_alias_table[i].flags & PTA_SSE
2353             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
2354           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
2355         if (processor_alias_table[i].flags & PTA_SSE2
2356             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
2357           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
2358         if (processor_alias_table[i].flags & PTA_SSE3
2359             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
2360           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
2361         if (processor_alias_table[i].flags & PTA_SSSE3
2362             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
2363           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
2364         if (processor_alias_table[i].flags & PTA_SSE4_1
2365             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
2366           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
2367         if (processor_alias_table[i].flags & PTA_SSE4_2
2368             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
2369           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
2370         if (processor_alias_table[i].flags & PTA_SSE4A
2371             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
2372           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
2373         if (processor_alias_table[i].flags & PTA_SSE5
2374             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE5))
2375           ix86_isa_flags |= OPTION_MASK_ISA_SSE5;
2376
2377         if (processor_alias_table[i].flags & PTA_ABM)
2378           x86_abm = true;
2379         if (processor_alias_table[i].flags & PTA_CX16)
2380           x86_cmpxchg16b = true;
2381         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM))
2382           x86_popcnt = true;
2383         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
2384           x86_prefetch_sse = true;
2385         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF)))
2386           x86_sahf = true;
2387
2388         break;
2389       }
2390
2391   if (i == pta_size)
2392     error ("bad value (%s) for -march= switch", ix86_arch_string);
2393
2394   ix86_arch_mask = 1u << ix86_arch;
2395   for (i = 0; i < X86_ARCH_LAST; ++i)
2396     ix86_arch_features[i] &= ix86_arch_mask;
2397
2398   for (i = 0; i < pta_size; i++)
2399     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
2400       {
2401         ix86_tune = processor_alias_table[i].processor;
2402         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
2403           {
2404             if (ix86_tune_defaulted)
2405               {
2406                 ix86_tune_string = "x86-64";
2407                 for (i = 0; i < pta_size; i++)
2408                   if (! strcmp (ix86_tune_string,
2409                                 processor_alias_table[i].name))
2410                     break;
2411                 ix86_tune = processor_alias_table[i].processor;
2412               }
2413             else
2414               error ("CPU you selected does not support x86-64 "
2415                      "instruction set");
2416           }
2417         /* Intel CPUs have always interpreted SSE prefetch instructions as
2418            NOPs; so, we can enable SSE prefetch instructions even when
2419            -mtune (rather than -march) points us to a processor that has them.
2420            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
2421            higher processors.  */
2422         if (TARGET_CMOVE
2423             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
2424           x86_prefetch_sse = true;
2425         break;
2426       }
2427   if (i == pta_size)
2428     error ("bad value (%s) for -mtune= switch", ix86_tune_string);
2429
2430   ix86_tune_mask = 1u << ix86_tune;
2431   for (i = 0; i < X86_TUNE_LAST; ++i)
2432     ix86_tune_features[i] &= ix86_tune_mask;
2433
2434   if (optimize_size)
2435     ix86_cost = &size_cost;
2436   else
2437     ix86_cost = processor_target_table[ix86_tune].cost;
2438
2439   /* Arrange to set up i386_stack_locals for all functions.  */
2440   init_machine_status = ix86_init_machine_status;
2441
2442   /* Validate -mregparm= value.  */
2443   if (ix86_regparm_string)
2444     {
2445       if (TARGET_64BIT)
2446         warning (0, "-mregparm is ignored in 64-bit mode");
2447       i = atoi (ix86_regparm_string);
2448       if (i < 0 || i > REGPARM_MAX)
2449         error ("-mregparm=%d is not between 0 and %d", i, REGPARM_MAX);
2450       else
2451         ix86_regparm = i;
2452     }
2453   if (TARGET_64BIT)
2454     ix86_regparm = REGPARM_MAX;
2455
2456   /* If the user has provided any of the -malign-* options,
2457      warn and use that value only if -falign-* is not set.
2458      Remove this code in GCC 3.2 or later.  */
2459   if (ix86_align_loops_string)
2460     {
2461       warning (0, "-malign-loops is obsolete, use -falign-loops");
2462       if (align_loops == 0)
2463         {
2464           i = atoi (ix86_align_loops_string);
2465           if (i < 0 || i > MAX_CODE_ALIGN)
2466             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
2467           else
2468             align_loops = 1 << i;
2469         }
2470     }
2471
2472   if (ix86_align_jumps_string)
2473     {
2474       warning (0, "-malign-jumps is obsolete, use -falign-jumps");
2475       if (align_jumps == 0)
2476         {
2477           i = atoi (ix86_align_jumps_string);
2478           if (i < 0 || i > MAX_CODE_ALIGN)
2479             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
2480           else
2481             align_jumps = 1 << i;
2482         }
2483     }
2484
2485   if (ix86_align_funcs_string)
2486     {
2487       warning (0, "-malign-functions is obsolete, use -falign-functions");
2488       if (align_functions == 0)
2489         {
2490           i = atoi (ix86_align_funcs_string);
2491           if (i < 0 || i > MAX_CODE_ALIGN)
2492             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
2493           else
2494             align_functions = 1 << i;
2495         }
2496     }
2497
2498   /* Default align_* from the processor table.  */
2499   if (align_loops == 0)
2500     {
2501       align_loops = processor_target_table[ix86_tune].align_loop;
2502       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
2503     }
2504   if (align_jumps == 0)
2505     {
2506       align_jumps = processor_target_table[ix86_tune].align_jump;
2507       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
2508     }
2509   if (align_functions == 0)
2510     {
2511       align_functions = processor_target_table[ix86_tune].align_func;
2512     }
2513
2514   /* Validate -mbranch-cost= value, or provide default.  */
2515   ix86_branch_cost = ix86_cost->branch_cost;
2516   if (ix86_branch_cost_string)
2517     {
2518       i = atoi (ix86_branch_cost_string);
2519       if (i < 0 || i > 5)
2520         error ("-mbranch-cost=%d is not between 0 and 5", i);
2521       else
2522         ix86_branch_cost = i;
2523     }
2524   if (ix86_section_threshold_string)
2525     {
2526       i = atoi (ix86_section_threshold_string);
2527       if (i < 0)
2528         error ("-mlarge-data-threshold=%d is negative", i);
2529       else
2530         ix86_section_threshold = i;
2531     }
2532
2533   if (ix86_tls_dialect_string)
2534     {
2535       if (strcmp (ix86_tls_dialect_string, "gnu") == 0)
2536         ix86_tls_dialect = TLS_DIALECT_GNU;
2537       else if (strcmp (ix86_tls_dialect_string, "gnu2") == 0)
2538         ix86_tls_dialect = TLS_DIALECT_GNU2;
2539       else if (strcmp (ix86_tls_dialect_string, "sun") == 0)
2540         ix86_tls_dialect = TLS_DIALECT_SUN;
2541       else
2542         error ("bad value (%s) for -mtls-dialect= switch",
2543                ix86_tls_dialect_string);
2544     }
2545
2546   if (ix87_precision_string)
2547     {
2548       i = atoi (ix87_precision_string);
2549       if (i != 32 && i != 64 && i != 80)
2550         error ("pc%d is not valid precision setting (32, 64 or 80)", i);
2551     }
2552
2553   if (TARGET_64BIT)
2554     {
2555       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
2556
2557       /* Enable by default the SSE and MMX builtins.  Do allow the user to
2558          explicitly disable any of these.  In particular, disabling SSE and
2559          MMX for kernel code is extremely useful.  */
2560       if (!ix86_arch_specified)
2561       ix86_isa_flags
2562         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
2563              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
2564
2565       if (TARGET_RTD)
2566         warning (0, "-mrtd is ignored in 64bit mode");
2567     }
2568   else
2569     {
2570       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
2571
2572       if (!ix86_arch_specified)
2573       ix86_isa_flags
2574         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
2575
2576       /* i386 ABI does not specify red zone.  It still makes sense to use it
2577          when programmer takes care to stack from being destroyed.  */
2578       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
2579         target_flags |= MASK_NO_RED_ZONE;
2580     }
2581
2582   /* Keep nonleaf frame pointers.  */
2583   if (flag_omit_frame_pointer)
2584     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
2585   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
2586     flag_omit_frame_pointer = 1;
2587
2588   /* If we're doing fast math, we don't care about comparison order
2589      wrt NaNs.  This lets us use a shorter comparison sequence.  */
2590   if (flag_finite_math_only)
2591     target_flags &= ~MASK_IEEE_FP;
2592
2593   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
2594      since the insns won't need emulation.  */
2595   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
2596     target_flags &= ~MASK_NO_FANCY_MATH_387;
2597
2598   /* Likewise, if the target doesn't have a 387, or we've specified
2599      software floating point, don't use 387 inline intrinsics.  */
2600   if (!TARGET_80387)
2601     target_flags |= MASK_NO_FANCY_MATH_387;
2602
2603   /* Turn on MMX builtins for -msse.  */
2604   if (TARGET_SSE)
2605     {
2606       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
2607       x86_prefetch_sse = true;
2608     }
2609
2610   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
2611   if (TARGET_SSE4_2 || TARGET_ABM)
2612     x86_popcnt = true;
2613
2614   /* Validate -mpreferred-stack-boundary= value, or provide default.
2615      The default of 128 bits is for Pentium III's SSE __m128.  We can't
2616      change it because of optimize_size.  Otherwise, we can't mix object
2617      files compiled with -Os and -On.  */
2618   ix86_preferred_stack_boundary = 128;
2619   if (ix86_preferred_stack_boundary_string)
2620     {
2621       i = atoi (ix86_preferred_stack_boundary_string);
2622       if (i < (TARGET_64BIT ? 4 : 2) || i > 12)
2623         error ("-mpreferred-stack-boundary=%d is not between %d and 12", i,
2624                TARGET_64BIT ? 4 : 2);
2625       else
2626         ix86_preferred_stack_boundary = (1 << i) * BITS_PER_UNIT;
2627     }
2628
2629   /* Accept -msseregparm only if at least SSE support is enabled.  */
2630   if (TARGET_SSEREGPARM
2631       && ! TARGET_SSE)
2632     error ("-msseregparm used without SSE enabled");
2633
2634   ix86_fpmath = TARGET_FPMATH_DEFAULT;
2635   if (ix86_fpmath_string != 0)
2636     {
2637       if (! strcmp (ix86_fpmath_string, "387"))
2638         ix86_fpmath = FPMATH_387;
2639       else if (! strcmp (ix86_fpmath_string, "sse"))
2640         {
2641           if (!TARGET_SSE)
2642             {
2643               warning (0, "SSE instruction set disabled, using 387 arithmetics");
2644               ix86_fpmath = FPMATH_387;
2645             }
2646           else
2647             ix86_fpmath = FPMATH_SSE;
2648         }
2649       else if (! strcmp (ix86_fpmath_string, "387,sse")
2650                || ! strcmp (ix86_fpmath_string, "sse,387"))
2651         {
2652           if (!TARGET_SSE)
2653             {
2654               warning (0, "SSE instruction set disabled, using 387 arithmetics");
2655               ix86_fpmath = FPMATH_387;
2656             }
2657           else if (!TARGET_80387)
2658             {
2659               warning (0, "387 instruction set disabled, using SSE arithmetics");
2660               ix86_fpmath = FPMATH_SSE;
2661             }
2662           else
2663             ix86_fpmath = (enum fpmath_unit) (FPMATH_SSE | FPMATH_387);
2664         }
2665       else
2666         error ("bad value (%s) for -mfpmath= switch", ix86_fpmath_string);
2667     }
2668
2669   /* If the i387 is disabled, then do not return values in it. */
2670   if (!TARGET_80387)
2671     target_flags &= ~MASK_FLOAT_RETURNS;
2672
2673   /* Use external vectorized library in vectorizing intrinsics.  */
2674   if (ix86_veclibabi_string)
2675     {
2676       if (strcmp (ix86_veclibabi_string, "acml") == 0)
2677         ix86_veclib_handler = ix86_veclibabi_acml;
2678       else
2679         error ("unknown vectorization library ABI type (%s) for "
2680                "-mveclibabi= switch", ix86_veclibabi_string);
2681     }
2682
2683   if ((x86_accumulate_outgoing_args & ix86_tune_mask)
2684       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
2685       && !optimize_size)
2686     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
2687
2688   /* ??? Unwind info is not correct around the CFG unless either a frame
2689      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
2690      unwind info generation to be aware of the CFG and propagating states
2691      around edges.  */
2692   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
2693        || flag_exceptions || flag_non_call_exceptions)
2694       && flag_omit_frame_pointer
2695       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
2696     {
2697       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
2698         warning (0, "unwind tables currently require either a frame pointer "
2699                  "or -maccumulate-outgoing-args for correctness");
2700       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
2701     }
2702
2703   /* If stack probes are required, the space used for large function
2704      arguments on the stack must also be probed, so enable
2705      -maccumulate-outgoing-args so this happens in the prologue.  */
2706   if (TARGET_STACK_PROBE
2707       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
2708     {
2709       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
2710         warning (0, "stack probing requires -maccumulate-outgoing-args "
2711                  "for correctness");
2712       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
2713     }
2714
2715   /* For sane SSE instruction set generation we need fcomi instruction.
2716      It is safe to enable all CMOVE instructions.  */
2717   if (TARGET_SSE)
2718     TARGET_CMOVE = 1;
2719
2720   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
2721   {
2722     char *p;
2723     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
2724     p = strchr (internal_label_prefix, 'X');
2725     internal_label_prefix_len = p - internal_label_prefix;
2726     *p = '\0';
2727   }
2728
2729   /* When scheduling description is not available, disable scheduler pass
2730      so it won't slow down the compilation and make x87 code slower.  */
2731   if (!TARGET_SCHEDULE)
2732     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
2733
2734   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
2735     set_param_value ("simultaneous-prefetches",
2736                      ix86_cost->simultaneous_prefetches);
2737   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
2738     set_param_value ("l1-cache-line-size", ix86_cost->prefetch_block);
2739   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
2740     set_param_value ("l1-cache-size", ix86_cost->l1_cache_size);
2741   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
2742     set_param_value ("l2-cache-size", ix86_cost->l2_cache_size);
2743
2744   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
2745      can be optimized to ap = __builtin_next_arg (0).  */
2746   if (!TARGET_64BIT || TARGET_64BIT_MS_ABI)
2747     targetm.expand_builtin_va_start = NULL;
2748 }
2749 \f
2750 /* Return true if this goes in large data/bss.  */
2751
2752 static bool
2753 ix86_in_large_data_p (tree exp)
2754 {
2755   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
2756     return false;
2757
2758   /* Functions are never large data.  */
2759   if (TREE_CODE (exp) == FUNCTION_DECL)
2760     return false;
2761
2762   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
2763     {
2764       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
2765       if (strcmp (section, ".ldata") == 0
2766           || strcmp (section, ".lbss") == 0)
2767         return true;
2768       return false;
2769     }
2770   else
2771     {
2772       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2773
2774       /* If this is an incomplete type with size 0, then we can't put it
2775          in data because it might be too big when completed.  */
2776       if (!size || size > ix86_section_threshold)
2777         return true;
2778     }
2779
2780   return false;
2781 }
2782
2783 /* Switch to the appropriate section for output of DECL.
2784    DECL is either a `VAR_DECL' node or a constant of some sort.
2785    RELOC indicates whether forming the initial value of DECL requires
2786    link-time relocations.  */
2787
2788 static section * x86_64_elf_select_section (tree, int, unsigned HOST_WIDE_INT)
2789         ATTRIBUTE_UNUSED;
2790
2791 static section *
2792 x86_64_elf_select_section (tree decl, int reloc,
2793                            unsigned HOST_WIDE_INT align)
2794 {
2795   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
2796       && ix86_in_large_data_p (decl))
2797     {
2798       const char *sname = NULL;
2799       unsigned int flags = SECTION_WRITE;
2800       switch (categorize_decl_for_section (decl, reloc))
2801         {
2802         case SECCAT_DATA:
2803           sname = ".ldata";
2804           break;
2805         case SECCAT_DATA_REL:
2806           sname = ".ldata.rel";
2807           break;
2808         case SECCAT_DATA_REL_LOCAL:
2809           sname = ".ldata.rel.local";
2810           break;
2811         case SECCAT_DATA_REL_RO:
2812           sname = ".ldata.rel.ro";
2813           break;
2814         case SECCAT_DATA_REL_RO_LOCAL:
2815           sname = ".ldata.rel.ro.local";
2816           break;
2817         case SECCAT_BSS:
2818           sname = ".lbss";
2819           flags |= SECTION_BSS;
2820           break;
2821         case SECCAT_RODATA:
2822         case SECCAT_RODATA_MERGE_STR:
2823         case SECCAT_RODATA_MERGE_STR_INIT:
2824         case SECCAT_RODATA_MERGE_CONST:
2825           sname = ".lrodata";