OSDN Git Service

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