OSDN Git Service

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