OSDN Git Service

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