OSDN Git Service

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