OSDN Git Service

bf792a91403c9d26e581bfbd26948868c93b4a6c
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / i386.c
1 /* Subroutines used for code generation on IA-32.
2    Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "tm_p.h"
29 #include "regs.h"
30 #include "hard-reg-set.h"
31 #include "real.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "output.h"
35 #include "insn-codes.h"
36 #include "insn-attr.h"
37 #include "flags.h"
38 #include "except.h"
39 #include "function.h"
40 #include "recog.h"
41 #include "expr.h"
42 #include "optabs.h"
43 #include "toplev.h"
44 #include "basic-block.h"
45 #include "ggc.h"
46 #include "target.h"
47 #include "target-def.h"
48 #include "langhooks.h"
49 #include "cgraph.h"
50 #include "tree-gimple.h"
51 #include "dwarf2.h"
52
53 #ifndef CHECK_STACK_LIMIT
54 #define CHECK_STACK_LIMIT (-1)
55 #endif
56
57 /* Return index of given mode in mult and division cost tables.  */
58 #define MODE_INDEX(mode)                                        \
59   ((mode) == QImode ? 0                                         \
60    : (mode) == HImode ? 1                                       \
61    : (mode) == SImode ? 2                                       \
62    : (mode) == DImode ? 3                                       \
63    : 4)
64
65 /* Processor costs (relative to an add) */
66 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
67 #define COSTS_N_BYTES(N) ((N) * 2)
68
69 static const
70 struct processor_costs size_cost = {    /* costs for tunning for size */
71   COSTS_N_BYTES (2),                    /* cost of an add instruction */
72   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
73   COSTS_N_BYTES (2),                    /* variable shift costs */
74   COSTS_N_BYTES (3),                    /* constant shift costs */
75   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
76    COSTS_N_BYTES (3),                   /*                               HI */
77    COSTS_N_BYTES (3),                   /*                               SI */
78    COSTS_N_BYTES (3),                   /*                               DI */
79    COSTS_N_BYTES (5)},                  /*                            other */
80   0,                                    /* cost of multiply per each bit set */
81   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
82    COSTS_N_BYTES (3),                   /*                          HI */
83    COSTS_N_BYTES (3),                   /*                          SI */
84    COSTS_N_BYTES (3),                   /*                          DI */
85    COSTS_N_BYTES (5)},                  /*                       other */
86   COSTS_N_BYTES (3),                    /* cost of movsx */
87   COSTS_N_BYTES (3),                    /* cost of movzx */
88   0,                                    /* "large" insn */
89   2,                                    /* MOVE_RATIO */
90   2,                                    /* cost for loading QImode using movzbl */
91   {2, 2, 2},                            /* cost of loading integer registers
92                                            in QImode, HImode and SImode.
93                                            Relative to reg-reg move (2).  */
94   {2, 2, 2},                            /* cost of storing integer registers */
95   2,                                    /* cost of reg,reg fld/fst */
96   {2, 2, 2},                            /* cost of loading fp registers
97                                            in SFmode, DFmode and XFmode */
98   {2, 2, 2},                            /* cost of loading integer registers */
99   3,                                    /* cost of moving MMX register */
100   {3, 3},                               /* cost of loading MMX registers
101                                            in SImode and DImode */
102   {3, 3},                               /* cost of storing MMX registers
103                                            in SImode and DImode */
104   3,                                    /* cost of moving SSE register */
105   {3, 3, 3},                            /* cost of loading SSE registers
106                                            in SImode, DImode and TImode */
107   {3, 3, 3},                            /* cost of storing SSE registers
108                                            in SImode, DImode and TImode */
109   3,                                    /* MMX or SSE register to integer */
110   0,                                    /* size of prefetch block */
111   0,                                    /* number of parallel prefetches */
112   2,                                    /* Branch cost */
113   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
114   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
115   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
116   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
117   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
118   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
119 };
120
121 /* Processor costs (relative to an add) */
122 static const
123 struct processor_costs i386_cost = {    /* 386 specific costs */
124   COSTS_N_INSNS (1),                    /* cost of an add instruction */
125   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
126   COSTS_N_INSNS (3),                    /* variable shift costs */
127   COSTS_N_INSNS (2),                    /* constant shift costs */
128   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
129    COSTS_N_INSNS (6),                   /*                               HI */
130    COSTS_N_INSNS (6),                   /*                               SI */
131    COSTS_N_INSNS (6),                   /*                               DI */
132    COSTS_N_INSNS (6)},                  /*                               other */
133   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
134   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
135    COSTS_N_INSNS (23),                  /*                          HI */
136    COSTS_N_INSNS (23),                  /*                          SI */
137    COSTS_N_INSNS (23),                  /*                          DI */
138    COSTS_N_INSNS (23)},                 /*                          other */
139   COSTS_N_INSNS (3),                    /* cost of movsx */
140   COSTS_N_INSNS (2),                    /* cost of movzx */
141   15,                                   /* "large" insn */
142   3,                                    /* MOVE_RATIO */
143   4,                                    /* cost for loading QImode using movzbl */
144   {2, 4, 2},                            /* cost of loading integer registers
145                                            in QImode, HImode and SImode.
146                                            Relative to reg-reg move (2).  */
147   {2, 4, 2},                            /* cost of storing integer registers */
148   2,                                    /* cost of reg,reg fld/fst */
149   {8, 8, 8},                            /* cost of loading fp registers
150                                            in SFmode, DFmode and XFmode */
151   {8, 8, 8},                            /* cost of loading integer registers */
152   2,                                    /* cost of moving MMX register */
153   {4, 8},                               /* cost of loading MMX registers
154                                            in SImode and DImode */
155   {4, 8},                               /* cost of storing MMX registers
156                                            in SImode and DImode */
157   2,                                    /* cost of moving SSE register */
158   {4, 8, 16},                           /* cost of loading SSE registers
159                                            in SImode, DImode and TImode */
160   {4, 8, 16},                           /* cost of storing SSE registers
161                                            in SImode, DImode and TImode */
162   3,                                    /* MMX or SSE register to integer */
163   0,                                    /* size of prefetch block */
164   0,                                    /* number of parallel prefetches */
165   1,                                    /* Branch cost */
166   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
167   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
168   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
169   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
170   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
171   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
172 };
173
174 static const
175 struct processor_costs i486_cost = {    /* 486 specific costs */
176   COSTS_N_INSNS (1),                    /* cost of an add instruction */
177   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
178   COSTS_N_INSNS (3),                    /* variable shift costs */
179   COSTS_N_INSNS (2),                    /* constant shift costs */
180   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
181    COSTS_N_INSNS (12),                  /*                               HI */
182    COSTS_N_INSNS (12),                  /*                               SI */
183    COSTS_N_INSNS (12),                  /*                               DI */
184    COSTS_N_INSNS (12)},                 /*                               other */
185   1,                                    /* cost of multiply per each bit set */
186   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
187    COSTS_N_INSNS (40),                  /*                          HI */
188    COSTS_N_INSNS (40),                  /*                          SI */
189    COSTS_N_INSNS (40),                  /*                          DI */
190    COSTS_N_INSNS (40)},                 /*                          other */
191   COSTS_N_INSNS (3),                    /* cost of movsx */
192   COSTS_N_INSNS (2),                    /* cost of movzx */
193   15,                                   /* "large" insn */
194   3,                                    /* MOVE_RATIO */
195   4,                                    /* cost for loading QImode using movzbl */
196   {2, 4, 2},                            /* cost of loading integer registers
197                                            in QImode, HImode and SImode.
198                                            Relative to reg-reg move (2).  */
199   {2, 4, 2},                            /* cost of storing integer registers */
200   2,                                    /* cost of reg,reg fld/fst */
201   {8, 8, 8},                            /* cost of loading fp registers
202                                            in SFmode, DFmode and XFmode */
203   {8, 8, 8},                            /* cost of loading integer registers */
204   2,                                    /* cost of moving MMX register */
205   {4, 8},                               /* cost of loading MMX registers
206                                            in SImode and DImode */
207   {4, 8},                               /* cost of storing MMX registers
208                                            in SImode and DImode */
209   2,                                    /* cost of moving SSE register */
210   {4, 8, 16},                           /* cost of loading SSE registers
211                                            in SImode, DImode and TImode */
212   {4, 8, 16},                           /* cost of storing SSE registers
213                                            in SImode, DImode and TImode */
214   3,                                    /* MMX or SSE register to integer */
215   0,                                    /* size of prefetch block */
216   0,                                    /* number of parallel prefetches */
217   1,                                    /* Branch cost */
218   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
219   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
220   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
221   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
222   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
223   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
224 };
225
226 static const
227 struct processor_costs pentium_cost = {
228   COSTS_N_INSNS (1),                    /* cost of an add instruction */
229   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
230   COSTS_N_INSNS (4),                    /* variable shift costs */
231   COSTS_N_INSNS (1),                    /* constant shift costs */
232   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
233    COSTS_N_INSNS (11),                  /*                               HI */
234    COSTS_N_INSNS (11),                  /*                               SI */
235    COSTS_N_INSNS (11),                  /*                               DI */
236    COSTS_N_INSNS (11)},                 /*                               other */
237   0,                                    /* cost of multiply per each bit set */
238   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
239    COSTS_N_INSNS (25),                  /*                          HI */
240    COSTS_N_INSNS (25),                  /*                          SI */
241    COSTS_N_INSNS (25),                  /*                          DI */
242    COSTS_N_INSNS (25)},                 /*                          other */
243   COSTS_N_INSNS (3),                    /* cost of movsx */
244   COSTS_N_INSNS (2),                    /* cost of movzx */
245   8,                                    /* "large" insn */
246   6,                                    /* MOVE_RATIO */
247   6,                                    /* cost for loading QImode using movzbl */
248   {2, 4, 2},                            /* cost of loading integer registers
249                                            in QImode, HImode and SImode.
250                                            Relative to reg-reg move (2).  */
251   {2, 4, 2},                            /* cost of storing integer registers */
252   2,                                    /* cost of reg,reg fld/fst */
253   {2, 2, 6},                            /* cost of loading fp registers
254                                            in SFmode, DFmode and XFmode */
255   {4, 4, 6},                            /* cost of loading integer registers */
256   8,                                    /* cost of moving MMX register */
257   {8, 8},                               /* cost of loading MMX registers
258                                            in SImode and DImode */
259   {8, 8},                               /* cost of storing MMX registers
260                                            in SImode and DImode */
261   2,                                    /* cost of moving SSE register */
262   {4, 8, 16},                           /* cost of loading SSE registers
263                                            in SImode, DImode and TImode */
264   {4, 8, 16},                           /* cost of storing SSE registers
265                                            in SImode, DImode and TImode */
266   3,                                    /* MMX or SSE register to integer */
267   0,                                    /* size of prefetch block */
268   0,                                    /* number of parallel prefetches */
269   2,                                    /* Branch cost */
270   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
271   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
272   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
273   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
274   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
275   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
276 };
277
278 static const
279 struct processor_costs pentiumpro_cost = {
280   COSTS_N_INSNS (1),                    /* cost of an add instruction */
281   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
282   COSTS_N_INSNS (1),                    /* variable shift costs */
283   COSTS_N_INSNS (1),                    /* constant shift costs */
284   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
285    COSTS_N_INSNS (4),                   /*                               HI */
286    COSTS_N_INSNS (4),                   /*                               SI */
287    COSTS_N_INSNS (4),                   /*                               DI */
288    COSTS_N_INSNS (4)},                  /*                               other */
289   0,                                    /* cost of multiply per each bit set */
290   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
291    COSTS_N_INSNS (17),                  /*                          HI */
292    COSTS_N_INSNS (17),                  /*                          SI */
293    COSTS_N_INSNS (17),                  /*                          DI */
294    COSTS_N_INSNS (17)},                 /*                          other */
295   COSTS_N_INSNS (1),                    /* cost of movsx */
296   COSTS_N_INSNS (1),                    /* cost of movzx */
297   8,                                    /* "large" insn */
298   6,                                    /* MOVE_RATIO */
299   2,                                    /* cost for loading QImode using movzbl */
300   {4, 4, 4},                            /* cost of loading integer registers
301                                            in QImode, HImode and SImode.
302                                            Relative to reg-reg move (2).  */
303   {2, 2, 2},                            /* cost of storing integer registers */
304   2,                                    /* cost of reg,reg fld/fst */
305   {2, 2, 6},                            /* cost of loading fp registers
306                                            in SFmode, DFmode and XFmode */
307   {4, 4, 6},                            /* cost of loading integer registers */
308   2,                                    /* cost of moving MMX register */
309   {2, 2},                               /* cost of loading MMX registers
310                                            in SImode and DImode */
311   {2, 2},                               /* cost of storing MMX registers
312                                            in SImode and DImode */
313   2,                                    /* cost of moving SSE register */
314   {2, 2, 8},                            /* cost of loading SSE registers
315                                            in SImode, DImode and TImode */
316   {2, 2, 8},                            /* cost of storing SSE registers
317                                            in SImode, DImode and TImode */
318   3,                                    /* MMX or SSE register to integer */
319   32,                                   /* size of prefetch block */
320   6,                                    /* number of parallel prefetches */
321   2,                                    /* Branch cost */
322   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
323   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
324   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
325   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
326   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
327   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
328 };
329
330 static const
331 struct processor_costs k6_cost = {
332   COSTS_N_INSNS (1),                    /* cost of an add instruction */
333   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
334   COSTS_N_INSNS (1),                    /* variable shift costs */
335   COSTS_N_INSNS (1),                    /* constant shift costs */
336   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
337    COSTS_N_INSNS (3),                   /*                               HI */
338    COSTS_N_INSNS (3),                   /*                               SI */
339    COSTS_N_INSNS (3),                   /*                               DI */
340    COSTS_N_INSNS (3)},                  /*                               other */
341   0,                                    /* cost of multiply per each bit set */
342   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
343    COSTS_N_INSNS (18),                  /*                          HI */
344    COSTS_N_INSNS (18),                  /*                          SI */
345    COSTS_N_INSNS (18),                  /*                          DI */
346    COSTS_N_INSNS (18)},                 /*                          other */
347   COSTS_N_INSNS (2),                    /* cost of movsx */
348   COSTS_N_INSNS (2),                    /* cost of movzx */
349   8,                                    /* "large" insn */
350   4,                                    /* MOVE_RATIO */
351   3,                                    /* cost for loading QImode using movzbl */
352   {4, 5, 4},                            /* cost of loading integer registers
353                                            in QImode, HImode and SImode.
354                                            Relative to reg-reg move (2).  */
355   {2, 3, 2},                            /* cost of storing integer registers */
356   4,                                    /* cost of reg,reg fld/fst */
357   {6, 6, 6},                            /* cost of loading fp registers
358                                            in SFmode, DFmode and XFmode */
359   {4, 4, 4},                            /* cost of loading integer registers */
360   2,                                    /* cost of moving MMX register */
361   {2, 2},                               /* cost of loading MMX registers
362                                            in SImode and DImode */
363   {2, 2},                               /* cost of storing MMX registers
364                                            in SImode and DImode */
365   2,                                    /* cost of moving SSE register */
366   {2, 2, 8},                            /* cost of loading SSE registers
367                                            in SImode, DImode and TImode */
368   {2, 2, 8},                            /* cost of storing SSE registers
369                                            in SImode, DImode and TImode */
370   6,                                    /* MMX or SSE register to integer */
371   32,                                   /* size of prefetch block */
372   1,                                    /* number of parallel prefetches */
373   1,                                    /* Branch cost */
374   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
375   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
376   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
377   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
378   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
379   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
380 };
381
382 static const
383 struct processor_costs athlon_cost = {
384   COSTS_N_INSNS (1),                    /* cost of an add instruction */
385   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
386   COSTS_N_INSNS (1),                    /* variable shift costs */
387   COSTS_N_INSNS (1),                    /* constant shift costs */
388   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
389    COSTS_N_INSNS (5),                   /*                               HI */
390    COSTS_N_INSNS (5),                   /*                               SI */
391    COSTS_N_INSNS (5),                   /*                               DI */
392    COSTS_N_INSNS (5)},                  /*                               other */
393   0,                                    /* cost of multiply per each bit set */
394   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
395    COSTS_N_INSNS (26),                  /*                          HI */
396    COSTS_N_INSNS (42),                  /*                          SI */
397    COSTS_N_INSNS (74),                  /*                          DI */
398    COSTS_N_INSNS (74)},                 /*                          other */
399   COSTS_N_INSNS (1),                    /* cost of movsx */
400   COSTS_N_INSNS (1),                    /* cost of movzx */
401   8,                                    /* "large" insn */
402   9,                                    /* MOVE_RATIO */
403   4,                                    /* cost for loading QImode using movzbl */
404   {3, 4, 3},                            /* cost of loading integer registers
405                                            in QImode, HImode and SImode.
406                                            Relative to reg-reg move (2).  */
407   {3, 4, 3},                            /* cost of storing integer registers */
408   4,                                    /* cost of reg,reg fld/fst */
409   {4, 4, 12},                           /* cost of loading fp registers
410                                            in SFmode, DFmode and XFmode */
411   {6, 6, 8},                            /* cost of loading integer registers */
412   2,                                    /* cost of moving MMX register */
413   {4, 4},                               /* cost of loading MMX registers
414                                            in SImode and DImode */
415   {4, 4},                               /* cost of storing MMX registers
416                                            in SImode and DImode */
417   2,                                    /* cost of moving SSE register */
418   {4, 4, 6},                            /* cost of loading SSE registers
419                                            in SImode, DImode and TImode */
420   {4, 4, 5},                            /* cost of storing SSE registers
421                                            in SImode, DImode and TImode */
422   5,                                    /* MMX or SSE register to integer */
423   64,                                   /* size of prefetch block */
424   6,                                    /* number of parallel prefetches */
425   5,                                    /* Branch cost */
426   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
427   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
428   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
429   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
430   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
431   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
432 };
433
434 static const
435 struct processor_costs k8_cost = {
436   COSTS_N_INSNS (1),                    /* cost of an add instruction */
437   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
438   COSTS_N_INSNS (1),                    /* variable shift costs */
439   COSTS_N_INSNS (1),                    /* constant shift costs */
440   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
441    COSTS_N_INSNS (4),                   /*                               HI */
442    COSTS_N_INSNS (3),                   /*                               SI */
443    COSTS_N_INSNS (4),                   /*                               DI */
444    COSTS_N_INSNS (5)},                  /*                               other */
445   0,                                    /* cost of multiply per each bit set */
446   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
447    COSTS_N_INSNS (26),                  /*                          HI */
448    COSTS_N_INSNS (42),                  /*                          SI */
449    COSTS_N_INSNS (74),                  /*                          DI */
450    COSTS_N_INSNS (74)},                 /*                          other */
451   COSTS_N_INSNS (1),                    /* cost of movsx */
452   COSTS_N_INSNS (1),                    /* cost of movzx */
453   8,                                    /* "large" insn */
454   9,                                    /* MOVE_RATIO */
455   4,                                    /* cost for loading QImode using movzbl */
456   {3, 4, 3},                            /* cost of loading integer registers
457                                            in QImode, HImode and SImode.
458                                            Relative to reg-reg move (2).  */
459   {3, 4, 3},                            /* cost of storing integer registers */
460   4,                                    /* cost of reg,reg fld/fst */
461   {4, 4, 12},                           /* cost of loading fp registers
462                                            in SFmode, DFmode and XFmode */
463   {6, 6, 8},                            /* cost of loading integer registers */
464   2,                                    /* cost of moving MMX register */
465   {3, 3},                               /* cost of loading MMX registers
466                                            in SImode and DImode */
467   {4, 4},                               /* cost of storing MMX registers
468                                            in SImode and DImode */
469   2,                                    /* cost of moving SSE register */
470   {4, 3, 6},                            /* cost of loading SSE registers
471                                            in SImode, DImode and TImode */
472   {4, 4, 5},                            /* cost of storing SSE registers
473                                            in SImode, DImode and TImode */
474   5,                                    /* MMX or SSE register to integer */
475   64,                                   /* size of prefetch block */
476   6,                                    /* number of parallel prefetches */
477   5,                                    /* Branch cost */
478   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
479   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
480   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
481   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
482   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
483   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
484 };
485
486 static const
487 struct processor_costs pentium4_cost = {
488   COSTS_N_INSNS (1),                    /* cost of an add instruction */
489   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
490   COSTS_N_INSNS (4),                    /* variable shift costs */
491   COSTS_N_INSNS (4),                    /* constant shift costs */
492   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
493    COSTS_N_INSNS (15),                  /*                               HI */
494    COSTS_N_INSNS (15),                  /*                               SI */
495    COSTS_N_INSNS (15),                  /*                               DI */
496    COSTS_N_INSNS (15)},                 /*                               other */
497   0,                                    /* cost of multiply per each bit set */
498   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
499    COSTS_N_INSNS (56),                  /*                          HI */
500    COSTS_N_INSNS (56),                  /*                          SI */
501    COSTS_N_INSNS (56),                  /*                          DI */
502    COSTS_N_INSNS (56)},                 /*                          other */
503   COSTS_N_INSNS (1),                    /* cost of movsx */
504   COSTS_N_INSNS (1),                    /* cost of movzx */
505   16,                                   /* "large" insn */
506   6,                                    /* MOVE_RATIO */
507   2,                                    /* cost for loading QImode using movzbl */
508   {4, 5, 4},                            /* cost of loading integer registers
509                                            in QImode, HImode and SImode.
510                                            Relative to reg-reg move (2).  */
511   {2, 3, 2},                            /* cost of storing integer registers */
512   2,                                    /* cost of reg,reg fld/fst */
513   {2, 2, 6},                            /* cost of loading fp registers
514                                            in SFmode, DFmode and XFmode */
515   {4, 4, 6},                            /* cost of loading integer registers */
516   2,                                    /* cost of moving MMX register */
517   {2, 2},                               /* cost of loading MMX registers
518                                            in SImode and DImode */
519   {2, 2},                               /* cost of storing MMX registers
520                                            in SImode and DImode */
521   12,                                   /* cost of moving SSE register */
522   {12, 12, 12},                         /* cost of loading SSE registers
523                                            in SImode, DImode and TImode */
524   {2, 2, 8},                            /* cost of storing SSE registers
525                                            in SImode, DImode and TImode */
526   10,                                   /* MMX or SSE register to integer */
527   64,                                   /* size of prefetch block */
528   6,                                    /* number of parallel prefetches */
529   2,                                    /* Branch cost */
530   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
531   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
532   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
533   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
534   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
535   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
536 };
537
538 static const
539 struct processor_costs nocona_cost = {
540   COSTS_N_INSNS (1),                    /* cost of an add instruction */
541   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
542   COSTS_N_INSNS (1),                    /* variable shift costs */
543   COSTS_N_INSNS (1),                    /* constant shift costs */
544   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
545    COSTS_N_INSNS (10),                  /*                               HI */
546    COSTS_N_INSNS (10),                  /*                               SI */
547    COSTS_N_INSNS (10),                  /*                               DI */
548    COSTS_N_INSNS (10)},                 /*                               other */
549   0,                                    /* cost of multiply per each bit set */
550   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
551    COSTS_N_INSNS (66),                  /*                          HI */
552    COSTS_N_INSNS (66),                  /*                          SI */
553    COSTS_N_INSNS (66),                  /*                          DI */
554    COSTS_N_INSNS (66)},                 /*                          other */
555   COSTS_N_INSNS (1),                    /* cost of movsx */
556   COSTS_N_INSNS (1),                    /* cost of movzx */
557   16,                                   /* "large" insn */
558   17,                                   /* MOVE_RATIO */
559   4,                                    /* cost for loading QImode using movzbl */
560   {4, 4, 4},                            /* cost of loading integer registers
561                                            in QImode, HImode and SImode.
562                                            Relative to reg-reg move (2).  */
563   {4, 4, 4},                            /* cost of storing integer registers */
564   3,                                    /* cost of reg,reg fld/fst */
565   {12, 12, 12},                         /* cost of loading fp registers
566                                            in SFmode, DFmode and XFmode */
567   {4, 4, 4},                            /* cost of loading integer registers */
568   6,                                    /* cost of moving MMX register */
569   {12, 12},                             /* cost of loading MMX registers
570                                            in SImode and DImode */
571   {12, 12},                             /* cost of storing MMX registers
572                                            in SImode and DImode */
573   6,                                    /* cost of moving SSE register */
574   {12, 12, 12},                         /* cost of loading SSE registers
575                                            in SImode, DImode and TImode */
576   {12, 12, 12},                         /* cost of storing SSE registers
577                                            in SImode, DImode and TImode */
578   8,                                    /* MMX or SSE register to integer */
579   128,                                  /* size of prefetch block */
580   8,                                    /* number of parallel prefetches */
581   1,                                    /* Branch cost */
582   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
583   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
584   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
585   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
586   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
587   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
588 };
589
590 /* Generic64 should produce code tuned for Nocona and K8.  */
591 static const
592 struct processor_costs generic64_cost = {
593   COSTS_N_INSNS (1),                    /* cost of an add instruction */
594   /* On all chips taken into consideration lea is 2 cycles and more.  With
595      this cost however our current implementation of synth_mult results in
596      use of unnecesary temporary registers causing regression on several
597      SPECfp benchmarks.  */
598   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
599   COSTS_N_INSNS (1),                    /* variable shift costs */
600   COSTS_N_INSNS (1),                    /* constant shift costs */
601   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
602    COSTS_N_INSNS (4),                   /*                               HI */
603    COSTS_N_INSNS (3),                   /*                               SI */
604    COSTS_N_INSNS (4),                   /*                               DI */
605    COSTS_N_INSNS (2)},                  /*                               other */
606   0,                                    /* cost of multiply per each bit set */
607   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
608    COSTS_N_INSNS (26),                  /*                          HI */
609    COSTS_N_INSNS (42),                  /*                          SI */
610    COSTS_N_INSNS (74),                  /*                          DI */
611    COSTS_N_INSNS (74)},                 /*                          other */
612   COSTS_N_INSNS (1),                    /* cost of movsx */
613   COSTS_N_INSNS (1),                    /* cost of movzx */
614   8,                                    /* "large" insn */
615   17,                                   /* MOVE_RATIO */
616   4,                                    /* cost for loading QImode using movzbl */
617   {4, 4, 4},                            /* cost of loading integer registers
618                                            in QImode, HImode and SImode.
619                                            Relative to reg-reg move (2).  */
620   {4, 4, 4},                            /* cost of storing integer registers */
621   4,                                    /* cost of reg,reg fld/fst */
622   {12, 12, 12},                         /* cost of loading fp registers
623                                            in SFmode, DFmode and XFmode */
624   {6, 6, 8},                            /* cost of loading integer registers */
625   2,                                    /* cost of moving MMX register */
626   {8, 8},                               /* cost of loading MMX registers
627                                            in SImode and DImode */
628   {8, 8},                               /* cost of storing MMX registers
629                                            in SImode and DImode */
630   2,                                    /* cost of moving SSE register */
631   {8, 8, 8},                            /* cost of loading SSE registers
632                                            in SImode, DImode and TImode */
633   {8, 8, 8},                            /* cost of storing SSE registers
634                                            in SImode, DImode and TImode */
635   5,                                    /* MMX or SSE register to integer */
636   64,                                   /* size of prefetch block */
637   6,                                    /* number of parallel prefetches */
638   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this value
639      is increased to perhaps more appropriate value of 5.  */
640   3,                                    /* Branch cost */
641   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
642   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
643   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
644   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
645   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
646   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
647 };
648
649 /* Generic32 should produce code tuned for Athlon, PPro, Pentium4, Nocona and K8.  */
650 static const
651 struct processor_costs generic32_cost = {
652   COSTS_N_INSNS (1),                    /* cost of an add instruction */
653   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
654   COSTS_N_INSNS (1),                    /* variable shift costs */
655   COSTS_N_INSNS (1),                    /* constant shift costs */
656   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
657    COSTS_N_INSNS (4),                   /*                               HI */
658    COSTS_N_INSNS (3),                   /*                               SI */
659    COSTS_N_INSNS (4),                   /*                               DI */
660    COSTS_N_INSNS (2)},                  /*                               other */
661   0,                                    /* cost of multiply per each bit set */
662   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
663    COSTS_N_INSNS (26),                  /*                          HI */
664    COSTS_N_INSNS (42),                  /*                          SI */
665    COSTS_N_INSNS (74),                  /*                          DI */
666    COSTS_N_INSNS (74)},                 /*                          other */
667   COSTS_N_INSNS (1),                    /* cost of movsx */
668   COSTS_N_INSNS (1),                    /* cost of movzx */
669   8,                                    /* "large" insn */
670   17,                                   /* MOVE_RATIO */
671   4,                                    /* cost for loading QImode using movzbl */
672   {4, 4, 4},                            /* cost of loading integer registers
673                                            in QImode, HImode and SImode.
674                                            Relative to reg-reg move (2).  */
675   {4, 4, 4},                            /* cost of storing integer registers */
676   4,                                    /* cost of reg,reg fld/fst */
677   {12, 12, 12},                         /* cost of loading fp registers
678                                            in SFmode, DFmode and XFmode */
679   {6, 6, 8},                            /* cost of loading integer registers */
680   2,                                    /* cost of moving MMX register */
681   {8, 8},                               /* cost of loading MMX registers
682                                            in SImode and DImode */
683   {8, 8},                               /* cost of storing MMX registers
684                                            in SImode and DImode */
685   2,                                    /* cost of moving SSE register */
686   {8, 8, 8},                            /* cost of loading SSE registers
687                                            in SImode, DImode and TImode */
688   {8, 8, 8},                            /* cost of storing SSE registers
689                                            in SImode, DImode and TImode */
690   5,                                    /* MMX or SSE register to integer */
691   64,                                   /* size of prefetch block */
692   6,                                    /* number of parallel prefetches */
693   3,                                    /* Branch cost */
694   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
695   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
696   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
697   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
698   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
699   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
700 };
701
702 const struct processor_costs *ix86_cost = &pentium_cost;
703
704 /* Processor feature/optimization bitmasks.  */
705 #define m_386 (1<<PROCESSOR_I386)
706 #define m_486 (1<<PROCESSOR_I486)
707 #define m_PENT (1<<PROCESSOR_PENTIUM)
708 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
709 #define m_K6  (1<<PROCESSOR_K6)
710 #define m_ATHLON  (1<<PROCESSOR_ATHLON)
711 #define m_PENT4  (1<<PROCESSOR_PENTIUM4)
712 #define m_K8  (1<<PROCESSOR_K8)
713 #define m_ATHLON_K8  (m_K8 | m_ATHLON)
714 #define m_NOCONA  (1<<PROCESSOR_NOCONA)
715 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
716 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
717 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
718
719 /* Generic instruction choice should be common subset of supported CPUs
720    (PPro/PENT4/NOCONA/Athlon/K8).  */
721
722 /* Leave is not affecting Nocona SPEC2000 results negatively, so enabling for
723    Generic64 seems like good code size tradeoff.  We can't enable it for 32bit
724    generic because it is not working well with PPro base chips.  */
725 const int x86_use_leave = m_386 | m_K6 | m_ATHLON_K8 | m_GENERIC64;
726 const int x86_push_memory = m_386 | m_K6 | m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
727 const int x86_zero_extend_with_and = m_486 | m_PENT;
728 const int x86_movx = m_ATHLON_K8 | m_PPRO | m_PENT4 | m_NOCONA | m_GENERIC /* m_386 | m_K6 */;
729 const int x86_double_with_add = ~m_386;
730 const int x86_use_bit_test = m_386;
731 const int x86_unroll_strlen = m_486 | m_PENT | m_PPRO | m_ATHLON_K8 | m_K6 | m_GENERIC;
732 const int x86_cmove = m_PPRO | m_ATHLON_K8 | m_PENT4 | m_NOCONA; 
733 const int x86_fisttp = m_NOCONA;
734 const int x86_3dnow_a = m_ATHLON_K8;
735 const int x86_deep_branch = m_PPRO | m_K6 | m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
736 /* Branch hints were put in P4 based on simulation result. But
737    after P4 was made, no performance benefit was observed with
738    branch hints. It also increases the code size. As the result,
739    icc never generates branch hints.  */
740 const int x86_branch_hints = 0;
741 const int x86_use_sahf = m_PPRO | m_K6 | m_PENT4 | m_NOCONA | m_GENERIC32; /*m_GENERIC | m_ATHLON_K8 ? */
742 /* We probably ought to watch for partial register stalls on Generic32
743    compilation setting as well.  However in current implementation the
744    partial register stalls are not eliminated very well - they can
745    be introduced via subregs synthesized by combine and can happen
746    in caller/callee saving sequences.
747    Because this option pays back little on PPro based chips and is in conflict
748    with partial reg. dependencies used by Athlon/P4 based chips, it is better
749    to leave it off for generic32 for now.  */
750 const int x86_partial_reg_stall = m_PPRO;
751 const int x86_use_himode_fiop = m_386 | m_486 | m_K6;
752 const int x86_use_simode_fiop = ~(m_PPRO | m_ATHLON_K8 | m_PENT | m_GENERIC);
753 const int x86_use_mov0 = m_K6;
754 const int x86_use_cltd = ~(m_PENT | m_K6 | m_GENERIC);
755 const int x86_read_modify_write = ~m_PENT;
756 const int x86_read_modify = ~(m_PENT | m_PPRO);
757 const int x86_split_long_moves = m_PPRO;
758 const int x86_promote_QImode = m_K6 | m_PENT | m_386 | m_486 | m_ATHLON_K8 | m_GENERIC; /* m_PENT4 ? */
759 const int x86_fast_prefix = ~(m_PENT | m_486 | m_386);
760 const int x86_single_stringop = m_386 | m_PENT4 | m_NOCONA;
761 const int x86_qimode_math = ~(0);
762 const int x86_promote_qi_regs = 0;
763 /* On PPro this flag is meant to avoid partial register stalls.  Just like
764    the x86_partial_reg_stall this option might be considered for Generic32
765    if our scheme for avoiding partial stalls was more effective.  */
766 const int x86_himode_math = ~(m_PPRO);
767 const int x86_promote_hi_regs = m_PPRO;
768 const int x86_sub_esp_4 = m_ATHLON_K8 | m_PPRO | m_PENT4 | m_NOCONA | m_GENERIC;
769 const int x86_sub_esp_8 = m_ATHLON_K8 | m_PPRO | m_386 | m_486 | m_PENT4 | m_NOCONA | m_GENERIC;
770 const int x86_add_esp_4 = m_ATHLON_K8 | m_K6 | m_PENT4 | m_NOCONA | m_GENERIC;
771 const int x86_add_esp_8 = m_ATHLON_K8 | m_PPRO | m_K6 | m_386 | m_486 | m_PENT4 | m_NOCONA | m_GENERIC;
772 const int x86_integer_DFmode_moves = ~(m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_PPRO | m_GENERIC);
773 const int x86_partial_reg_dependency = m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
774 const int x86_memory_mismatch_stall = m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
775 const int x86_accumulate_outgoing_args = m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_PPRO | m_GENERIC;
776 const int x86_prologue_using_move = m_ATHLON_K8 | m_PPRO | m_GENERIC;
777 const int x86_epilogue_using_move = m_ATHLON_K8 | m_PPRO | m_GENERIC;
778 const int x86_shift1 = ~m_486;
779 const int x86_arch_always_fancy_math_387 = m_PENT | m_PPRO | m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
780 /* In Generic model we have an conflict here in between PPro/Pentium4 based chips
781    that thread 128bit SSE registers as single units versus K8 based chips that
782    divide SSE registers to two 64bit halves.
783    x86_sse_partial_reg_dependency promote all store destinations to be 128bit
784    to allow register renaming on 128bit SSE units, but usually results in one
785    extra microop on 64bit SSE units.  Experimental results shows that disabling
786    this option on P4 brings over 20% SPECfp regression, while enabling it on
787    K8 brings roughly 2.4% regression that can be partly masked by careful scheduling
788    of moves.  */
789 const int x86_sse_partial_reg_dependency = m_PENT4 | m_NOCONA | m_PPRO | m_GENERIC;
790 /* Set for machines where the type and dependencies are resolved on SSE
791    register parts instead of whole registers, so we may maintain just
792    lower part of scalar values in proper format leaving the upper part
793    undefined.  */
794 const int x86_sse_split_regs = m_ATHLON_K8;
795 const int x86_sse_typeless_stores = m_ATHLON_K8;
796 const int x86_sse_load0_by_pxor = m_PPRO | m_PENT4 | m_NOCONA;
797 const int x86_use_ffreep = m_ATHLON_K8;
798 const int x86_rep_movl_optimal = m_386 | m_PENT | m_PPRO | m_K6;
799 const int x86_use_incdec = ~(m_PENT4 | m_NOCONA | m_GENERIC);
800
801 /* ??? Allowing interunit moves makes it all too easy for the compiler to put
802    integer data in xmm registers.  Which results in pretty abysmal code.  */
803 const int x86_inter_unit_moves = 0 /* ~(m_ATHLON_K8) */;
804
805 const int x86_ext_80387_constants = m_K6 | m_ATHLON | m_PENT4 | m_NOCONA | m_PPRO | m_GENERIC32;
806 /* Some CPU cores are not able to predict more than 4 branch instructions in
807    the 16 byte window.  */
808 const int x86_four_jump_limit = m_PPRO | m_ATHLON_K8 | m_PENT4 | m_NOCONA | m_GENERIC;
809 const int x86_schedule = m_PPRO | m_ATHLON_K8 | m_K6 | m_PENT | m_GENERIC;
810 const int x86_use_bt = m_ATHLON_K8;
811 /* Compare and exchange was added for 80486.  */
812 const int x86_cmpxchg = ~m_386;
813 /* Compare and exchange 8 bytes was added for pentium.  */
814 const int x86_cmpxchg8b = ~(m_386 | m_486);
815 /* Compare and exchange 16 bytes was added for nocona.  */
816 const int x86_cmpxchg16b = m_NOCONA;
817 /* Exchange and add was added for 80486.  */
818 const int x86_xadd = ~m_386;
819 const int x86_pad_returns = m_ATHLON_K8 | m_GENERIC;
820
821 /* In case the average insn count for single function invocation is
822    lower than this constant, emit fast (but longer) prologue and
823    epilogue code.  */
824 #define FAST_PROLOGUE_INSN_COUNT 20
825
826 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
827 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
828 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
829 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
830
831 /* Array of the smallest class containing reg number REGNO, indexed by
832    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
833
834 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
835 {
836   /* ax, dx, cx, bx */
837   AREG, DREG, CREG, BREG,
838   /* si, di, bp, sp */
839   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
840   /* FP registers */
841   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
842   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
843   /* arg pointer */
844   NON_Q_REGS,
845   /* flags, fpsr, dirflag, frame */
846   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
847   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
848   SSE_REGS, SSE_REGS,
849   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
850   MMX_REGS, MMX_REGS,
851   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
852   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
853   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
854   SSE_REGS, SSE_REGS,
855 };
856
857 /* The "default" register map used in 32bit mode.  */
858
859 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
860 {
861   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
862   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
863   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, dir, frame */
864   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
865   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
866   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
867   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
868 };
869
870 static int const x86_64_int_parameter_registers[6] =
871 {
872   5 /*RDI*/, 4 /*RSI*/, 1 /*RDX*/, 2 /*RCX*/,
873   FIRST_REX_INT_REG /*R8 */, FIRST_REX_INT_REG + 1 /*R9 */
874 };
875
876 static int const x86_64_int_return_registers[4] =
877 {
878   0 /*RAX*/, 1 /*RDI*/, 5 /*RDI*/, 4 /*RSI*/
879 };
880
881 /* The "default" register map used in 64bit mode.  */
882 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
883 {
884   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
885   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
886   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, dir, frame */
887   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
888   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
889   8,9,10,11,12,13,14,15,                /* extended integer registers */
890   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
891 };
892
893 /* Define the register numbers to be used in Dwarf debugging information.
894    The SVR4 reference port C compiler uses the following register numbers
895    in its Dwarf output code:
896         0 for %eax (gcc regno = 0)
897         1 for %ecx (gcc regno = 2)
898         2 for %edx (gcc regno = 1)
899         3 for %ebx (gcc regno = 3)
900         4 for %esp (gcc regno = 7)
901         5 for %ebp (gcc regno = 6)
902         6 for %esi (gcc regno = 4)
903         7 for %edi (gcc regno = 5)
904    The following three DWARF register numbers are never generated by
905    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
906    believes these numbers have these meanings.
907         8  for %eip    (no gcc equivalent)
908         9  for %eflags (gcc regno = 17)
909         10 for %trapno (no gcc equivalent)
910    It is not at all clear how we should number the FP stack registers
911    for the x86 architecture.  If the version of SDB on x86/svr4 were
912    a bit less brain dead with respect to floating-point then we would
913    have a precedent to follow with respect to DWARF register numbers
914    for x86 FP registers, but the SDB on x86/svr4 is so completely
915    broken with respect to FP registers that it is hardly worth thinking
916    of it as something to strive for compatibility with.
917    The version of x86/svr4 SDB I have at the moment does (partially)
918    seem to believe that DWARF register number 11 is associated with
919    the x86 register %st(0), but that's about all.  Higher DWARF
920    register numbers don't seem to be associated with anything in
921    particular, and even for DWARF regno 11, SDB only seems to under-
922    stand that it should say that a variable lives in %st(0) (when
923    asked via an `=' command) if we said it was in DWARF regno 11,
924    but SDB still prints garbage when asked for the value of the
925    variable in question (via a `/' command).
926    (Also note that the labels SDB prints for various FP stack regs
927    when doing an `x' command are all wrong.)
928    Note that these problems generally don't affect the native SVR4
929    C compiler because it doesn't allow the use of -O with -g and
930    because when it is *not* optimizing, it allocates a memory
931    location for each floating-point variable, and the memory
932    location is what gets described in the DWARF AT_location
933    attribute for the variable in question.
934    Regardless of the severe mental illness of the x86/svr4 SDB, we
935    do something sensible here and we use the following DWARF
936    register numbers.  Note that these are all stack-top-relative
937    numbers.
938         11 for %st(0) (gcc regno = 8)
939         12 for %st(1) (gcc regno = 9)
940         13 for %st(2) (gcc regno = 10)
941         14 for %st(3) (gcc regno = 11)
942         15 for %st(4) (gcc regno = 12)
943         16 for %st(5) (gcc regno = 13)
944         17 for %st(6) (gcc regno = 14)
945         18 for %st(7) (gcc regno = 15)
946 */
947 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
948 {
949   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
950   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
951   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, dir, frame */
952   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
953   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
954   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
955   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
956 };
957
958 /* Test and compare insns in i386.md store the information needed to
959    generate branch and scc insns here.  */
960
961 rtx ix86_compare_op0 = NULL_RTX;
962 rtx ix86_compare_op1 = NULL_RTX;
963 rtx ix86_compare_emitted = NULL_RTX;
964
965 /* Size of the register save area.  */
966 #define X86_64_VARARGS_SIZE (REGPARM_MAX * UNITS_PER_WORD + SSE_REGPARM_MAX * 16)
967
968 /* Define the structure for the machine field in struct function.  */
969
970 struct stack_local_entry GTY(())
971 {
972   unsigned short mode;
973   unsigned short n;
974   rtx rtl;
975   struct stack_local_entry *next;
976 };
977
978 /* Structure describing stack frame layout.
979    Stack grows downward:
980
981    [arguments]
982                                               <- ARG_POINTER
983    saved pc
984
985    saved frame pointer if frame_pointer_needed
986                                               <- HARD_FRAME_POINTER
987    [saved regs]
988
989    [padding1]          \
990                         )
991    [va_arg registers]  (
992                         > to_allocate         <- FRAME_POINTER
993    [frame]             (
994                         )
995    [padding2]          /
996   */
997 struct ix86_frame
998 {
999   int nregs;
1000   int padding1;
1001   int va_arg_size;
1002   HOST_WIDE_INT frame;
1003   int padding2;
1004   int outgoing_arguments_size;
1005   int red_zone_size;
1006
1007   HOST_WIDE_INT to_allocate;
1008   /* The offsets relative to ARG_POINTER.  */
1009   HOST_WIDE_INT frame_pointer_offset;
1010   HOST_WIDE_INT hard_frame_pointer_offset;
1011   HOST_WIDE_INT stack_pointer_offset;
1012
1013   /* When save_regs_using_mov is set, emit prologue using
1014      move instead of push instructions.  */
1015   bool save_regs_using_mov;
1016 };
1017
1018 /* Code model option.  */
1019 enum cmodel ix86_cmodel;
1020 /* Asm dialect.  */
1021 enum asm_dialect ix86_asm_dialect = ASM_ATT;
1022 /* TLS dialects.  */
1023 enum tls_dialect ix86_tls_dialect = TLS_DIALECT_GNU;
1024
1025 /* Which unit we are generating floating point math for.  */
1026 enum fpmath_unit ix86_fpmath;
1027
1028 /* Which cpu are we scheduling for.  */
1029 enum processor_type ix86_tune;
1030 /* Which instruction set architecture to use.  */
1031 enum processor_type ix86_arch;
1032
1033 /* true if sse prefetch instruction is not NOOP.  */
1034 int x86_prefetch_sse;
1035
1036 /* ix86_regparm_string as a number */
1037 static int ix86_regparm;
1038
1039 /* Preferred alignment for stack boundary in bits.  */
1040 unsigned int ix86_preferred_stack_boundary;
1041
1042 /* Values 1-5: see jump.c */
1043 int ix86_branch_cost;
1044
1045 /* Variables which are this size or smaller are put in the data/bss
1046    or ldata/lbss sections.  */
1047
1048 int ix86_section_threshold = 65536;
1049
1050 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
1051 char internal_label_prefix[16];
1052 int internal_label_prefix_len;
1053
1054 /* Table for BUILT_IN_NORMAL to BUILT_IN_MD mapping.  */
1055 static GTY(()) tree ix86_builtin_function_variants[(int) END_BUILTINS];
1056 \f
1057 static bool ix86_handle_option (size_t, const char *, int);
1058 static void output_pic_addr_const (FILE *, rtx, int);
1059 static void put_condition_code (enum rtx_code, enum machine_mode,
1060                                 int, int, FILE *);
1061 static const char *get_some_local_dynamic_name (void);
1062 static int get_some_local_dynamic_name_1 (rtx *, void *);
1063 static rtx ix86_expand_int_compare (enum rtx_code, rtx, rtx);
1064 static enum rtx_code ix86_prepare_fp_compare_args (enum rtx_code, rtx *,
1065                                                    rtx *);
1066 static bool ix86_fixed_condition_code_regs (unsigned int *, unsigned int *);
1067 static enum machine_mode ix86_cc_modes_compatible (enum machine_mode,
1068                                                    enum machine_mode);
1069 static rtx get_thread_pointer (int);
1070 static rtx legitimize_tls_address (rtx, enum tls_model, int);
1071 static void get_pc_thunk_name (char [32], unsigned int);
1072 static rtx gen_push (rtx);
1073 static int ix86_flags_dependant (rtx, rtx, enum attr_type);
1074 static int ix86_agi_dependant (rtx, rtx, enum attr_type);
1075 static struct machine_function * ix86_init_machine_status (void);
1076 static int ix86_split_to_parts (rtx, rtx *, enum machine_mode);
1077 static int ix86_nsaved_regs (void);
1078 static void ix86_emit_save_regs (void);
1079 static void ix86_emit_save_regs_using_mov (rtx, HOST_WIDE_INT);
1080 static void ix86_emit_restore_regs_using_mov (rtx, HOST_WIDE_INT, int);
1081 static void ix86_output_function_epilogue (FILE *, HOST_WIDE_INT);
1082 static HOST_WIDE_INT ix86_GOT_alias_set (void);
1083 static void ix86_adjust_counter (rtx, HOST_WIDE_INT);
1084 static rtx ix86_expand_aligntest (rtx, int);
1085 static void ix86_expand_strlensi_unroll_1 (rtx, rtx, rtx);
1086 static int ix86_issue_rate (void);
1087 static int ix86_adjust_cost (rtx, rtx, rtx, int);
1088 static int ia32_multipass_dfa_lookahead (void);
1089 static void ix86_init_mmx_sse_builtins (void);
1090 static void ix86_init_sse_abi_builtins (void);
1091 static rtx x86_this_parameter (tree);
1092 static void x86_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
1093                                  HOST_WIDE_INT, tree);
1094 static bool x86_can_output_mi_thunk (tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
1095 static void x86_file_start (void);
1096 static void ix86_reorg (void);
1097 static bool ix86_expand_carry_flag_compare (enum rtx_code, rtx, rtx, rtx*);
1098 static tree ix86_build_builtin_va_list (void);
1099 static void ix86_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
1100                                          tree, int *, int);
1101 static tree ix86_gimplify_va_arg (tree, tree, tree *, tree *);
1102 static bool ix86_scalar_mode_supported_p (enum machine_mode);
1103 static bool ix86_vector_mode_supported_p (enum machine_mode);
1104
1105 static int ix86_address_cost (rtx);
1106 static bool ix86_cannot_force_const_mem (rtx);
1107 static rtx ix86_delegitimize_address (rtx);
1108
1109 static void i386_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
1110
1111 struct builtin_description;
1112 static rtx ix86_expand_sse_comi (const struct builtin_description *,
1113                                  tree, rtx);
1114 static rtx ix86_expand_sse_compare (const struct builtin_description *,
1115                                     tree, rtx);
1116 static rtx ix86_expand_unop1_builtin (enum insn_code, tree, rtx);
1117 static rtx ix86_expand_unop_builtin (enum insn_code, tree, rtx, int);
1118 static rtx ix86_expand_binop_builtin (enum insn_code, tree, rtx);
1119 static rtx ix86_expand_store_builtin (enum insn_code, tree);
1120 static rtx safe_vector_operand (rtx, enum machine_mode);
1121 static rtx ix86_expand_fp_compare (enum rtx_code, rtx, rtx, rtx, rtx *, rtx *);
1122 static int ix86_fp_comparison_arithmetics_cost (enum rtx_code code);
1123 static int ix86_fp_comparison_fcomi_cost (enum rtx_code code);
1124 static int ix86_fp_comparison_sahf_cost (enum rtx_code code);
1125 static int ix86_fp_comparison_cost (enum rtx_code code);
1126 static unsigned int ix86_select_alt_pic_regnum (void);
1127 static int ix86_save_reg (unsigned int, int);
1128 static void ix86_compute_frame_layout (struct ix86_frame *);
1129 static int ix86_comp_type_attributes (tree, tree);
1130 static int ix86_function_regparm (tree, tree);
1131 const struct attribute_spec ix86_attribute_table[];
1132 static bool ix86_function_ok_for_sibcall (tree, tree);
1133 static tree ix86_handle_cconv_attribute (tree *, tree, tree, int, bool *);
1134 static int ix86_value_regno (enum machine_mode, tree, tree);
1135 static bool contains_128bit_aligned_vector_p (tree);
1136 static rtx ix86_struct_value_rtx (tree, int);
1137 static bool ix86_ms_bitfield_layout_p (tree);
1138 static tree ix86_handle_struct_attribute (tree *, tree, tree, int, bool *);
1139 static int extended_reg_mentioned_1 (rtx *, void *);
1140 static bool ix86_rtx_costs (rtx, int, int, int *);
1141 static int min_insn_size (rtx);
1142 static tree ix86_md_asm_clobbers (tree outputs, tree inputs, tree clobbers);
1143 static bool ix86_must_pass_in_stack (enum machine_mode mode, tree type);
1144 static bool ix86_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
1145                                     tree, bool);
1146 static void ix86_init_builtins (void);
1147 static rtx ix86_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
1148 static rtx ix86_expand_library_builtin (tree, rtx, rtx, enum machine_mode, int);
1149 static const char *ix86_mangle_fundamental_type (tree);
1150 static tree ix86_stack_protect_fail (void);
1151 static rtx ix86_internal_arg_pointer (void);
1152 static void ix86_dwarf_handle_frame_unspec (const char *, rtx, int);
1153
1154 /* This function is only used on Solaris.  */
1155 static void i386_solaris_elf_named_section (const char *, unsigned int, tree)
1156   ATTRIBUTE_UNUSED;
1157
1158 /* Register class used for passing given 64bit part of the argument.
1159    These represent classes as documented by the PS ABI, with the exception
1160    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
1161    use SF or DFmode move instead of DImode to avoid reformatting penalties.
1162
1163    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
1164    whenever possible (upper half does contain padding).
1165  */
1166 enum x86_64_reg_class
1167   {
1168     X86_64_NO_CLASS,
1169     X86_64_INTEGER_CLASS,
1170     X86_64_INTEGERSI_CLASS,
1171     X86_64_SSE_CLASS,
1172     X86_64_SSESF_CLASS,
1173     X86_64_SSEDF_CLASS,
1174     X86_64_SSEUP_CLASS,
1175     X86_64_X87_CLASS,
1176     X86_64_X87UP_CLASS,
1177     X86_64_COMPLEX_X87_CLASS,
1178     X86_64_MEMORY_CLASS
1179   };
1180 static const char * const x86_64_reg_class_name[] = {
1181   "no", "integer", "integerSI", "sse", "sseSF", "sseDF",
1182   "sseup", "x87", "x87up", "cplx87", "no"
1183 };
1184
1185 #define MAX_CLASSES 4
1186
1187 /* Table of constants used by fldpi, fldln2, etc....  */
1188 static REAL_VALUE_TYPE ext_80387_constants_table [5];
1189 static bool ext_80387_constants_init = 0;
1190 static void init_ext_80387_constants (void);
1191 static bool ix86_in_large_data_p (tree) ATTRIBUTE_UNUSED;
1192 static void ix86_encode_section_info (tree, rtx, int) ATTRIBUTE_UNUSED;
1193 static void x86_64_elf_unique_section (tree decl, int reloc) ATTRIBUTE_UNUSED;
1194 static section *x86_64_elf_select_section (tree decl, int reloc,
1195                                            unsigned HOST_WIDE_INT align)
1196                                              ATTRIBUTE_UNUSED;
1197 \f
1198 /* Initialize the GCC target structure.  */
1199 #undef TARGET_ATTRIBUTE_TABLE
1200 #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table
1201 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
1202 #  undef TARGET_MERGE_DECL_ATTRIBUTES
1203 #  define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
1204 #endif
1205
1206 #undef TARGET_COMP_TYPE_ATTRIBUTES
1207 #define TARGET_COMP_TYPE_ATTRIBUTES ix86_comp_type_attributes
1208
1209 #undef TARGET_INIT_BUILTINS
1210 #define TARGET_INIT_BUILTINS ix86_init_builtins
1211 #undef TARGET_EXPAND_BUILTIN
1212 #define TARGET_EXPAND_BUILTIN ix86_expand_builtin
1213 #undef TARGET_EXPAND_LIBRARY_BUILTIN
1214 #define TARGET_EXPAND_LIBRARY_BUILTIN ix86_expand_library_builtin
1215
1216 #undef TARGET_ASM_FUNCTION_EPILOGUE
1217 #define TARGET_ASM_FUNCTION_EPILOGUE ix86_output_function_epilogue
1218
1219 #undef TARGET_ENCODE_SECTION_INFO
1220 #ifndef SUBTARGET_ENCODE_SECTION_INFO
1221 #define TARGET_ENCODE_SECTION_INFO ix86_encode_section_info
1222 #else
1223 #define TARGET_ENCODE_SECTION_INFO SUBTARGET_ENCODE_SECTION_INFO
1224 #endif
1225
1226 #undef TARGET_ASM_OPEN_PAREN
1227 #define TARGET_ASM_OPEN_PAREN ""
1228 #undef TARGET_ASM_CLOSE_PAREN
1229 #define TARGET_ASM_CLOSE_PAREN ""
1230
1231 #undef TARGET_ASM_ALIGNED_HI_OP
1232 #define TARGET_ASM_ALIGNED_HI_OP ASM_SHORT
1233 #undef TARGET_ASM_ALIGNED_SI_OP
1234 #define TARGET_ASM_ALIGNED_SI_OP ASM_LONG
1235 #ifdef ASM_QUAD
1236 #undef TARGET_ASM_ALIGNED_DI_OP
1237 #define TARGET_ASM_ALIGNED_DI_OP ASM_QUAD
1238 #endif
1239
1240 #undef TARGET_ASM_UNALIGNED_HI_OP
1241 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
1242 #undef TARGET_ASM_UNALIGNED_SI_OP
1243 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
1244 #undef TARGET_ASM_UNALIGNED_DI_OP
1245 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
1246
1247 #undef TARGET_SCHED_ADJUST_COST
1248 #define TARGET_SCHED_ADJUST_COST ix86_adjust_cost
1249 #undef TARGET_SCHED_ISSUE_RATE
1250 #define TARGET_SCHED_ISSUE_RATE ix86_issue_rate
1251 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1252 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
1253   ia32_multipass_dfa_lookahead
1254
1255 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1256 #define TARGET_FUNCTION_OK_FOR_SIBCALL ix86_function_ok_for_sibcall
1257
1258 #ifdef HAVE_AS_TLS
1259 #undef TARGET_HAVE_TLS
1260 #define TARGET_HAVE_TLS true
1261 #endif
1262 #undef TARGET_CANNOT_FORCE_CONST_MEM
1263 #define TARGET_CANNOT_FORCE_CONST_MEM ix86_cannot_force_const_mem
1264 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1265 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_rtx_true
1266
1267 #undef TARGET_DELEGITIMIZE_ADDRESS
1268 #define TARGET_DELEGITIMIZE_ADDRESS ix86_delegitimize_address
1269
1270 #undef TARGET_MS_BITFIELD_LAYOUT_P
1271 #define TARGET_MS_BITFIELD_LAYOUT_P ix86_ms_bitfield_layout_p
1272
1273 #if TARGET_MACHO
1274 #undef TARGET_BINDS_LOCAL_P
1275 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1276 #endif
1277
1278 #undef TARGET_ASM_OUTPUT_MI_THUNK
1279 #define TARGET_ASM_OUTPUT_MI_THUNK x86_output_mi_thunk
1280 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1281 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK x86_can_output_mi_thunk
1282
1283 #undef TARGET_ASM_FILE_START
1284 #define TARGET_ASM_FILE_START x86_file_start
1285
1286 #undef TARGET_DEFAULT_TARGET_FLAGS
1287 #define TARGET_DEFAULT_TARGET_FLAGS     \
1288   (TARGET_DEFAULT                       \
1289    | TARGET_64BIT_DEFAULT               \
1290    | TARGET_SUBTARGET_DEFAULT           \
1291    | TARGET_TLS_DIRECT_SEG_REFS_DEFAULT)
1292
1293 #undef TARGET_HANDLE_OPTION
1294 #define TARGET_HANDLE_OPTION ix86_handle_option
1295
1296 #undef TARGET_RTX_COSTS
1297 #define TARGET_RTX_COSTS ix86_rtx_costs
1298 #undef TARGET_ADDRESS_COST
1299 #define TARGET_ADDRESS_COST ix86_address_cost
1300
1301 #undef TARGET_FIXED_CONDITION_CODE_REGS
1302 #define TARGET_FIXED_CONDITION_CODE_REGS ix86_fixed_condition_code_regs
1303 #undef TARGET_CC_MODES_COMPATIBLE
1304 #define TARGET_CC_MODES_COMPATIBLE ix86_cc_modes_compatible
1305
1306 #undef TARGET_MACHINE_DEPENDENT_REORG
1307 #define TARGET_MACHINE_DEPENDENT_REORG ix86_reorg
1308
1309 #undef TARGET_BUILD_BUILTIN_VA_LIST
1310 #define TARGET_BUILD_BUILTIN_VA_LIST ix86_build_builtin_va_list
1311
1312 #undef TARGET_MD_ASM_CLOBBERS
1313 #define TARGET_MD_ASM_CLOBBERS ix86_md_asm_clobbers
1314
1315 #undef TARGET_PROMOTE_PROTOTYPES
1316 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
1317 #undef TARGET_STRUCT_VALUE_RTX
1318 #define TARGET_STRUCT_VALUE_RTX ix86_struct_value_rtx
1319 #undef TARGET_SETUP_INCOMING_VARARGS
1320 #define TARGET_SETUP_INCOMING_VARARGS ix86_setup_incoming_varargs
1321 #undef TARGET_MUST_PASS_IN_STACK
1322 #define TARGET_MUST_PASS_IN_STACK ix86_must_pass_in_stack
1323 #undef TARGET_PASS_BY_REFERENCE
1324 #define TARGET_PASS_BY_REFERENCE ix86_pass_by_reference
1325 #undef TARGET_INTERNAL_ARG_POINTER
1326 #define TARGET_INTERNAL_ARG_POINTER ix86_internal_arg_pointer
1327 #undef TARGET_DWARF_HANDLE_FRAME_UNSPEC
1328 #define TARGET_DWARF_HANDLE_FRAME_UNSPEC ix86_dwarf_handle_frame_unspec
1329
1330 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1331 #define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
1332
1333 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1334 #define TARGET_SCALAR_MODE_SUPPORTED_P ix86_scalar_mode_supported_p
1335
1336 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1337 #define TARGET_VECTOR_MODE_SUPPORTED_P ix86_vector_mode_supported_p
1338
1339 #ifdef HAVE_AS_TLS
1340 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1341 #define TARGET_ASM_OUTPUT_DWARF_DTPREL i386_output_dwarf_dtprel
1342 #endif
1343
1344 #ifdef SUBTARGET_INSERT_ATTRIBUTES
1345 #undef TARGET_INSERT_ATTRIBUTES
1346 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
1347 #endif
1348
1349 #undef TARGET_MANGLE_FUNDAMENTAL_TYPE
1350 #define TARGET_MANGLE_FUNDAMENTAL_TYPE ix86_mangle_fundamental_type
1351
1352 #undef TARGET_STACK_PROTECT_FAIL
1353 #define TARGET_STACK_PROTECT_FAIL ix86_stack_protect_fail
1354
1355 #undef TARGET_FUNCTION_VALUE
1356 #define TARGET_FUNCTION_VALUE ix86_function_value
1357
1358 struct gcc_target targetm = TARGET_INITIALIZER;
1359
1360 \f
1361 /* The svr4 ABI for the i386 says that records and unions are returned
1362    in memory.  */
1363 #ifndef DEFAULT_PCC_STRUCT_RETURN
1364 #define DEFAULT_PCC_STRUCT_RETURN 1
1365 #endif
1366
1367 /* Implement TARGET_HANDLE_OPTION.  */
1368
1369 static bool
1370 ix86_handle_option (size_t code, const char *arg ATTRIBUTE_UNUSED, int value)
1371 {
1372   switch (code)
1373     {
1374     case OPT_m3dnow:
1375       if (!value)
1376         {
1377           target_flags &= ~MASK_3DNOW_A;
1378           target_flags_explicit |= MASK_3DNOW_A;
1379         }
1380       return true;
1381
1382     case OPT_mmmx:
1383       if (!value)
1384         {
1385           target_flags &= ~(MASK_3DNOW | MASK_3DNOW_A);
1386           target_flags_explicit |= MASK_3DNOW | MASK_3DNOW_A;
1387         }
1388       return true;
1389
1390     case OPT_msse:
1391       if (!value)
1392         {
1393           target_flags &= ~(MASK_SSE2 | MASK_SSE3);
1394           target_flags_explicit |= MASK_SSE2 | MASK_SSE3;
1395         }
1396       return true;
1397
1398     case OPT_msse2:
1399       if (!value)
1400         {
1401           target_flags &= ~MASK_SSE3;
1402           target_flags_explicit |= MASK_SSE3;
1403         }
1404       return true;
1405
1406     default:
1407       return true;
1408     }
1409 }
1410
1411 /* Sometimes certain combinations of command options do not make
1412    sense on a particular target machine.  You can define a macro
1413    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
1414    defined, is executed once just after all the command options have
1415    been parsed.
1416
1417    Don't use this macro to turn on various extra optimizations for
1418    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
1419
1420 void
1421 override_options (void)
1422 {
1423   int i;
1424   int ix86_tune_defaulted = 0;
1425
1426   /* Comes from final.c -- no real reason to change it.  */
1427 #define MAX_CODE_ALIGN 16
1428
1429   static struct ptt
1430     {
1431       const struct processor_costs *cost;       /* Processor costs */
1432       const int target_enable;                  /* Target flags to enable.  */
1433       const int target_disable;                 /* Target flags to disable.  */
1434       const int align_loop;                     /* Default alignments.  */
1435       const int align_loop_max_skip;
1436       const int align_jump;
1437       const int align_jump_max_skip;
1438       const int align_func;
1439     }
1440   const processor_target_table[PROCESSOR_max] =
1441     {
1442       {&i386_cost, 0, 0, 4, 3, 4, 3, 4},
1443       {&i486_cost, 0, 0, 16, 15, 16, 15, 16},
1444       {&pentium_cost, 0, 0, 16, 7, 16, 7, 16},
1445       {&pentiumpro_cost, 0, 0, 16, 15, 16, 7, 16},
1446       {&k6_cost, 0, 0, 32, 7, 32, 7, 32},
1447       {&athlon_cost, 0, 0, 16, 7, 16, 7, 16},
1448       {&pentium4_cost, 0, 0, 0, 0, 0, 0, 0},
1449       {&k8_cost, 0, 0, 16, 7, 16, 7, 16},
1450       {&nocona_cost, 0, 0, 0, 0, 0, 0, 0},
1451       {&generic32_cost, 0, 0, 16, 7, 16, 7, 16},
1452       {&generic64_cost, 0, 0, 16, 7, 16, 7, 16}
1453     };
1454
1455   static const char * const cpu_names[] = TARGET_CPU_DEFAULT_NAMES;
1456   static struct pta
1457     {
1458       const char *const name;           /* processor name or nickname.  */
1459       const enum processor_type processor;
1460       const enum pta_flags
1461         {
1462           PTA_SSE = 1,
1463           PTA_SSE2 = 2,
1464           PTA_SSE3 = 4,
1465           PTA_MMX = 8,
1466           PTA_PREFETCH_SSE = 16,
1467           PTA_3DNOW = 32,
1468           PTA_3DNOW_A = 64,
1469           PTA_64BIT = 128
1470         } flags;
1471     }
1472   const processor_alias_table[] =
1473     {
1474       {"i386", PROCESSOR_I386, 0},
1475       {"i486", PROCESSOR_I486, 0},
1476       {"i586", PROCESSOR_PENTIUM, 0},
1477       {"pentium", PROCESSOR_PENTIUM, 0},
1478       {"pentium-mmx", PROCESSOR_PENTIUM, PTA_MMX},
1479       {"winchip-c6", PROCESSOR_I486, PTA_MMX},
1480       {"winchip2", PROCESSOR_I486, PTA_MMX | PTA_3DNOW},
1481       {"c3", PROCESSOR_I486, PTA_MMX | PTA_3DNOW},
1482       {"c3-2", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_PREFETCH_SSE | PTA_SSE},
1483       {"i686", PROCESSOR_PENTIUMPRO, 0},
1484       {"pentiumpro", PROCESSOR_PENTIUMPRO, 0},
1485       {"pentium2", PROCESSOR_PENTIUMPRO, PTA_MMX},
1486       {"pentium3", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE | PTA_PREFETCH_SSE},
1487       {"pentium3m", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE | PTA_PREFETCH_SSE},
1488       {"pentium-m", PROCESSOR_PENTIUMPRO, PTA_MMX | PTA_SSE | PTA_PREFETCH_SSE | PTA_SSE2},
1489       {"pentium4", PROCESSOR_PENTIUM4, PTA_SSE | PTA_SSE2
1490                                        | PTA_MMX | PTA_PREFETCH_SSE},
1491       {"pentium4m", PROCESSOR_PENTIUM4, PTA_SSE | PTA_SSE2
1492                                         | PTA_MMX | PTA_PREFETCH_SSE},
1493       {"prescott", PROCESSOR_NOCONA, PTA_SSE | PTA_SSE2 | PTA_SSE3
1494                                         | PTA_MMX | PTA_PREFETCH_SSE},
1495       {"nocona", PROCESSOR_NOCONA, PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_64BIT
1496                                         | PTA_MMX | PTA_PREFETCH_SSE},
1497       {"k6", PROCESSOR_K6, PTA_MMX},
1498       {"k6-2", PROCESSOR_K6, PTA_MMX | PTA_3DNOW},
1499       {"k6-3", PROCESSOR_K6, PTA_MMX | PTA_3DNOW},
1500       {"athlon", PROCESSOR_ATHLON, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW
1501                                    | PTA_3DNOW_A},
1502       {"athlon-tbird", PROCESSOR_ATHLON, PTA_MMX | PTA_PREFETCH_SSE
1503                                          | PTA_3DNOW | PTA_3DNOW_A},
1504       {"athlon-4", PROCESSOR_ATHLON, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW
1505                                     | PTA_3DNOW_A | PTA_SSE},
1506       {"athlon-xp", PROCESSOR_ATHLON, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW
1507                                       | PTA_3DNOW_A | PTA_SSE},
1508       {"athlon-mp", PROCESSOR_ATHLON, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW
1509                                       | PTA_3DNOW_A | PTA_SSE},
1510       {"x86-64", PROCESSOR_K8, PTA_MMX | PTA_PREFETCH_SSE | PTA_64BIT
1511                                | PTA_SSE | PTA_SSE2 },
1512       {"k8", PROCESSOR_K8, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW | PTA_64BIT
1513                                       | PTA_3DNOW_A | PTA_SSE | PTA_SSE2},
1514       {"opteron", PROCESSOR_K8, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW | PTA_64BIT
1515                                       | PTA_3DNOW_A | PTA_SSE | PTA_SSE2},
1516       {"athlon64", PROCESSOR_K8, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW | PTA_64BIT
1517                                       | PTA_3DNOW_A | PTA_SSE | PTA_SSE2},
1518       {"athlon-fx", PROCESSOR_K8, PTA_MMX | PTA_PREFETCH_SSE | PTA_3DNOW | PTA_64BIT
1519                                       | PTA_3DNOW_A | PTA_SSE | PTA_SSE2},
1520       {"generic32", PROCESSOR_GENERIC32, 0 /* flags are only used for -march switch.  */ },
1521       {"generic64", PROCESSOR_GENERIC64, PTA_64BIT /* flags are only used for -march switch.  */ },
1522     };
1523
1524   int const pta_size = ARRAY_SIZE (processor_alias_table);
1525
1526 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1527   SUBTARGET_OVERRIDE_OPTIONS;
1528 #endif
1529
1530   /* Set the default values for switches whose default depends on TARGET_64BIT
1531      in case they weren't overwritten by command line options.  */
1532   if (TARGET_64BIT)
1533     {
1534       if (flag_omit_frame_pointer == 2)
1535         flag_omit_frame_pointer = 1;
1536       if (flag_asynchronous_unwind_tables == 2)
1537         flag_asynchronous_unwind_tables = 1;
1538       if (flag_pcc_struct_return == 2)
1539         flag_pcc_struct_return = 0;
1540     }
1541   else
1542     {
1543       if (flag_omit_frame_pointer == 2)
1544         flag_omit_frame_pointer = 0;
1545       if (flag_asynchronous_unwind_tables == 2)
1546         flag_asynchronous_unwind_tables = 0;
1547       if (flag_pcc_struct_return == 2)
1548         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
1549     }
1550
1551   /* Need to check -mtune=generic first.  */
1552   if (ix86_tune_string)
1553     {
1554       if (!strcmp (ix86_tune_string, "generic")
1555           || !strcmp (ix86_tune_string, "i686"))
1556         {
1557           if (TARGET_64BIT)
1558             ix86_tune_string = "generic64";
1559           else
1560             ix86_tune_string = "generic32";
1561         }
1562       else if (!strncmp (ix86_tune_string, "generic", 7))
1563         error ("bad value (%s) for -mtune= switch", ix86_tune_string);
1564     }
1565   else
1566     {
1567       if (ix86_arch_string)
1568         ix86_tune_string = ix86_arch_string;
1569       if (!ix86_tune_string)
1570         {
1571           ix86_tune_string = cpu_names [TARGET_CPU_DEFAULT];
1572           ix86_tune_defaulted = 1;
1573         }
1574
1575       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
1576          need to use a sensible tune option.  */
1577       if (!strcmp (ix86_tune_string, "generic")
1578           || !strcmp (ix86_tune_string, "x86-64")
1579           || !strcmp (ix86_tune_string, "i686"))
1580         {
1581           if (TARGET_64BIT)
1582             ix86_tune_string = "generic64";
1583           else
1584             ix86_tune_string = "generic32";
1585         }
1586     }
1587   if (!strcmp (ix86_tune_string, "x86-64"))
1588     warning (OPT_Wdeprecated, "-mtune=x86-64 is deprecated.  Use -mtune=k8 or "
1589              "-mtune=generic instead as appropriate.");
1590
1591   if (!ix86_arch_string)
1592     ix86_arch_string = TARGET_64BIT ? "x86-64" : "i386";
1593   if (!strcmp (ix86_arch_string, "generic"))
1594     error ("generic CPU can be used only for -mtune= switch");
1595   if (!strncmp (ix86_arch_string, "generic", 7))
1596     error ("bad value (%s) for -march= switch", ix86_arch_string);
1597
1598   if (ix86_cmodel_string != 0)
1599     {
1600       if (!strcmp (ix86_cmodel_string, "small"))
1601         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
1602       else if (!strcmp (ix86_cmodel_string, "medium"))
1603         ix86_cmodel = flag_pic ? CM_MEDIUM_PIC : CM_MEDIUM;
1604       else if (flag_pic)
1605         sorry ("code model %s not supported in PIC mode", ix86_cmodel_string);
1606       else if (!strcmp (ix86_cmodel_string, "32"))
1607         ix86_cmodel = CM_32;
1608       else if (!strcmp (ix86_cmodel_string, "kernel") && !flag_pic)
1609         ix86_cmodel = CM_KERNEL;
1610       else if (!strcmp (ix86_cmodel_string, "large") && !flag_pic)
1611         ix86_cmodel = CM_LARGE;
1612       else
1613         error ("bad value (%s) for -mcmodel= switch", ix86_cmodel_string);
1614     }
1615   else
1616     {
1617       ix86_cmodel = CM_32;
1618       if (TARGET_64BIT)
1619         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
1620     }
1621   if (ix86_asm_string != 0)
1622     {
1623       if (! TARGET_MACHO
1624           && !strcmp (ix86_asm_string, "intel"))
1625         ix86_asm_dialect = ASM_INTEL;
1626       else if (!strcmp (ix86_asm_string, "att"))
1627         ix86_asm_dialect = ASM_ATT;
1628       else
1629         error ("bad value (%s) for -masm= switch", ix86_asm_string);
1630     }
1631   if ((TARGET_64BIT == 0) != (ix86_cmodel == CM_32))
1632     error ("code model %qs not supported in the %s bit mode",
1633            ix86_cmodel_string, TARGET_64BIT ? "64" : "32");
1634   if (ix86_cmodel == CM_LARGE)
1635     sorry ("code model %<large%> not supported yet");
1636   if ((TARGET_64BIT != 0) != ((target_flags & MASK_64BIT) != 0))
1637     sorry ("%i-bit mode not compiled in",
1638            (target_flags & MASK_64BIT) ? 64 : 32);
1639
1640   for (i = 0; i < pta_size; i++)
1641     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
1642       {
1643         ix86_arch = processor_alias_table[i].processor;
1644         /* Default cpu tuning to the architecture.  */
1645         ix86_tune = ix86_arch;
1646         if (processor_alias_table[i].flags & PTA_MMX
1647             && !(target_flags_explicit & MASK_MMX))
1648           target_flags |= MASK_MMX;
1649         if (processor_alias_table[i].flags & PTA_3DNOW
1650             && !(target_flags_explicit & MASK_3DNOW))
1651           target_flags |= MASK_3DNOW;
1652         if (processor_alias_table[i].flags & PTA_3DNOW_A
1653             && !(target_flags_explicit & MASK_3DNOW_A))
1654           target_flags |= MASK_3DNOW_A;
1655         if (processor_alias_table[i].flags & PTA_SSE
1656             && !(target_flags_explicit & MASK_SSE))
1657           target_flags |= MASK_SSE;
1658         if (processor_alias_table[i].flags & PTA_SSE2
1659             && !(target_flags_explicit & MASK_SSE2))
1660           target_flags |= MASK_SSE2;
1661         if (processor_alias_table[i].flags & PTA_SSE3
1662             && !(target_flags_explicit & MASK_SSE3))
1663           target_flags |= MASK_SSE3;
1664         if (processor_alias_table[i].flags & PTA_PREFETCH_SSE)
1665           x86_prefetch_sse = true;
1666         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
1667           error ("CPU you selected does not support x86-64 "
1668                  "instruction set");
1669         break;
1670       }
1671
1672   if (i == pta_size)
1673     error ("bad value (%s) for -march= switch", ix86_arch_string);
1674
1675   for (i = 0; i < pta_size; i++)
1676     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
1677       {
1678         ix86_tune = processor_alias_table[i].processor;
1679         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
1680           {
1681             if (ix86_tune_defaulted)
1682               {
1683                 ix86_tune_string = "x86-64";
1684                 for (i = 0; i < pta_size; i++)
1685                   if (! strcmp (ix86_tune_string,
1686                                 processor_alias_table[i].name))
1687                     break;
1688                 ix86_tune = processor_alias_table[i].processor;
1689               }
1690             else
1691               error ("CPU you selected does not support x86-64 "
1692                      "instruction set");
1693           }
1694         /* Intel CPUs have always interpreted SSE prefetch instructions as
1695            NOPs; so, we can enable SSE prefetch instructions even when
1696            -mtune (rather than -march) points us to a processor that has them.
1697            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
1698            higher processors.  */
1699         if (TARGET_CMOVE && (processor_alias_table[i].flags & PTA_PREFETCH_SSE))
1700           x86_prefetch_sse = true;
1701         break;
1702       }
1703   if (i == pta_size)
1704     error ("bad value (%s) for -mtune= switch", ix86_tune_string);
1705
1706   if (optimize_size)
1707     ix86_cost = &size_cost;
1708   else
1709     ix86_cost = processor_target_table[ix86_tune].cost;
1710   target_flags |= processor_target_table[ix86_tune].target_enable;
1711   target_flags &= ~processor_target_table[ix86_tune].target_disable;
1712
1713   /* Arrange to set up i386_stack_locals for all functions.  */
1714   init_machine_status = ix86_init_machine_status;
1715
1716   /* Validate -mregparm= value.  */
1717   if (ix86_regparm_string)
1718     {
1719       i = atoi (ix86_regparm_string);
1720       if (i < 0 || i > REGPARM_MAX)
1721         error ("-mregparm=%d is not between 0 and %d", i, REGPARM_MAX);
1722       else
1723         ix86_regparm = i;
1724     }
1725   else
1726    if (TARGET_64BIT)
1727      ix86_regparm = REGPARM_MAX;
1728
1729   /* If the user has provided any of the -malign-* options,
1730      warn and use that value only if -falign-* is not set.
1731      Remove this code in GCC 3.2 or later.  */
1732   if (ix86_align_loops_string)
1733     {
1734       warning (0, "-malign-loops is obsolete, use -falign-loops");
1735       if (align_loops == 0)
1736         {
1737           i = atoi (ix86_align_loops_string);
1738           if (i < 0 || i > MAX_CODE_ALIGN)
1739             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
1740           else
1741             align_loops = 1 << i;
1742         }
1743     }
1744
1745   if (ix86_align_jumps_string)
1746     {
1747       warning (0, "-malign-jumps is obsolete, use -falign-jumps");
1748       if (align_jumps == 0)
1749         {
1750           i = atoi (ix86_align_jumps_string);
1751           if (i < 0 || i > MAX_CODE_ALIGN)
1752             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
1753           else
1754             align_jumps = 1 << i;
1755         }
1756     }
1757
1758   if (ix86_align_funcs_string)
1759     {
1760       warning (0, "-malign-functions is obsolete, use -falign-functions");
1761       if (align_functions == 0)
1762         {
1763           i = atoi (ix86_align_funcs_string);
1764           if (i < 0 || i > MAX_CODE_ALIGN)
1765             error ("-malign-loops=%d is not between 0 and %d", i, MAX_CODE_ALIGN);
1766           else
1767             align_functions = 1 << i;
1768         }
1769     }
1770
1771   /* Default align_* from the processor table.  */
1772   if (align_loops == 0)
1773     {
1774       align_loops = processor_target_table[ix86_tune].align_loop;
1775       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
1776     }
1777   if (align_jumps == 0)
1778     {
1779       align_jumps = processor_target_table[ix86_tune].align_jump;
1780       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
1781     }
1782   if (align_functions == 0)
1783     {
1784       align_functions = processor_target_table[ix86_tune].align_func;
1785     }
1786
1787   /* Validate -mpreferred-stack-boundary= value, or provide default.
1788      The default of 128 bits is for Pentium III's SSE __m128, but we
1789      don't want additional code to keep the stack aligned when
1790      optimizing for code size.  */
1791   ix86_preferred_stack_boundary = ((TARGET_64BIT || TARGET_MACHO || !optimize_size)
1792                                    ? 128 : 32);
1793   if (ix86_preferred_stack_boundary_string)
1794     {
1795       i = atoi (ix86_preferred_stack_boundary_string);
1796       if (i < (TARGET_64BIT ? 4 : 2) || i > 12)
1797         error ("-mpreferred-stack-boundary=%d is not between %d and 12", i,
1798                TARGET_64BIT ? 4 : 2);
1799       else
1800         ix86_preferred_stack_boundary = (1 << i) * BITS_PER_UNIT;
1801     }
1802
1803   /* Validate -mbranch-cost= value, or provide default.  */
1804   ix86_branch_cost = ix86_cost->branch_cost;
1805   if (ix86_branch_cost_string)
1806     {
1807       i = atoi (ix86_branch_cost_string);
1808       if (i < 0 || i > 5)
1809         error ("-mbranch-cost=%d is not between 0 and 5", i);
1810       else
1811         ix86_branch_cost = i;
1812     }
1813   if (ix86_section_threshold_string)
1814     {
1815       i = atoi (ix86_section_threshold_string);
1816       if (i < 0)
1817         error ("-mlarge-data-threshold=%d is negative", i);
1818       else
1819         ix86_section_threshold = i;
1820     }
1821
1822   if (ix86_tls_dialect_string)
1823     {
1824       if (strcmp (ix86_tls_dialect_string, "gnu") == 0)
1825         ix86_tls_dialect = TLS_DIALECT_GNU;
1826       else if (strcmp (ix86_tls_dialect_string, "gnu2") == 0)
1827         ix86_tls_dialect = TLS_DIALECT_GNU2;
1828       else if (strcmp (ix86_tls_dialect_string, "sun") == 0)
1829         ix86_tls_dialect = TLS_DIALECT_SUN;
1830       else
1831         error ("bad value (%s) for -mtls-dialect= switch",
1832                ix86_tls_dialect_string);
1833     }
1834
1835   /* Keep nonleaf frame pointers.  */
1836   if (flag_omit_frame_pointer)
1837     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
1838   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
1839     flag_omit_frame_pointer = 1;
1840
1841   /* If we're doing fast math, we don't care about comparison order
1842      wrt NaNs.  This lets us use a shorter comparison sequence.  */
1843   if (flag_unsafe_math_optimizations)
1844     target_flags &= ~MASK_IEEE_FP;
1845
1846   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
1847      since the insns won't need emulation.  */
1848   if (x86_arch_always_fancy_math_387 & (1 << ix86_arch))
1849     target_flags &= ~MASK_NO_FANCY_MATH_387;
1850
1851   /* Likewise, if the target doesn't have a 387, or we've specified
1852      software floating point, don't use 387 inline intrinsics.  */
1853   if (!TARGET_80387)
1854     target_flags |= MASK_NO_FANCY_MATH_387;
1855
1856   /* Turn on SSE2 builtins for -msse3.  */
1857   if (TARGET_SSE3)
1858     target_flags |= MASK_SSE2;
1859
1860   /* Turn on SSE builtins for -msse2.  */
1861   if (TARGET_SSE2)
1862     target_flags |= MASK_SSE;
1863
1864   /* Turn on MMX builtins for -msse.  */
1865   if (TARGET_SSE)
1866     {
1867       target_flags |= MASK_MMX & ~target_flags_explicit;
1868       x86_prefetch_sse = true;
1869     }
1870
1871   /* Turn on MMX builtins for 3Dnow.  */
1872   if (TARGET_3DNOW)
1873     target_flags |= MASK_MMX;
1874
1875   if (TARGET_64BIT)
1876     {
1877       if (TARGET_ALIGN_DOUBLE)
1878         error ("-malign-double makes no sense in the 64bit mode");
1879       if (TARGET_RTD)
1880         error ("-mrtd calling convention not supported in the 64bit mode");
1881
1882       /* Enable by default the SSE and MMX builtins.  Do allow the user to
1883          explicitly disable any of these.  In particular, disabling SSE and
1884          MMX for kernel code is extremely useful.  */
1885       target_flags
1886         |= ((MASK_SSE2 | MASK_SSE | MASK_MMX | MASK_128BIT_LONG_DOUBLE)
1887             & ~target_flags_explicit);
1888      }
1889   else
1890     {
1891       /* i386 ABI does not specify red zone.  It still makes sense to use it
1892          when programmer takes care to stack from being destroyed.  */
1893       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
1894         target_flags |= MASK_NO_RED_ZONE;
1895     }
1896
1897   /* Accept -msseregparm only if at least SSE support is enabled.  */
1898   if (TARGET_SSEREGPARM
1899       && ! TARGET_SSE)
1900     error ("-msseregparm used without SSE enabled");
1901
1902   /* Accept -msselibm only if at least SSE support is enabled.  */
1903   if (TARGET_SSELIBM
1904       && ! TARGET_SSE2)
1905     error ("-msselibm used without SSE2 enabled");
1906
1907   /* Ignore -msselibm on 64bit targets.  */
1908   if (TARGET_SSELIBM
1909       && TARGET_64BIT)
1910     error ("-msselibm used on a 64bit target");
1911
1912   ix86_fpmath = TARGET_FPMATH_DEFAULT;
1913
1914   if (ix86_fpmath_string != 0)
1915     {
1916       if (! strcmp (ix86_fpmath_string, "387"))
1917         ix86_fpmath = FPMATH_387;
1918       else if (! strcmp (ix86_fpmath_string, "sse"))
1919         {
1920           if (!TARGET_SSE)
1921             {
1922               warning (0, "SSE instruction set disabled, using 387 arithmetics");
1923               ix86_fpmath = FPMATH_387;
1924             }
1925           else
1926             ix86_fpmath = FPMATH_SSE;
1927         }
1928       else if (! strcmp (ix86_fpmath_string, "387,sse")
1929                || ! strcmp (ix86_fpmath_string, "sse,387"))
1930         {
1931           if (!TARGET_SSE)
1932             {
1933               warning (0, "SSE instruction set disabled, using 387 arithmetics");
1934               ix86_fpmath = FPMATH_387;
1935             }
1936           else if (!TARGET_80387)
1937             {
1938               warning (0, "387 instruction set disabled, using SSE arithmetics");
1939               ix86_fpmath = FPMATH_SSE;
1940             }
1941           else
1942             ix86_fpmath = FPMATH_SSE | FPMATH_387;
1943         }
1944       else
1945         error ("bad value (%s) for -mfpmath= switch", ix86_fpmath_string);
1946     }
1947
1948   /* If the i387 is disabled, then do not return values in it. */
1949   if (!TARGET_80387)
1950     target_flags &= ~MASK_FLOAT_RETURNS;
1951
1952   if ((x86_accumulate_outgoing_args & TUNEMASK)
1953       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
1954       && !optimize_size)
1955     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
1956
1957   /* ??? Unwind info is not correct around the CFG unless either a frame
1958      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
1959      unwind info generation to be aware of the CFG and propagating states
1960      around edges.  */
1961   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
1962        || flag_exceptions || flag_non_call_exceptions)
1963       && flag_omit_frame_pointer
1964       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
1965     {
1966       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
1967         warning (0, "unwind tables currently require either a frame pointer "
1968                  "or -maccumulate-outgoing-args for correctness");
1969       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
1970     }
1971
1972   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
1973   {
1974     char *p;
1975     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
1976     p = strchr (internal_label_prefix, 'X');
1977     internal_label_prefix_len = p - internal_label_prefix;
1978     *p = '\0';
1979   }
1980
1981   /* When scheduling description is not available, disable scheduler pass
1982      so it won't slow down the compilation and make x87 code slower.  */
1983   if (!TARGET_SCHEDULE)
1984     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
1985 }
1986 \f
1987 /* switch to the appropriate section for output of DECL.
1988    DECL is either a `VAR_DECL' node or a constant of some sort.
1989    RELOC indicates whether forming the initial value of DECL requires
1990    link-time relocations.  */
1991
1992 static section *
1993 x86_64_elf_select_section (tree decl, int reloc,
1994                            unsigned HOST_WIDE_INT align)
1995 {
1996   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
1997       && ix86_in_large_data_p (decl))
1998     {
1999       const char *sname = NULL;
2000       unsigned int flags = SECTION_WRITE;
2001       switch (categorize_decl_for_section (decl, reloc, flag_pic))
2002         {
2003         case SECCAT_DATA:
2004           sname = ".ldata";
2005           break;
2006         case SECCAT_DATA_REL:
2007           sname = ".ldata.rel";
2008           break;
2009         case SECCAT_DATA_REL_LOCAL:
2010           sname = ".ldata.rel.local";
2011           break;
2012         case SECCAT_DATA_REL_RO:
2013           sname = ".ldata.rel.ro";
2014           break;
2015         case SECCAT_DATA_REL_RO_LOCAL:
2016           sname = ".ldata.rel.ro.local";
2017           break;
2018         case SECCAT_BSS:
2019           sname = ".lbss";
2020           flags |= SECTION_BSS;
2021           break;
2022         case SECCAT_RODATA:
2023         case SECCAT_RODATA_MERGE_STR:
2024         case SECCAT_RODATA_MERGE_STR_INIT:
2025         case SECCAT_RODATA_MERGE_CONST:
2026           sname = ".lrodata";
2027           flags = 0;
2028           break;
2029         case SECCAT_SRODATA:
2030         case SECCAT_SDATA:
2031         case SECCAT_SBSS:
2032           gcc_unreachable ();
2033         case SECCAT_TEXT:
2034         case SECCAT_TDATA:
2035         case SECCAT_TBSS:
2036           /* We don't split these for medium model.  Place them into
2037              default sections and hope for best.  */
2038           break;
2039         }
2040       if (sname)
2041         {
2042           /* We might get called with string constants, but get_named_section
2043              doesn't like them as they are not DECLs.  Also, we need to set
2044              flags in that case.  */
2045           if (!DECL_P (decl))
2046             return get_section (sname, flags, NULL);
2047           return get_named_section (decl, sname, reloc);
2048         }
2049     }
2050   return default_elf_select_section (decl, reloc, align);
2051 }
2052
2053 /* Build up a unique section name, expressed as a
2054    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
2055    RELOC indicates whether the initial value of EXP requires
2056    link-time relocations.  */
2057
2058 static void
2059 x86_64_elf_unique_section (tree decl, int reloc)
2060 {
2061   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
2062       && ix86_in_large_data_p (decl))
2063     {
2064       const char *prefix = NULL;
2065       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
2066       bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
2067
2068       switch (categorize_decl_for_section (decl, reloc, flag_pic))
2069         {
2070         case SECCAT_DATA:
2071         case SECCAT_DATA_REL:
2072         case SECCAT_DATA_REL_LOCAL:
2073         case SECCAT_DATA_REL_RO:
2074         case SECCAT_DATA_REL_RO_LOCAL:
2075           prefix = one_only ? ".gnu.linkonce.ld." : ".ldata.";
2076           break;
2077         case SECCAT_BSS:
2078           prefix = one_only ? ".gnu.linkonce.lb." : ".lbss.";
2079           break;
2080         case SECCAT_RODATA:
2081         case SECCAT_RODATA_MERGE_STR:
2082         case SECCAT_RODATA_MERGE_STR_INIT:
2083         case SECCAT_RODATA_MERGE_CONST:
2084           prefix = one_only ? ".gnu.linkonce.lr." : ".lrodata.";
2085           break;
2086         case SECCAT_SRODATA:
2087         case SECCAT_SDATA:
2088         case SECCAT_SBSS:
2089           gcc_unreachable ();
2090         case SECCAT_TEXT:
2091         case SECCAT_TDATA:
2092         case SECCAT_TBSS:
2093           /* We don't split these for medium model.  Place them into
2094              default sections and hope for best.  */
2095           break;
2096         }
2097       if (prefix)
2098         {
2099           const char *name;
2100           size_t nlen, plen;
2101           char *string;
2102           plen = strlen (prefix);
2103
2104           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2105           name = targetm.strip_name_encoding (name);
2106           nlen = strlen (name);
2107
2108           string = alloca (nlen + plen + 1);
2109           memcpy (string, prefix, plen);
2110           memcpy (string + plen, name, nlen + 1);
2111
2112           DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
2113           return;
2114         }
2115     }
2116   default_unique_section (decl, reloc);
2117 }
2118
2119 #ifdef COMMON_ASM_OP
2120 /* This says how to output assembler code to declare an
2121    uninitialized external linkage data object.
2122
2123    For medium model x86-64 we need to use .largecomm opcode for
2124    large objects.  */
2125 void
2126 x86_elf_aligned_common (FILE *file,
2127                         const char *name, unsigned HOST_WIDE_INT size,
2128                         int align)
2129 {
2130   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
2131       && size > (unsigned int)ix86_section_threshold)
2132     fprintf (file, ".largecomm\t");
2133   else
2134     fprintf (file, "%s", COMMON_ASM_OP);
2135   assemble_name (file, name);
2136   fprintf (file, ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",
2137            size, align / BITS_PER_UNIT);
2138 }
2139
2140 /* Utility function for targets to use in implementing
2141    ASM_OUTPUT_ALIGNED_BSS.  */
2142
2143 void
2144 x86_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
2145                         const char *name, unsigned HOST_WIDE_INT size,
2146                         int align)
2147 {
2148   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
2149       && size > (unsigned int)ix86_section_threshold)
2150     switch_to_section (get_named_section (decl, ".lbss", 0));
2151   else
2152     switch_to_section (bss_section);
2153   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
2154 #ifdef ASM_DECLARE_OBJECT_NAME
2155   last_assemble_variable_decl = decl;
2156   ASM_DECLARE_OBJECT_NAME (file, name, decl);
2157 #else
2158   /* Standard thing is just output label for the object.  */
2159   ASM_OUTPUT_LABEL (file, name);
2160 #endif /* ASM_DECLARE_OBJECT_NAME */
2161   ASM_OUTPUT_SKIP (file, size ? size : 1);
2162 }
2163 #endif
2164 \f
2165 void
2166 optimization_options (int level, int size ATTRIBUTE_UNUSED)
2167 {
2168   /* For -O2 and beyond, turn off -fschedule-insns by default.  It tends to
2169      make the problem with not enough registers even worse.  */
2170 #ifdef INSN_SCHEDULING
2171   if (level > 1)
2172     flag_schedule_insns = 0;
2173 #endif
2174
2175   if (TARGET_MACHO)
2176     /* The Darwin libraries never set errno, so we might as well
2177        avoid calling them when that's the only reason we would.  */
2178     flag_errno_math = 0;
2179
2180   /* The default values of these switches depend on the TARGET_64BIT
2181      that is not known at this moment.  Mark these values with 2 and
2182      let user the to override these.  In case there is no command line option
2183      specifying them, we will set the defaults in override_options.  */
2184   if (optimize >= 1)
2185     flag_omit_frame_pointer = 2;
2186   flag_pcc_struct_return = 2;
2187   flag_asynchronous_unwind_tables = 2;
2188 #ifdef SUBTARGET_OPTIMIZATION_OPTIONS
2189   SUBTARGET_OPTIMIZATION_OPTIONS;
2190 #endif
2191 }
2192 \f
2193 /* Table of valid machine attributes.  */
2194 const struct attribute_spec ix86_attribute_table[] =
2195 {
2196   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2197   /* Stdcall attribute says callee is responsible for popping arguments
2198      if they are not variable.  */
2199   { "stdcall",   0, 0, false, true,  true,  ix86_handle_cconv_attribute },
2200   /* Fastcall attribute says callee is responsible for popping arguments
2201      if they are not variable.  */
2202   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute },
2203   /* Cdecl attribute says the callee is a normal C declaration */
2204   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute },
2205   /* Regparm attribute specifies how many integer arguments are to be
2206      passed in registers.  */
2207   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute },
2208   /* Sseregparm attribute says we are using x86_64 calling conventions
2209      for FP arguments.  */
2210   { "sseregparm", 0, 0, false, true, true, ix86_handle_cconv_attribute },
2211 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
2212   { "dllimport", 0, 0, false, false, false, handle_dll_attribute },
2213   { "dllexport", 0, 0, false, false, false, handle_dll_attribute },
2214   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute },
2215 #endif
2216   { "ms_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute },
2217   { "gcc_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute },
2218 #ifdef SUBTARGET_ATTRIBUTE_TABLE
2219   SUBTARGET_ATTRIBUTE_TABLE,
2220 #endif
2221   { NULL,        0, 0, false, false, false, NULL }
2222 };
2223
2224 /* Decide whether we can make a sibling call to a function.  DECL is the
2225    declaration of the function being targeted by the call and EXP is the
2226    CALL_EXPR representing the call.  */
2227
2228 static bool
2229 ix86_function_ok_for_sibcall (tree decl, tree exp)
2230 {
2231   tree func;
2232   rtx a, b;
2233
2234   /* If we are generating position-independent code, we cannot sibcall
2235      optimize any indirect call, or a direct call to a global function,
2236      as the PLT requires %ebx be live.  */
2237   if (!TARGET_64BIT && flag_pic && (!decl || !targetm.binds_local_p (decl)))
2238     return false;
2239
2240   if (decl)
2241     func = decl;
2242   else
2243     {
2244       func = TREE_TYPE (TREE_OPERAND (exp, 0));
2245       if (POINTER_TYPE_P (func))
2246         func = TREE_TYPE (func);
2247     }
2248
2249   /* Check that the return value locations are the same.  Like
2250      if we are returning floats on the 80387 register stack, we cannot
2251      make a sibcall from a function that doesn't return a float to a
2252      function that does or, conversely, from a function that does return
2253      a float to a function that doesn't; the necessary stack adjustment
2254      would not be executed.  This is also the place we notice
2255      differences in the return value ABI.  Note that it is ok for one
2256      of the functions to have void return type as long as the return
2257      value of the other is passed in a register.  */
2258   a = ix86_function_value (TREE_TYPE (exp), func, false);
2259   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
2260                            cfun->decl, false);
2261   if (STACK_REG_P (a) || STACK_REG_P (b))
2262     {
2263       if (!rtx_equal_p (a, b))
2264         return false;
2265     }
2266   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
2267     ;
2268   else if (!rtx_equal_p (a, b))
2269     return false;
2270
2271   /* If this call is indirect, we'll need to be able to use a call-clobbered
2272      register for the address of the target function.  Make sure that all
2273      such registers are not used for passing parameters.  */
2274   if (!decl && !TARGET_64BIT)
2275     {
2276       tree type;
2277
2278       /* We're looking at the CALL_EXPR, we need the type of the function.  */
2279       type = TREE_OPERAND (exp, 0);             /* pointer expression */
2280       type = TREE_TYPE (type);                  /* pointer type */
2281       type = TREE_TYPE (type);                  /* function type */
2282
2283       if (ix86_function_regparm (type, NULL) >= 3)
2284         {
2285           /* ??? Need to count the actual number of registers to be used,
2286              not the possible number of registers.  Fix later.  */
2287           return false;
2288         }
2289     }
2290
2291 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
2292   /* Dllimport'd functions are also called indirectly.  */
2293   if (decl && DECL_DLLIMPORT_P (decl)
2294       && ix86_function_regparm (TREE_TYPE (decl), NULL) >= 3)
2295     return false;
2296 #endif
2297
2298   /* If we forced aligned the stack, then sibcalling would unalign the
2299      stack, which may break the called function.  */
2300   if (cfun->machine->force_align_arg_pointer)
2301     return false;
2302
2303   /* Otherwise okay.  That also includes certain types of indirect calls.  */
2304   return true;
2305 }
2306
2307 /* Handle "cdecl", "stdcall", "fastcall", "regparm" and "sseregparm"
2308    calling convention attributes;
2309    arguments as in struct attribute_spec.handler.  */
2310
2311 static tree
2312 ix86_handle_cconv_attribute (tree *node, tree name,
2313                                    tree args,
2314                                    int flags ATTRIBUTE_UNUSED,
2315                                    bool *no_add_attrs)
2316 {
2317   if (TREE_CODE (*node) != FUNCTION_TYPE
2318       && TREE_CODE (*node) != METHOD_TYPE
2319       && TREE_CODE (*node) != FIELD_DECL
2320       && TREE_CODE (*node) != TYPE_DECL)
2321     {
2322       warning (OPT_Wattributes, "%qs attribute only applies to functions",
2323                IDENTIFIER_POINTER (name));
2324       *no_add_attrs = true;
2325       return NULL_TREE;
2326     }
2327
2328   /* Can combine regparm with all attributes but fastcall.  */
2329   if (is_attribute_p ("regparm", name))
2330     {
2331       tree cst;
2332
2333       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
2334         {
2335           error ("fastcall and regparm attributes are not compatible");
2336         }
2337
2338       cst = TREE_VALUE (args);
2339       if (TREE_CODE (cst) != INTEGER_CST)
2340         {
2341           warning (OPT_Wattributes,
2342                    "%qs attribute requires an integer constant argument",
2343                    IDENTIFIER_POINTER (name));
2344           *no_add_attrs = true;
2345         }
2346       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
2347         {
2348           warning (OPT_Wattributes, "argument to %qs attribute larger than %d",
2349                    IDENTIFIER_POINTER (name), REGPARM_MAX);
2350           *no_add_attrs = true;
2351         }
2352
2353       return NULL_TREE;
2354     }
2355
2356   if (TARGET_64BIT)
2357     {
2358       warning (OPT_Wattributes, "%qs attribute ignored",
2359                IDENTIFIER_POINTER (name));
2360       *no_add_attrs = true;
2361       return NULL_TREE;
2362     }
2363
2364   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
2365   if (is_attribute_p ("fastcall", name))
2366     {
2367       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
2368         {
2369           error ("fastcall and cdecl attributes are not compatible");
2370         }
2371       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
2372         {
2373           error ("fastcall and stdcall attributes are not compatible");
2374         }
2375       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
2376         {
2377           error ("fastcall and regparm attributes are not compatible");
2378         }
2379     }
2380
2381   /* Can combine stdcall with fastcall (redundant), regparm and
2382      sseregparm.  */
2383   else if (is_attribute_p ("stdcall", name))
2384     {
2385       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
2386         {
2387           error ("stdcall and cdecl attributes are not compatible");
2388         }
2389       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
2390         {
2391           error ("stdcall and fastcall attributes are not compatible");
2392         }
2393     }
2394
2395   /* Can combine cdecl with regparm and sseregparm.  */
2396   else if (is_attribute_p ("cdecl", name))
2397     {
2398       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
2399         {
2400           error ("stdcall and cdecl attributes are not compatible");
2401         }
2402       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
2403         {
2404           error ("fastcall and cdecl attributes are not compatible");
2405         }
2406     }
2407
2408   /* Can combine sseregparm with all attributes.  */
2409
2410   return NULL_TREE;
2411 }
2412
2413 /* Return 0 if the attributes for two types are incompatible, 1 if they
2414    are compatible, and 2 if they are nearly compatible (which causes a
2415    warning to be generated).  */
2416
2417 static int
2418 ix86_comp_type_attributes (tree type1, tree type2)
2419 {
2420   /* Check for mismatch of non-default calling convention.  */
2421   const char *const rtdstr = TARGET_RTD ? "cdecl" : "stdcall";
2422
2423   if (TREE_CODE (type1) != FUNCTION_TYPE)
2424     return 1;
2425
2426   /* Check for mismatched fastcall/regparm types.  */
2427   if ((!lookup_attribute ("fastcall", TYPE_ATTRIBUTES (type1))
2428        != !lookup_attribute ("fastcall", TYPE_ATTRIBUTES (type2)))
2429       || (ix86_function_regparm (type1, NULL)
2430           != ix86_function_regparm (type2, NULL)))
2431     return 0;
2432
2433   /* Check for mismatched sseregparm types.  */
2434   if (!lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type1))
2435       != !lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type2)))
2436     return 0;
2437
2438   /* Check for mismatched return types (cdecl vs stdcall).  */
2439   if (!lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type1))
2440       != !lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type2)))
2441     return 0;
2442
2443   return 1;
2444 }
2445 \f
2446 /* Return the regparm value for a function with the indicated TYPE and DECL.
2447    DECL may be NULL when calling function indirectly
2448    or considering a libcall.  */
2449
2450 static int
2451 ix86_function_regparm (tree type, tree decl)
2452 {
2453   tree attr;
2454   int regparm = ix86_regparm;
2455   bool user_convention = false;
2456
2457   if (!TARGET_64BIT)
2458     {
2459       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
2460       if (attr)
2461         {
2462           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
2463           user_convention = true;
2464         }
2465
2466       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (type)))
2467         {
2468           regparm = 2;
2469           user_convention = true;
2470         }
2471
2472       /* Use register calling convention for local functions when possible.  */
2473       if (!TARGET_64BIT && !user_convention && decl
2474           && flag_unit_at_a_time && !profile_flag)
2475         {
2476           struct cgraph_local_info *i = cgraph_local_info (decl);
2477           if (i && i->local)
2478             {
2479               int local_regparm, globals = 0, regno;
2480
2481               /* Make sure no regparm register is taken by a global register
2482                  variable.  */
2483               for (local_regparm = 0; local_regparm < 3; local_regparm++)
2484                 if (global_regs[local_regparm])
2485                   break;
2486               /* We can't use regparm(3) for nested functions as these use
2487                  static chain pointer in third argument.  */
2488               if (local_regparm == 3
2489                   && decl_function_context (decl)
2490                   && !DECL_NO_STATIC_CHAIN (decl))
2491                 local_regparm = 2;
2492               /* Each global register variable increases register preassure,
2493                  so the more global reg vars there are, the smaller regparm
2494                  optimization use, unless requested by the user explicitly.  */
2495               for (regno = 0; regno < 6; regno++)
2496                 if (global_regs[regno])
2497                   globals++;
2498               local_regparm
2499                 = globals < local_regparm ? local_regparm - globals : 0;
2500
2501               if (local_regparm > regparm)
2502                 regparm = local_regparm;
2503             }
2504         }
2505     }
2506   return regparm;
2507 }
2508
2509 /* Return 1 or 2, if we can pass up to 8 SFmode (1) and DFmode (2) arguments
2510    in SSE registers for a function with the indicated TYPE and DECL.
2511    DECL may be NULL when calling function indirectly
2512    or considering a libcall.  Otherwise return 0.  */
2513
2514 static int
2515 ix86_function_sseregparm (tree type, tree decl)
2516 {
2517   /* Use SSE registers to pass SFmode and DFmode arguments if requested
2518      by the sseregparm attribute.  */
2519   if (TARGET_SSEREGPARM
2520       || (type
2521           && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
2522     {
2523       if (!TARGET_SSE)
2524         {
2525           if (decl)
2526             error ("Calling %qD with attribute sseregparm without "
2527                    "SSE/SSE2 enabled", decl);
2528           else
2529             error ("Calling %qT with attribute sseregparm without "
2530                    "SSE/SSE2 enabled", type);
2531           return 0;
2532         }
2533
2534       return 2;
2535     }
2536
2537   /* For local functions, pass SFmode (and DFmode for SSE2) arguments
2538      in SSE registers even for 32-bit mode and not just 3, but up to
2539      8 SSE arguments in registers.  */
2540   if (!TARGET_64BIT && decl
2541       && TARGET_SSE_MATH && flag_unit_at_a_time && !profile_flag)
2542     {
2543       struct cgraph_local_info *i = cgraph_local_info (decl);
2544       if (i && i->local)
2545         return TARGET_SSE2 ? 2 : 1;
2546     }
2547
2548   return 0;
2549 }
2550
2551 /* Return true if EAX is live at the start of the function.  Used by
2552    ix86_expand_prologue to determine if we need special help before
2553    calling allocate_stack_worker.  */
2554
2555 static bool
2556 ix86_eax_live_at_start_p (void)
2557 {
2558   /* Cheat.  Don't bother working forward from ix86_function_regparm
2559      to the function type to whether an actual argument is located in
2560      eax.  Instead just look at cfg info, which is still close enough
2561      to correct at this point.  This gives false positives for broken
2562      functions that might use uninitialized data that happens to be
2563      allocated in eax, but who cares?  */
2564   return REGNO_REG_SET_P (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end, 0);
2565 }
2566
2567 /* Value is the number of bytes of arguments automatically
2568    popped when returning from a subroutine call.
2569    FUNDECL is the declaration node of the function (as a tree),
2570    FUNTYPE is the data type of the function (as a tree),
2571    or for a library call it is an identifier node for the subroutine name.
2572    SIZE is the number of bytes of arguments passed on the stack.
2573
2574    On the 80386, the RTD insn may be used to pop them if the number
2575      of args is fixed, but if the number is variable then the caller
2576      must pop them all.  RTD can't be used for library calls now
2577      because the library is compiled with the Unix compiler.
2578    Use of RTD is a selectable option, since it is incompatible with
2579    standard Unix calling sequences.  If the option is not selected,
2580    the caller must always pop the args.
2581
2582    The attribute stdcall is equivalent to RTD on a per module basis.  */
2583
2584 int
2585 ix86_return_pops_args (tree fundecl, tree funtype, int size)
2586 {
2587   int rtd = TARGET_RTD && (!fundecl || TREE_CODE (fundecl) != IDENTIFIER_NODE);
2588
2589   /* Cdecl functions override -mrtd, and never pop the stack.  */
2590   if (! lookup_attribute ("cdecl", TYPE_ATTRIBUTES (funtype))) {
2591
2592     /* Stdcall and fastcall functions will pop the stack if not
2593        variable args.  */
2594     if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (funtype))
2595         || lookup_attribute ("fastcall", TYPE_ATTRIBUTES (funtype)))
2596       rtd = 1;
2597
2598     if (rtd
2599         && (TYPE_ARG_TYPES (funtype) == NULL_TREE
2600             || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (funtype)))
2601                 == void_type_node)))
2602       return size;
2603   }
2604
2605   /* Lose any fake structure return argument if it is passed on the stack.  */
2606   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
2607       && !TARGET_64BIT
2608       && !KEEP_AGGREGATE_RETURN_POINTER)
2609     {
2610       int nregs = ix86_function_regparm (funtype, fundecl);
2611
2612       if (!nregs)
2613         return GET_MODE_SIZE (Pmode);
2614     }
2615
2616   return 0;
2617 }
2618 \f
2619 /* Argument support functions.  */
2620
2621 /* Return true when register may be used to pass function parameters.  */
2622 bool
2623 ix86_function_arg_regno_p (int regno)
2624 {
2625   int i;
2626   if (!TARGET_64BIT)
2627     return (regno < REGPARM_MAX
2628             || (TARGET_MMX && MMX_REGNO_P (regno)
2629                 && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
2630             || (TARGET_SSE && SSE_REGNO_P (regno)
2631                 && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
2632
2633   if (TARGET_SSE && SSE_REGNO_P (regno)
2634       && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
2635     return true;
2636   /* RAX is used as hidden argument to va_arg functions.  */
2637   if (!regno)
2638     return true;
2639   for (i = 0; i < REGPARM_MAX; i++)
2640     if (regno == x86_64_int_parameter_registers[i])
2641       return true;
2642   return false;
2643 }
2644
2645 /* Return if we do not know how to pass TYPE solely in registers.  */
2646
2647 static bool
2648 ix86_must_pass_in_stack (enum machine_mode mode, tree type)
2649 {
2650   if (must_pass_in_stack_var_size_or_pad (mode, type))
2651     return true;
2652
2653   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
2654      The layout_type routine is crafty and tries to trick us into passing
2655      currently unsupported vector types on the stack by using TImode.  */
2656   return (!TARGET_64BIT && mode == TImode
2657           && type && TREE_CODE (type) != VECTOR_TYPE);
2658 }
2659
2660 /* Initialize a variable CUM of type CUMULATIVE_ARGS
2661    for a call to a function whose data type is FNTYPE.
2662    For a library call, FNTYPE is 0.  */
2663
2664 void
2665 init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
2666                       tree fntype,      /* tree ptr for function decl */
2667                       rtx libname,      /* SYMBOL_REF of library name or 0 */
2668                       tree fndecl)
2669 {
2670   static CUMULATIVE_ARGS zero_cum;
2671   tree param, next_param;
2672
2673   if (TARGET_DEBUG_ARG)
2674     {
2675       fprintf (stderr, "\ninit_cumulative_args (");
2676       if (fntype)
2677         fprintf (stderr, "fntype code = %s, ret code = %s",
2678                  tree_code_name[(int) TREE_CODE (fntype)],
2679                  tree_code_name[(int) TREE_CODE (TREE_TYPE (fntype))]);
2680       else
2681         fprintf (stderr, "no fntype");
2682
2683       if (libname)
2684         fprintf (stderr, ", libname = %s", XSTR (libname, 0));
2685     }
2686
2687   *cum = zero_cum;
2688
2689   /* Set up the number of registers to use for passing arguments.  */
2690   cum->nregs = ix86_regparm;
2691   if (TARGET_SSE)
2692     cum->sse_nregs = SSE_REGPARM_MAX;
2693   if (TARGET_MMX)
2694     cum->mmx_nregs = MMX_REGPARM_MAX;
2695   cum->warn_sse = true;
2696   cum->warn_mmx = true;
2697   cum->maybe_vaarg = false;
2698
2699   /* Use ecx and edx registers if function has fastcall attribute,
2700      else look for regparm information.  */
2701   if (fntype && !TARGET_64BIT)
2702     {
2703       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)))
2704         {
2705           cum->nregs = 2;
2706           cum->fastcall = 1;
2707         }
2708       else
2709         cum->nregs = ix86_function_regparm (fntype, fndecl);
2710     }
2711
2712   /* Set up the number of SSE registers used for passing SFmode
2713      and DFmode arguments.  Warn for mismatching ABI.  */
2714   cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl);
2715
2716   /* Determine if this function has variable arguments.  This is
2717      indicated by the last argument being 'void_type_mode' if there
2718      are no variable arguments.  If there are variable arguments, then
2719      we won't pass anything in registers in 32-bit mode. */
2720
2721   if (cum->nregs || cum->mmx_nregs || cum->sse_nregs)
2722     {
2723       for (param = (fntype) ? TYPE_ARG_TYPES (fntype) : 0;
2724            param != 0; param = next_param)
2725         {
2726           next_param = TREE_CHAIN (param);
2727           if (next_param == 0 && TREE_VALUE (param) != void_type_node)
2728             {
2729               if (!TARGET_64BIT)
2730                 {
2731                   cum->nregs = 0;
2732                   cum->sse_nregs = 0;
2733                   cum->mmx_nregs = 0;
2734                   cum->warn_sse = 0;
2735                   cum->warn_mmx = 0;
2736                   cum->fastcall = 0;
2737                   cum->float_in_sse = 0;
2738                 }
2739               cum->maybe_vaarg = true;
2740             }
2741         }
2742     }
2743   if ((!fntype && !libname)
2744       || (fntype && !TYPE_ARG_TYPES (fntype)))
2745     cum->maybe_vaarg = true;
2746
2747   if (TARGET_DEBUG_ARG)
2748     fprintf (stderr, ", nregs=%d )\n", cum->nregs);
2749
2750   return;
2751 }
2752
2753 /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
2754    But in the case of vector types, it is some vector mode.
2755
2756    When we have only some of our vector isa extensions enabled, then there
2757    are some modes for which vector_mode_supported_p is false.  For these
2758    modes, the generic vector support in gcc will choose some non-vector mode
2759    in order to implement the type.  By computing the natural mode, we'll 
2760    select the proper ABI location for the operand and not depend on whatever
2761    the middle-end decides to do with these vector types.  */
2762
2763 static enum machine_mode
2764 type_natural_mode (tree type)
2765 {
2766   enum machine_mode mode = TYPE_MODE (type);
2767
2768   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
2769     {
2770       HOST_WIDE_INT size = int_size_in_bytes (type);
2771       if ((size == 8 || size == 16)
2772           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
2773           && TYPE_VECTOR_SUBPARTS (type) > 1)
2774         {
2775           enum machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
2776
2777           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
2778             mode = MIN_MODE_VECTOR_FLOAT;
2779           else
2780             mode = MIN_MODE_VECTOR_INT;
2781
2782           /* Get the mode which has this inner mode and number of units.  */
2783           for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2784             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
2785                 && GET_MODE_INNER (mode) == innermode)
2786               return mode;
2787
2788           gcc_unreachable ();
2789         }
2790     }
2791
2792   return mode;
2793 }
2794
2795 /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
2796    this may not agree with the mode that the type system has chosen for the
2797    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
2798    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
2799
2800 static rtx
2801 gen_reg_or_parallel (enum machine_mode mode, enum machine_mode orig_mode,
2802                      unsigned int regno)
2803 {
2804   rtx tmp;
2805
2806   if (orig_mode != BLKmode)
2807     tmp = gen_rtx_REG (orig_mode, regno);
2808   else
2809     {
2810       tmp = gen_rtx_REG (mode, regno);
2811       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
2812       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
2813     }
2814
2815   return tmp;
2816 }
2817
2818 /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
2819    of this code is to classify each 8bytes of incoming argument by the register
2820    class and assign registers accordingly.  */
2821
2822 /* Return the union class of CLASS1 and CLASS2.
2823    See the x86-64 PS ABI for details.  */
2824
2825 static enum x86_64_reg_class
2826 merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
2827 {
2828   /* Rule #1: If both classes are equal, this is the resulting class.  */
2829   if (class1 == class2)
2830     return class1;
2831
2832   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
2833      the other class.  */
2834   if (class1 == X86_64_NO_CLASS)
2835     return class2;
2836   if (class2 == X86_64_NO_CLASS)
2837     return class1;
2838
2839   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
2840   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
2841     return X86_64_MEMORY_CLASS;
2842
2843   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
2844   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
2845       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
2846     return X86_64_INTEGERSI_CLASS;
2847   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
2848       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
2849     return X86_64_INTEGER_CLASS;
2850
2851   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
2852      MEMORY is used.  */
2853   if (class1 == X86_64_X87_CLASS
2854       || class1 == X86_64_X87UP_CLASS
2855       || class1 == X86_64_COMPLEX_X87_CLASS
2856       || class2 == X86_64_X87_CLASS
2857       || class2 == X86_64_X87UP_CLASS
2858       || class2 == X86_64_COMPLEX_X87_CLASS)
2859     return X86_64_MEMORY_CLASS;
2860
2861   /* Rule #6: Otherwise class SSE is used.  */
2862   return X86_64_SSE_CLASS;
2863 }
2864
2865 /* Classify the argument of type TYPE and mode MODE.
2866    CLASSES will be filled by the register class used to pass each word
2867    of the operand.  The number of words is returned.  In case the parameter
2868    should be passed in memory, 0 is returned. As a special case for zero
2869    sized containers, classes[0] will be NO_CLASS and 1 is returned.
2870
2871    BIT_OFFSET is used internally for handling records and specifies offset
2872    of the offset in bits modulo 256 to avoid overflow cases.
2873
2874    See the x86-64 PS ABI for details.
2875 */
2876
2877 static int
2878 classify_argument (enum machine_mode mode, tree type,
2879                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
2880 {
2881   HOST_WIDE_INT bytes =
2882     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
2883   int words = (bytes + (bit_offset % 64) / 8 + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2884
2885   /* Variable sized entities are always passed/returned in memory.  */
2886   if (bytes < 0)
2887     return 0;
2888
2889   if (mode != VOIDmode
2890       && targetm.calls.must_pass_in_stack (mode, type))
2891     return 0;
2892
2893   if (type && AGGREGATE_TYPE_P (type))
2894     {
2895       int i;
2896       tree field;
2897       enum x86_64_reg_class subclasses[MAX_CLASSES];
2898
2899       /* On x86-64 we pass structures larger than 16 bytes on the stack.  */
2900       if (bytes > 16)
2901         return 0;
2902
2903       for (i = 0; i < words; i++)
2904         classes[i] = X86_64_NO_CLASS;
2905
2906       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
2907          signalize memory class, so handle it as special case.  */
2908       if (!words)
2909         {
2910           classes[0] = X86_64_NO_CLASS;
2911           return 1;
2912         }
2913
2914       /* Classify each field of record and merge classes.  */
2915       switch (TREE_CODE (type))
2916         {
2917         case RECORD_TYPE:
2918           /* For classes first merge in the field of the subclasses.  */
2919           if (TYPE_BINFO (type))
2920             {
2921               tree binfo, base_binfo;
2922               int basenum;
2923
2924               for (binfo = TYPE_BINFO (type), basenum = 0;
2925                    BINFO_BASE_ITERATE (binfo, basenum, base_binfo); basenum++)
2926                 {
2927                    int num;
2928                    int offset = tree_low_cst (BINFO_OFFSET (base_binfo), 0) * 8;
2929                    tree type = BINFO_TYPE (base_binfo);
2930
2931                    num = classify_argument (TYPE_MODE (type),
2932                                             type, subclasses,
2933                                             (offset + bit_offset) % 256);
2934                    if (!num)
2935                      return 0;
2936                    for (i = 0; i < num; i++)
2937                      {
2938                        int pos = (offset + (bit_offset % 64)) / 8 / 8;
2939                        classes[i + pos] =
2940                          merge_classes (subclasses[i], classes[i + pos]);
2941                      }
2942                 }
2943             }
2944           /* And now merge the fields of structure.  */
2945           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2946             {
2947               if (TREE_CODE (field) == FIELD_DECL)
2948                 {
2949                   int num;
2950
2951                   /* Bitfields are always classified as integer.  Handle them
2952                      early, since later code would consider them to be
2953                      misaligned integers.  */
2954                   if (DECL_BIT_FIELD (field))
2955                     {
2956                       for (i = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
2957                            i < ((int_bit_position (field) + (bit_offset % 64))
2958                                 + tree_low_cst (DECL_SIZE (field), 0)
2959                                 + 63) / 8 / 8; i++)
2960                         classes[i] =
2961                           merge_classes (X86_64_INTEGER_CLASS,
2962                                          classes[i]);
2963                     }
2964                   else
2965                     {
2966                       num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
2967                                                TREE_TYPE (field), subclasses,
2968                                                (int_bit_position (field)
2969                                                 + bit_offset) % 256);
2970                       if (!num)
2971                         return 0;
2972                       for (i = 0; i < num; i++)
2973                         {
2974                           int pos =
2975                             (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
2976                           classes[i + pos] =
2977                             merge_classes (subclasses[i], classes[i + pos]);
2978                         }
2979                     }
2980                 }
2981             }
2982           break;
2983
2984         case ARRAY_TYPE:
2985           /* Arrays are handled as small records.  */
2986           {
2987             int num;
2988             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
2989                                      TREE_TYPE (type), subclasses, bit_offset);
2990             if (!num)
2991               return 0;
2992
2993             /* The partial classes are now full classes.  */
2994             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
2995               subclasses[0] = X86_64_SSE_CLASS;
2996             if (subclasses[0] == X86_64_INTEGERSI_CLASS && bytes != 4)
2997               subclasses[0] = X86_64_INTEGER_CLASS;
2998             
2999             for (i = 0; i < words; i++)
3000               classes[i] = subclasses[i % num];
3001             
3002             break;
3003           }
3004         case UNION_TYPE:
3005         case QUAL_UNION_TYPE:
3006           /* Unions are similar to RECORD_TYPE but offset is always 0.
3007              */
3008
3009           /* Unions are not derived.  */
3010           gcc_assert (!TYPE_BINFO (type)
3011                       || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
3012           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3013             {
3014               if (TREE_CODE (field) == FIELD_DECL)
3015                 {
3016                   int num;
3017                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
3018                                            TREE_TYPE (field), subclasses,
3019                                            bit_offset);
3020                   if (!num)
3021                     return 0;
3022                   for (i = 0; i < num; i++)
3023                     classes[i] = merge_classes (subclasses[i], classes[i]);
3024                 }
3025             }
3026           break;
3027
3028         default:
3029           gcc_unreachable ();
3030         }
3031
3032       /* Final merger cleanup.  */
3033       for (i = 0; i < words; i++)
3034         {
3035           /* If one class is MEMORY, everything should be passed in
3036              memory.  */
3037           if (classes[i] == X86_64_MEMORY_CLASS)
3038             return 0;
3039
3040           /* The X86_64_SSEUP_CLASS should be always preceded by
3041              X86_64_SSE_CLASS.  */
3042           if (classes[i] == X86_64_SSEUP_CLASS
3043               && (i == 0 || classes[i - 1] != X86_64_SSE_CLASS))
3044             classes[i] = X86_64_SSE_CLASS;
3045
3046           /*  X86_64_X87UP_CLASS should be preceded by X86_64_X87_CLASS.  */
3047           if (classes[i] == X86_64_X87UP_CLASS
3048               && (i == 0 || classes[i - 1] != X86_64_X87_CLASS))
3049             classes[i] = X86_64_SSE_CLASS;
3050         }
3051       return words;
3052     }
3053
3054   /* Compute alignment needed.  We align all types to natural boundaries with
3055      exception of XFmode that is aligned to 64bits.  */
3056   if (mode != VOIDmode && mode != BLKmode)
3057     {
3058       int mode_alignment = GET_MODE_BITSIZE (mode);
3059
3060       if (mode == XFmode)
3061         mode_alignment = 128;
3062       else if (mode == XCmode)
3063         mode_alignment = 256;
3064       if (COMPLEX_MODE_P (mode))
3065         mode_alignment /= 2;
3066       /* Misaligned fields are always returned in memory.  */
3067       if (bit_offset % mode_alignment)
3068         return 0;
3069     }
3070
3071   /* for V1xx modes, just use the base mode */
3072   if (VECTOR_MODE_P (mode)
3073       && GET_MODE_SIZE (GET_MODE_INNER (mode)) == bytes)
3074     mode = GET_MODE_INNER (mode);
3075
3076   /* Classification of atomic types.  */
3077   switch (mode)
3078     {
3079     case SDmode:
3080     case DDmode:
3081       classes[0] = X86_64_SSE_CLASS;
3082       return 1;
3083     case TDmode:
3084       classes[0] = X86_64_SSE_CLASS;
3085       classes[1] = X86_64_SSEUP_CLASS;
3086       return 2;
3087     case DImode:
3088     case SImode:
3089     case HImode:
3090     case QImode:
3091     case CSImode:
3092     case CHImode:
3093     case CQImode:
3094       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
3095         classes[0] = X86_64_INTEGERSI_CLASS;
3096       else
3097         classes[0] = X86_64_INTEGER_CLASS;
3098       return 1;
3099     case CDImode:
3100     case TImode:
3101       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
3102       return 2;
3103     case CTImode:
3104       return 0;
3105     case SFmode:
3106       if (!(bit_offset % 64))
3107         classes[0] = X86_64_SSESF_CLASS;
3108       else
3109         classes[0] = X86_64_SSE_CLASS;
3110       return 1;
3111     case DFmode:
3112       classes[0] = X86_64_SSEDF_CLASS;
3113       return 1;
3114     case XFmode:
3115       classes[0] = X86_64_X87_CLASS;
3116       classes[1] = X86_64_X87UP_CLASS;
3117       return 2;
3118     case TFmode:
3119       classes[0] = X86_64_SSE_CLASS;
3120       classes[1] = X86_64_SSEUP_CLASS;
3121       return 2;
3122     case SCmode:
3123       classes[0] = X86_64_SSE_CLASS;
3124       return 1;
3125     case DCmode:
3126       classes[0] = X86_64_SSEDF_CLASS;
3127       classes[1] = X86_64_SSEDF_CLASS;
3128       return 2;
3129     case XCmode:
3130       classes[0] = X86_64_COMPLEX_X87_CLASS;
3131       return 1;
3132     case TCmode:
3133       /* This modes is larger than 16 bytes.  */
3134       return 0;
3135     case V4SFmode:
3136     case V4SImode:
3137     case V16QImode:
3138     case V8HImode:
3139     case V2DFmode:
3140     case V2DImode:
3141       classes[0] = X86_64_SSE_CLASS;
3142       classes[1] = X86_64_SSEUP_CLASS;
3143       return 2;
3144     case V2SFmode:
3145     case V2SImode:
3146     case V4HImode:
3147     case V8QImode:
3148       classes[0] = X86_64_SSE_CLASS;
3149       return 1;
3150     case BLKmode:
3151     case VOIDmode:
3152       return 0;
3153     default:
3154       gcc_assert (VECTOR_MODE_P (mode));
3155       
3156       if (bytes > 16)
3157         return 0;
3158       
3159       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
3160       
3161       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
3162         classes[0] = X86_64_INTEGERSI_CLASS;
3163       else
3164         classes[0] = X86_64_INTEGER_CLASS;
3165       classes[1] = X86_64_INTEGER_CLASS;
3166       return 1 + (bytes > 8);
3167     }
3168 }
3169
3170 /* Examine the argument and return set number of register required in each
3171    class.  Return 0 iff parameter should be passed in memory.  */
3172 static int
3173 examine_argument (enum machine_mode mode, tree type, int in_return,
3174                   int *int_nregs, int *sse_nregs)
3175 {
3176   enum x86_64_reg_class class[MAX_CLASSES];
3177   int n = classify_argument (mode, type, class, 0);
3178
3179   *int_nregs = 0;
3180   *sse_nregs = 0;
3181   if (!n)
3182     return 0;
3183   for (n--; n >= 0; n--)
3184     switch (class[n])
3185       {
3186       case X86_64_INTEGER_CLASS:
3187       case X86_64_INTEGERSI_CLASS:
3188         (*int_nregs)++;
3189         break;
3190       case X86_64_SSE_CLASS:
3191       case X86_64_SSESF_CLASS:
3192       case X86_64_SSEDF_CLASS:
3193         (*sse_nregs)++;
3194         break;
3195       case X86_64_NO_CLASS:
3196       case X86_64_SSEUP_CLASS:
3197         break;
3198       case X86_64_X87_CLASS:
3199       case X86_64_X87UP_CLASS:
3200         if (!in_return)
3201           return 0;
3202         break;
3203       case X86_64_COMPLEX_X87_CLASS:
3204         return in_return ? 2 : 0;
3205       case X86_64_MEMORY_CLASS:
3206         gcc_unreachable ();
3207       }
3208   return 1;
3209 }
3210
3211 /* Construct container for the argument used by GCC interface.  See
3212    FUNCTION_ARG for the detailed description.  */
3213
3214 static rtx
3215 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
3216                      tree type, int in_return, int nintregs, int nsseregs,
3217                      const int *intreg, int sse_regno)
3218 {
3219   enum machine_mode tmpmode;
3220   int bytes =
3221     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
3222   enum x86_64_reg_class class[MAX_CLASSES];
3223   int n;
3224   int i;
3225   int nexps = 0;
3226   int needed_sseregs, needed_intregs;
3227   rtx exp[MAX_CLASSES];
3228   rtx ret;
3229
3230   n = classify_argument (mode, type, class, 0);
3231   if (TARGET_DEBUG_ARG)
3232     {
3233       if (!n)
3234         fprintf (stderr, "Memory class\n");
3235       else
3236         {
3237           fprintf (stderr, "Classes:");
3238           for (i = 0; i < n; i++)
3239             {
3240               fprintf (stderr, " %s", x86_64_reg_class_name[class[i]]);
3241             }
3242            fprintf (stderr, "\n");
3243         }
3244     }
3245   if (!n)
3246     return NULL;
3247   if (!examine_argument (mode, type, in_return, &needed_intregs,
3248                          &needed_sseregs))
3249     return NULL;
3250   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
3251     return NULL;
3252
3253   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
3254      some less clueful developer tries to use floating-point anyway.  */
3255   if (needed_sseregs && !TARGET_SSE)
3256     {
3257       static bool issued_error;
3258       if (!issued_error)
3259         {
3260           issued_error = true;
3261           if (in_return)
3262             error ("SSE register return with SSE disabled");
3263           else
3264             error ("SSE register argument with SSE disabled");
3265         }
3266       return NULL;
3267     }
3268
3269   /* First construct simple cases.  Avoid SCmode, since we want to use
3270      single register to pass this type.  */
3271   if (n == 1 && mode != SCmode)
3272     switch (class[0])
3273       {
3274       case X86_64_INTEGER_CLASS:
3275       case X86_64_INTEGERSI_CLASS:
3276         return gen_rtx_REG (mode, intreg[0]);
3277       case X86_64_SSE_CLASS:
3278       case X86_64_SSESF_CLASS:
3279       case X86_64_SSEDF_CLASS:
3280         return gen_reg_or_parallel (mode, orig_mode, SSE_REGNO (sse_regno));
3281       case X86_64_X87_CLASS:
3282       case X86_64_COMPLEX_X87_CLASS:
3283         return gen_rtx_REG (mode, FIRST_STACK_REG);
3284       case X86_64_NO_CLASS:
3285         /* Zero sized array, struct or class.  */
3286         return NULL;
3287       default:
3288         gcc_unreachable ();
3289       }
3290   if (n == 2 && class[0] == X86_64_SSE_CLASS && class[1] == X86_64_SSEUP_CLASS
3291       && mode != BLKmode)
3292     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
3293   if (n == 2
3294       && class[0] == X86_64_X87_CLASS && class[1] == X86_64_X87UP_CLASS)
3295     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
3296   if (n == 2 && class[0] == X86_64_INTEGER_CLASS
3297       && class[1] == X86_64_INTEGER_CLASS
3298       && (mode == CDImode || mode == TImode || mode == TFmode)
3299       && intreg[0] + 1 == intreg[1])
3300     return gen_rtx_REG (mode, intreg[0]);
3301
3302   /* Otherwise figure out the entries of the PARALLEL.  */
3303   for (i = 0; i < n; i++)
3304     {
3305       switch (class[i])
3306         {
3307           case X86_64_NO_CLASS:
3308             break;
3309           case X86_64_INTEGER_CLASS:
3310           case X86_64_INTEGERSI_CLASS:
3311             /* Merge TImodes on aligned occasions here too.  */
3312             if (i * 8 + 8 > bytes)
3313               tmpmode = mode_for_size ((bytes - i * 8) * BITS_PER_UNIT, MODE_INT, 0);
3314             else if (class[i] == X86_64_INTEGERSI_CLASS)
3315               tmpmode = SImode;
3316             else
3317               tmpmode = DImode;
3318             /* We've requested 24 bytes we don't have mode for.  Use DImode.  */
3319             if (tmpmode == BLKmode)
3320               tmpmode = DImode;
3321             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
3322                                                gen_rtx_REG (tmpmode, *intreg),
3323                                                GEN_INT (i*8));
3324             intreg++;
3325             break;
3326           case X86_64_SSESF_CLASS:
3327             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
3328                                                gen_rtx_REG (SFmode,
3329                                                             SSE_REGNO (sse_regno)),
3330                                                GEN_INT (i*8));
3331             sse_regno++;
3332             break;
3333           case X86_64_SSEDF_CLASS:
3334             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
3335                                                gen_rtx_REG (DFmode,
3336                                                             SSE_REGNO (sse_regno)),
3337                                                GEN_INT (i*8));
3338             sse_regno++;
3339             break;
3340           case X86_64_SSE_CLASS:
3341             if (i < n - 1 && class[i + 1] == X86_64_SSEUP_CLASS)
3342               tmpmode = TImode;
3343             else
3344               tmpmode = DImode;
3345             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
3346                                                gen_rtx_REG (tmpmode,
3347                                                             SSE_REGNO (sse_regno)),
3348                                                GEN_INT (i*8));
3349             if (tmpmode == TImode)
3350               i++;
3351             sse_regno++;
3352             break;
3353           default:
3354             gcc_unreachable ();
3355         }
3356     }
3357
3358   /* Empty aligned struct, union or class.  */
3359   if (nexps == 0)
3360     return NULL;
3361
3362   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
3363   for (i = 0; i < nexps; i++)
3364     XVECEXP (ret, 0, i) = exp [i];
3365   return ret;
3366 }
3367
3368 /* Update the data in CUM to advance over an argument
3369    of mode MODE and data type TYPE.
3370    (TYPE is null for libcalls where that information may not be available.)  */
3371
3372 void
3373 function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
3374                       tree type, int named)
3375 {
3376   int bytes =
3377     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
3378   int words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3379
3380   if (type)
3381     mode = type_natural_mode (type);
3382
3383   if (TARGET_DEBUG_ARG)
3384     fprintf (stderr, "function_adv (sz=%d, wds=%2d, nregs=%d, ssenregs=%d, "
3385              "mode=%s, named=%d)\n\n",
3386              words, cum->words, cum->nregs, cum->sse_nregs,
3387              GET_MODE_NAME (mode), named);
3388
3389   if (TARGET_64BIT)
3390     {
3391       int int_nregs, sse_nregs;
3392       if (!examine_argument (mode, type, 0, &int_nregs, &sse_nregs))
3393         cum->words += words;
3394       else if (sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
3395         {
3396           cum->nregs -= int_nregs;
3397           cum->sse_nregs -= sse_nregs;
3398           cum->regno += int_nregs;
3399           cum->sse_regno += sse_nregs;
3400         }
3401       else
3402         cum->words += words;
3403     }
3404   else
3405     {
3406       switch (mode)
3407         {
3408         default:
3409           break;
3410
3411         case BLKmode:
3412           if (bytes < 0)
3413             break;
3414           /* FALLTHRU */
3415
3416         case DImode:
3417         case SImode:
3418         case HImode:
3419         case QImode:
3420           cum->words += words;
3421           cum->nregs -= words;
3422           cum->regno += words;
3423
3424           if (cum->nregs <= 0)
3425             {
3426               cum->nregs = 0;
3427               cum->regno = 0;
3428             }
3429           break;
3430
3431         case DFmode:
3432           if (cum->float_in_sse < 2)
3433             break;
3434         case SFmode:
3435           if (cum->float_in_sse < 1)
3436             break;
3437           /* FALLTHRU */
3438
3439         case TImode:
3440         case V16QImode:
3441         case V8HImode:
3442         case V4SImode:
3443         case V2DImode:
3444         case V4SFmode:
3445         case V2DFmode:
3446           if (!type || !AGGREGATE_TYPE_P (type))
3447             {
3448               cum->sse_words += words;
3449               cum->sse_nregs -= 1;
3450               cum->sse_regno += 1;
3451               if (cum->sse_nregs <= 0)
3452                 {
3453                   cum->sse_nregs = 0;
3454                   cum->sse_regno = 0;
3455                 }
3456             }
3457           break;
3458
3459         case V8QImode:
3460         case V4HImode:
3461         case V2SImode:
3462         case V2SFmode:
3463           if (!type || !AGGREGATE_TYPE_P (type))
3464             {
3465               cum->mmx_words += words;
3466               cum->mmx_nregs -= 1;
3467               cum->mmx_regno += 1;
3468               if (cum->mmx_nregs <= 0)
3469                 {
3470                   cum->mmx_nregs = 0;
3471                   cum->mmx_regno = 0;
3472                 }
3473             }
3474           break;
3475         }
3476     }
3477 }
3478
3479 /* Define where to put the arguments to a function.
3480    Value is zero to push the argument on the stack,
3481    or a hard register in which to store the argument.
3482
3483    MODE is the argument's machine mode.
3484    TYPE is the data type of the argument (as a tree).
3485     This is null for libcalls where that information may
3486     not be available.
3487    CUM is a variable of type CUMULATIVE_ARGS which gives info about
3488     the preceding args and about the function being called.
3489    NAMED is nonzero if this argument is a named parameter
3490     (otherwise it is an extra parameter matching an ellipsis).  */
3491
3492 rtx
3493 function_arg (CUMULATIVE_ARGS *cum, enum machine_mode orig_mode,
3494               tree type, int named)
3495 {
3496   enum machine_mode mode = orig_mode;
3497   rtx ret = NULL_RTX;
3498   int bytes =
3499     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
3500   int words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3501   static bool warnedsse, warnedmmx;
3502
3503   /* To simplify the code below, represent vector types with a vector mode
3504      even if MMX/SSE are not active.  */
3505   if (type && TREE_CODE (type) == VECTOR_TYPE)
3506     mode = type_natural_mode (type);
3507
3508   /* Handle a hidden AL argument containing number of registers for varargs
3509      x86-64 functions.  For i386 ABI just return constm1_rtx to avoid
3510      any AL settings.  */
3511   if (mode == VOIDmode)
3512     {
3513       if (TARGET_64BIT)
3514         return GEN_INT (cum->maybe_vaarg
3515                         ? (cum->sse_nregs < 0
3516                            ? SSE_REGPARM_MAX
3517                            : cum->sse_regno)
3518                         : -1);
3519       else
3520         return constm1_rtx;
3521     }
3522   if (TARGET_64BIT)
3523     ret = construct_container (mode, orig_mode, type, 0, cum->nregs,
3524                                cum->sse_nregs,
3525                                &x86_64_int_parameter_registers [cum->regno],
3526                                cum->sse_regno);
3527   else
3528     switch (mode)
3529       {
3530         /* For now, pass fp/complex values on the stack.  */
3531       default:
3532         break;
3533
3534       case BLKmode:
3535         if (bytes < 0)
3536           break;
3537         /* FALLTHRU */
3538       case DImode:
3539       case SImode:
3540       case HImode:
3541       case QImode:
3542         if (words <= cum->nregs)
3543           {
3544             int regno = cum->regno;</