OSDN Git Service

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