OSDN Git Service

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