OSDN Git Service

PR bootstrap/51134
[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 "common/common-target.h"
49 #include "langhooks.h"
50 #include "cgraph.h"
51 #include "gimple.h"
52 #include "dwarf2.h"
53 #include "df.h"
54 #include "tm-constrs.h"
55 #include "params.h"
56 #include "cselib.h"
57 #include "debug.h"
58 #include "sched-int.h"
59 #include "sbitmap.h"
60 #include "fibheap.h"
61 #include "opts.h"
62 #include "diagnostic.h"
63
64 enum upper_128bits_state
65 {
66   unknown = 0,
67   unused,
68   used
69 };
70
71 typedef struct block_info_def
72 {
73   /* State of the upper 128bits of AVX registers at exit.  */
74   enum upper_128bits_state state;
75   /* TRUE if state of the upper 128bits of AVX registers is unchanged
76      in this block.  */
77   bool unchanged;
78   /* TRUE if block has been processed.  */
79   bool processed;
80   /* TRUE if block has been scanned.  */
81   bool scanned;
82   /* Previous state of the upper 128bits of AVX registers at entry.  */
83   enum upper_128bits_state prev;
84 } *block_info;
85
86 #define BLOCK_INFO(B)   ((block_info) (B)->aux)
87
88 enum call_avx256_state
89 {
90   /* Callee returns 256bit AVX register.  */
91   callee_return_avx256 = -1,
92   /* Callee returns and passes 256bit AVX register.  */
93   callee_return_pass_avx256,
94   /* Callee passes 256bit AVX register.  */
95   callee_pass_avx256,
96   /* Callee doesn't return nor passe 256bit AVX register, or no
97      256bit AVX register in function return.  */
98   call_no_avx256,
99   /* vzeroupper intrinsic.  */
100   vzeroupper_intrinsic
101 };
102
103 /* Check if a 256bit AVX register is referenced in stores.   */
104
105 static void
106 check_avx256_stores (rtx dest, const_rtx set, void *data)
107 {
108   if ((REG_P (dest)
109        && VALID_AVX256_REG_MODE (GET_MODE (dest)))
110       || (GET_CODE (set) == SET
111           && REG_P (SET_SRC (set))
112           && VALID_AVX256_REG_MODE (GET_MODE (SET_SRC (set)))))
113     {
114       enum upper_128bits_state *state
115         = (enum upper_128bits_state *) data;
116       *state = used;
117     }
118 }
119
120 /* Helper function for move_or_delete_vzeroupper_1.  Look for vzeroupper
121    in basic block BB.  Delete it if upper 128bit AVX registers are
122    unused.  If it isn't deleted, move it to just before a jump insn.
123
124    STATE is state of the upper 128bits of AVX registers at entry.  */
125
126 static void
127 move_or_delete_vzeroupper_2 (basic_block bb,
128                              enum upper_128bits_state state)
129 {
130   rtx insn, bb_end;
131   rtx vzeroupper_insn = NULL_RTX;
132   rtx pat;
133   int avx256;
134   bool unchanged;
135
136   if (BLOCK_INFO (bb)->unchanged)
137     {
138       if (dump_file)
139         fprintf (dump_file, " [bb %i] unchanged: upper 128bits: %d\n",
140                  bb->index, state);
141
142       BLOCK_INFO (bb)->state = state;
143       return;
144     }
145
146   if (BLOCK_INFO (bb)->scanned && BLOCK_INFO (bb)->prev == state)
147     {
148       if (dump_file)
149         fprintf (dump_file, " [bb %i] scanned: upper 128bits: %d\n",
150                  bb->index, BLOCK_INFO (bb)->state);
151       return;
152     }
153
154   BLOCK_INFO (bb)->prev = state;
155
156   if (dump_file)
157     fprintf (dump_file, " [bb %i] entry: upper 128bits: %d\n",
158              bb->index, state);
159
160   unchanged = true;
161
162   /* BB_END changes when it is deleted.  */
163   bb_end = BB_END (bb);
164   insn = BB_HEAD (bb);
165   while (insn != bb_end)
166     {
167       insn = NEXT_INSN (insn);
168
169       if (!NONDEBUG_INSN_P (insn))
170         continue;
171
172       /* Move vzeroupper before jump/call.  */
173       if (JUMP_P (insn) || CALL_P (insn))
174         {
175           if (!vzeroupper_insn)
176             continue;
177
178           if (PREV_INSN (insn) != vzeroupper_insn)
179             {
180               if (dump_file)
181                 {
182                   fprintf (dump_file, "Move vzeroupper after:\n");
183                   print_rtl_single (dump_file, PREV_INSN (insn));
184                   fprintf (dump_file, "before:\n");
185                   print_rtl_single (dump_file, insn);
186                 }
187               reorder_insns_nobb (vzeroupper_insn, vzeroupper_insn,
188                                   PREV_INSN (insn));
189             }
190           vzeroupper_insn = NULL_RTX;
191           continue;
192         }
193
194       pat = PATTERN (insn);
195
196       /* Check insn for vzeroupper intrinsic.  */
197       if (GET_CODE (pat) == UNSPEC_VOLATILE
198           && XINT (pat, 1) == UNSPECV_VZEROUPPER)
199         {
200           if (dump_file)
201             {
202               /* Found vzeroupper intrinsic.  */
203               fprintf (dump_file, "Found vzeroupper:\n");
204               print_rtl_single (dump_file, insn);
205             }
206         }
207       else
208         {
209           /* Check insn for vzeroall intrinsic.  */
210           if (GET_CODE (pat) == PARALLEL
211               && GET_CODE (XVECEXP (pat, 0, 0)) == UNSPEC_VOLATILE
212               && XINT (XVECEXP (pat, 0, 0), 1) == UNSPECV_VZEROALL)
213             {
214               state = unused;
215               unchanged = false;
216
217               /* Delete pending vzeroupper insertion.  */
218               if (vzeroupper_insn)
219                 {
220                   delete_insn (vzeroupper_insn);
221                   vzeroupper_insn = NULL_RTX;
222                 }
223             }
224           else if (state != used)
225             {
226               note_stores (pat, check_avx256_stores, &state);
227               if (state == used)
228                 unchanged = false;
229             }
230           continue;
231         }
232
233       /* Process vzeroupper intrinsic.  */
234       avx256 = INTVAL (XVECEXP (pat, 0, 0));
235
236       if (state == unused)
237         {
238           /* Since the upper 128bits are cleared, callee must not pass
239              256bit AVX register.  We only need to check if callee
240              returns 256bit AVX register.  */
241           if (avx256 == callee_return_avx256)
242             {
243               state = used;
244               unchanged = false;
245             }
246
247           /* Remove unnecessary vzeroupper since upper 128bits are
248              cleared.  */
249           if (dump_file)
250             {
251               fprintf (dump_file, "Delete redundant vzeroupper:\n");
252               print_rtl_single (dump_file, insn);
253             }
254           delete_insn (insn);
255         }
256       else
257         {
258           /* Set state to UNUSED if callee doesn't return 256bit AVX
259              register.  */
260           if (avx256 != callee_return_pass_avx256)
261             state = unused;
262
263           if (avx256 == callee_return_pass_avx256
264               || avx256 == callee_pass_avx256)
265             {
266               /* Must remove vzeroupper since callee passes in 256bit
267                  AVX register.  */
268               if (dump_file)
269                 {
270                   fprintf (dump_file, "Delete callee pass vzeroupper:\n");
271                   print_rtl_single (dump_file, insn);
272                 }
273               delete_insn (insn);
274             }
275           else
276             {
277               vzeroupper_insn = insn;
278               unchanged = false;
279             }
280         }
281     }
282
283   BLOCK_INFO (bb)->state = state;
284   BLOCK_INFO (bb)->unchanged = unchanged;
285   BLOCK_INFO (bb)->scanned = true;
286
287   if (dump_file)
288     fprintf (dump_file, " [bb %i] exit: %s: upper 128bits: %d\n",
289              bb->index, unchanged ? "unchanged" : "changed",
290              state);
291 }
292
293 /* Helper function for move_or_delete_vzeroupper.  Process vzeroupper
294    in BLOCK and check its predecessor blocks.  Treat UNKNOWN state
295    as USED if UNKNOWN_IS_UNUSED is true.  Return TRUE if the exit
296    state is changed.  */
297
298 static bool
299 move_or_delete_vzeroupper_1 (basic_block block, bool unknown_is_unused)
300 {
301   edge e;
302   edge_iterator ei;
303   enum upper_128bits_state state, old_state, new_state;
304   bool seen_unknown;
305
306   if (dump_file)
307     fprintf (dump_file, " Process [bb %i]: status: %d\n",
308              block->index, BLOCK_INFO (block)->processed);
309
310   if (BLOCK_INFO (block)->processed)
311     return false;
312
313   state = unused;
314
315   /* Check all predecessor edges of this block.  */
316   seen_unknown = false;
317   FOR_EACH_EDGE (e, ei, block->preds)
318     {
319       if (e->src == block)
320         continue;
321       switch (BLOCK_INFO (e->src)->state)
322         {
323         case unknown:
324           if (!unknown_is_unused)
325             seen_unknown = true;
326         case unused:
327           break;
328         case used:
329           state = used;
330           goto done;
331         }
332     }
333
334   if (seen_unknown)
335     state = unknown;
336
337 done:
338   old_state = BLOCK_INFO (block)->state;
339   move_or_delete_vzeroupper_2 (block, state);
340   new_state = BLOCK_INFO (block)->state;
341
342   if (state != unknown || new_state == used)
343     BLOCK_INFO (block)->processed = true;
344
345   /* Need to rescan if the upper 128bits of AVX registers are changed
346      to USED at exit.  */
347   if (new_state != old_state)
348     {
349       if (new_state == used)
350         cfun->machine->rescan_vzeroupper_p = 1;
351       return true;
352     }
353   else
354     return false;
355 }
356
357 /* Go through the instruction stream looking for vzeroupper.  Delete
358    it if upper 128bit AVX registers are unused.  If it isn't deleted,
359    move it to just before a jump insn.  */
360
361 static void
362 move_or_delete_vzeroupper (void)
363 {
364   edge e;
365   edge_iterator ei;
366   basic_block bb;
367   fibheap_t worklist, pending, fibheap_swap;
368   sbitmap visited, in_worklist, in_pending, sbitmap_swap;
369   int *bb_order;
370   int *rc_order;
371   int i;
372
373   /* Set up block info for each basic block.  */
374   alloc_aux_for_blocks (sizeof (struct block_info_def));
375
376   /* Process outgoing edges of entry point.  */
377   if (dump_file)
378     fprintf (dump_file, "Process outgoing edges of entry point\n");
379
380   FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
381     {
382       move_or_delete_vzeroupper_2 (e->dest,
383                                    cfun->machine->caller_pass_avx256_p
384                                    ? used : unused);
385       BLOCK_INFO (e->dest)->processed = true;
386     }
387
388   /* Compute reverse completion order of depth first search of the CFG
389      so that the data-flow runs faster.  */
390   rc_order = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
391   bb_order = XNEWVEC (int, last_basic_block);
392   pre_and_rev_post_order_compute (NULL, rc_order, false);
393   for (i = 0; i < n_basic_blocks - NUM_FIXED_BLOCKS; i++)
394     bb_order[rc_order[i]] = i;
395   free (rc_order);
396
397   worklist = fibheap_new ();
398   pending = fibheap_new ();
399   visited = sbitmap_alloc (last_basic_block);
400   in_worklist = sbitmap_alloc (last_basic_block);
401   in_pending = sbitmap_alloc (last_basic_block);
402   sbitmap_zero (in_worklist);
403
404   /* Don't check outgoing edges of entry point.  */
405   sbitmap_ones (in_pending);
406   FOR_EACH_BB (bb)
407     if (BLOCK_INFO (bb)->processed)
408       RESET_BIT (in_pending, bb->index);
409     else
410       {
411         move_or_delete_vzeroupper_1 (bb, false);
412         fibheap_insert (pending, bb_order[bb->index], bb);
413       }
414
415   if (dump_file)
416     fprintf (dump_file, "Check remaining basic blocks\n");
417
418   while (!fibheap_empty (pending))
419     {
420       fibheap_swap = pending;
421       pending = worklist;
422       worklist = fibheap_swap;
423       sbitmap_swap = in_pending;
424       in_pending = in_worklist;
425       in_worklist = sbitmap_swap;
426
427       sbitmap_zero (visited);
428
429       cfun->machine->rescan_vzeroupper_p = 0;
430
431       while (!fibheap_empty (worklist))
432         {
433           bb = (basic_block) fibheap_extract_min (worklist);
434           RESET_BIT (in_worklist, bb->index);
435           gcc_assert (!TEST_BIT (visited, bb->index));
436           if (!TEST_BIT (visited, bb->index))
437             {
438               edge_iterator ei;
439
440               SET_BIT (visited, bb->index);
441
442               if (move_or_delete_vzeroupper_1 (bb, false))
443                 FOR_EACH_EDGE (e, ei, bb->succs)
444                   {
445                     if (e->dest == EXIT_BLOCK_PTR
446                         || BLOCK_INFO (e->dest)->processed)
447                       continue;
448
449                     if (TEST_BIT (visited, e->dest->index))
450                       {
451                         if (!TEST_BIT (in_pending, e->dest->index))
452                           {
453                             /* Send E->DEST to next round.  */
454                             SET_BIT (in_pending, e->dest->index);
455                             fibheap_insert (pending,
456                                             bb_order[e->dest->index],
457                                             e->dest);
458                           }
459                       }
460                     else if (!TEST_BIT (in_worklist, e->dest->index))
461                       {
462                         /* Add E->DEST to current round.  */
463                         SET_BIT (in_worklist, e->dest->index);
464                         fibheap_insert (worklist, bb_order[e->dest->index],
465                                         e->dest);
466                       }
467                   }
468             }
469         }
470
471       if (!cfun->machine->rescan_vzeroupper_p)
472         break;
473     }
474
475   free (bb_order);
476   fibheap_delete (worklist);
477   fibheap_delete (pending);
478   sbitmap_free (visited);
479   sbitmap_free (in_worklist);
480   sbitmap_free (in_pending);
481
482   if (dump_file)
483     fprintf (dump_file, "Process remaining basic blocks\n");
484
485   FOR_EACH_BB (bb)
486     move_or_delete_vzeroupper_1 (bb, true);
487
488   free_aux_for_blocks ();
489 }
490
491 static rtx legitimize_dllimport_symbol (rtx, bool);
492
493 #ifndef CHECK_STACK_LIMIT
494 #define CHECK_STACK_LIMIT (-1)
495 #endif
496
497 /* Return index of given mode in mult and division cost tables.  */
498 #define MODE_INDEX(mode)                                        \
499   ((mode) == QImode ? 0                                         \
500    : (mode) == HImode ? 1                                       \
501    : (mode) == SImode ? 2                                       \
502    : (mode) == DImode ? 3                                       \
503    : 4)
504
505 /* Processor costs (relative to an add) */
506 /* We assume COSTS_N_INSNS is defined as (N)*4 and an addition is 2 bytes.  */
507 #define COSTS_N_BYTES(N) ((N) * 2)
508
509 #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall}}}
510
511 const
512 struct processor_costs ix86_size_cost = {/* costs for tuning for size */
513   COSTS_N_BYTES (2),                    /* cost of an add instruction */
514   COSTS_N_BYTES (3),                    /* cost of a lea instruction */
515   COSTS_N_BYTES (2),                    /* variable shift costs */
516   COSTS_N_BYTES (3),                    /* constant shift costs */
517   {COSTS_N_BYTES (3),                   /* cost of starting multiply for QI */
518    COSTS_N_BYTES (3),                   /*                               HI */
519    COSTS_N_BYTES (3),                   /*                               SI */
520    COSTS_N_BYTES (3),                   /*                               DI */
521    COSTS_N_BYTES (5)},                  /*                            other */
522   0,                                    /* cost of multiply per each bit set */
523   {COSTS_N_BYTES (3),                   /* cost of a divide/mod for QI */
524    COSTS_N_BYTES (3),                   /*                          HI */
525    COSTS_N_BYTES (3),                   /*                          SI */
526    COSTS_N_BYTES (3),                   /*                          DI */
527    COSTS_N_BYTES (5)},                  /*                          other */
528   COSTS_N_BYTES (3),                    /* cost of movsx */
529   COSTS_N_BYTES (3),                    /* cost of movzx */
530   0,                                    /* "large" insn */
531   2,                                    /* MOVE_RATIO */
532   2,                                 /* cost for loading QImode using movzbl */
533   {2, 2, 2},                            /* cost of loading integer registers
534                                            in QImode, HImode and SImode.
535                                            Relative to reg-reg move (2).  */
536   {2, 2, 2},                            /* cost of storing integer registers */
537   2,                                    /* cost of reg,reg fld/fst */
538   {2, 2, 2},                            /* cost of loading fp registers
539                                            in SFmode, DFmode and XFmode */
540   {2, 2, 2},                            /* cost of storing fp registers
541                                            in SFmode, DFmode and XFmode */
542   3,                                    /* cost of moving MMX register */
543   {3, 3},                               /* cost of loading MMX registers
544                                            in SImode and DImode */
545   {3, 3},                               /* cost of storing MMX registers
546                                            in SImode and DImode */
547   3,                                    /* cost of moving SSE register */
548   {3, 3, 3},                            /* cost of loading SSE registers
549                                            in SImode, DImode and TImode */
550   {3, 3, 3},                            /* cost of storing SSE registers
551                                            in SImode, DImode and TImode */
552   3,                                    /* MMX or SSE register to integer */
553   0,                                    /* size of l1 cache  */
554   0,                                    /* size of l2 cache  */
555   0,                                    /* size of prefetch block */
556   0,                                    /* number of parallel prefetches */
557   2,                                    /* Branch cost */
558   COSTS_N_BYTES (2),                    /* cost of FADD and FSUB insns.  */
559   COSTS_N_BYTES (2),                    /* cost of FMUL instruction.  */
560   COSTS_N_BYTES (2),                    /* cost of FDIV instruction.  */
561   COSTS_N_BYTES (2),                    /* cost of FABS instruction.  */
562   COSTS_N_BYTES (2),                    /* cost of FCHS instruction.  */
563   COSTS_N_BYTES (2),                    /* cost of FSQRT instruction.  */
564   {{{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
565    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
566    {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
567    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}}},
568   {{{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
569    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}},
570    {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
571    {rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}}}},
572   1,                                    /* scalar_stmt_cost.  */
573   1,                                    /* scalar load_cost.  */
574   1,                                    /* scalar_store_cost.  */
575   1,                                    /* vec_stmt_cost.  */
576   1,                                    /* vec_to_scalar_cost.  */
577   1,                                    /* scalar_to_vec_cost.  */
578   1,                                    /* vec_align_load_cost.  */
579   1,                                    /* vec_unalign_load_cost.  */
580   1,                                    /* vec_store_cost.  */
581   1,                                    /* cond_taken_branch_cost.  */
582   1,                                    /* cond_not_taken_branch_cost.  */
583 };
584
585 /* Processor costs (relative to an add) */
586 static const
587 struct processor_costs i386_cost = {    /* 386 specific costs */
588   COSTS_N_INSNS (1),                    /* cost of an add instruction */
589   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
590   COSTS_N_INSNS (3),                    /* variable shift costs */
591   COSTS_N_INSNS (2),                    /* constant shift costs */
592   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
593    COSTS_N_INSNS (6),                   /*                               HI */
594    COSTS_N_INSNS (6),                   /*                               SI */
595    COSTS_N_INSNS (6),                   /*                               DI */
596    COSTS_N_INSNS (6)},                  /*                            other */
597   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
598   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
599    COSTS_N_INSNS (23),                  /*                          HI */
600    COSTS_N_INSNS (23),                  /*                          SI */
601    COSTS_N_INSNS (23),                  /*                          DI */
602    COSTS_N_INSNS (23)},                 /*                          other */
603   COSTS_N_INSNS (3),                    /* cost of movsx */
604   COSTS_N_INSNS (2),                    /* cost of movzx */
605   15,                                   /* "large" insn */
606   3,                                    /* MOVE_RATIO */
607   4,                                 /* cost for loading QImode using movzbl */
608   {2, 4, 2},                            /* cost of loading integer registers
609                                            in QImode, HImode and SImode.
610                                            Relative to reg-reg move (2).  */
611   {2, 4, 2},                            /* cost of storing integer registers */
612   2,                                    /* cost of reg,reg fld/fst */
613   {8, 8, 8},                            /* cost of loading fp registers
614                                            in SFmode, DFmode and XFmode */
615   {8, 8, 8},                            /* cost of storing fp registers
616                                            in SFmode, DFmode and XFmode */
617   2,                                    /* cost of moving MMX register */
618   {4, 8},                               /* cost of loading MMX registers
619                                            in SImode and DImode */
620   {4, 8},                               /* cost of storing MMX registers
621                                            in SImode and DImode */
622   2,                                    /* cost of moving SSE register */
623   {4, 8, 16},                           /* cost of loading SSE registers
624                                            in SImode, DImode and TImode */
625   {4, 8, 16},                           /* cost of storing SSE registers
626                                            in SImode, DImode and TImode */
627   3,                                    /* MMX or SSE register to integer */
628   0,                                    /* size of l1 cache  */
629   0,                                    /* size of l2 cache  */
630   0,                                    /* size of prefetch block */
631   0,                                    /* number of parallel prefetches */
632   1,                                    /* Branch cost */
633   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
634   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
635   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
636   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
637   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
638   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
639   {{{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
640    DUMMY_STRINGOP_ALGS},
641    {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
642    DUMMY_STRINGOP_ALGS}},
643   {{{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
644    DUMMY_STRINGOP_ALGS},
645    {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
646    DUMMY_STRINGOP_ALGS}},
647   1,                                    /* scalar_stmt_cost.  */
648   1,                                    /* scalar load_cost.  */
649   1,                                    /* scalar_store_cost.  */
650   1,                                    /* vec_stmt_cost.  */
651   1,                                    /* vec_to_scalar_cost.  */
652   1,                                    /* scalar_to_vec_cost.  */
653   1,                                    /* vec_align_load_cost.  */
654   2,                                    /* vec_unalign_load_cost.  */
655   1,                                    /* vec_store_cost.  */
656   3,                                    /* cond_taken_branch_cost.  */
657   1,                                    /* cond_not_taken_branch_cost.  */
658 };
659
660 static const
661 struct processor_costs i486_cost = {    /* 486 specific costs */
662   COSTS_N_INSNS (1),                    /* cost of an add instruction */
663   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
664   COSTS_N_INSNS (3),                    /* variable shift costs */
665   COSTS_N_INSNS (2),                    /* constant shift costs */
666   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
667    COSTS_N_INSNS (12),                  /*                               HI */
668    COSTS_N_INSNS (12),                  /*                               SI */
669    COSTS_N_INSNS (12),                  /*                               DI */
670    COSTS_N_INSNS (12)},                 /*                            other */
671   1,                                    /* cost of multiply per each bit set */
672   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
673    COSTS_N_INSNS (40),                  /*                          HI */
674    COSTS_N_INSNS (40),                  /*                          SI */
675    COSTS_N_INSNS (40),                  /*                          DI */
676    COSTS_N_INSNS (40)},                 /*                          other */
677   COSTS_N_INSNS (3),                    /* cost of movsx */
678   COSTS_N_INSNS (2),                    /* cost of movzx */
679   15,                                   /* "large" insn */
680   3,                                    /* MOVE_RATIO */
681   4,                                 /* cost for loading QImode using movzbl */
682   {2, 4, 2},                            /* cost of loading integer registers
683                                            in QImode, HImode and SImode.
684                                            Relative to reg-reg move (2).  */
685   {2, 4, 2},                            /* cost of storing integer registers */
686   2,                                    /* cost of reg,reg fld/fst */
687   {8, 8, 8},                            /* cost of loading fp registers
688                                            in SFmode, DFmode and XFmode */
689   {8, 8, 8},                            /* cost of storing fp registers
690                                            in SFmode, DFmode and XFmode */
691   2,                                    /* cost of moving MMX register */
692   {4, 8},                               /* cost of loading MMX registers
693                                            in SImode and DImode */
694   {4, 8},                               /* cost of storing MMX registers
695                                            in SImode and DImode */
696   2,                                    /* cost of moving SSE register */
697   {4, 8, 16},                           /* cost of loading SSE registers
698                                            in SImode, DImode and TImode */
699   {4, 8, 16},                           /* cost of storing SSE registers
700                                            in SImode, DImode and TImode */
701   3,                                    /* MMX or SSE register to integer */
702   4,                                    /* size of l1 cache.  486 has 8kB cache
703                                            shared for code and data, so 4kB is
704                                            not really precise.  */
705   4,                                    /* size of l2 cache  */
706   0,                                    /* size of prefetch block */
707   0,                                    /* number of parallel prefetches */
708   1,                                    /* Branch cost */
709   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
710   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
711   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
712   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
713   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
714   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
715   {{{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
716    DUMMY_STRINGOP_ALGS},
717    {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
718    DUMMY_STRINGOP_ALGS}},
719   {{{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
720    DUMMY_STRINGOP_ALGS},
721    {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
722    DUMMY_STRINGOP_ALGS}},
723   1,                                    /* scalar_stmt_cost.  */
724   1,                                    /* scalar load_cost.  */
725   1,                                    /* scalar_store_cost.  */
726   1,                                    /* vec_stmt_cost.  */
727   1,                                    /* vec_to_scalar_cost.  */
728   1,                                    /* scalar_to_vec_cost.  */
729   1,                                    /* vec_align_load_cost.  */
730   2,                                    /* vec_unalign_load_cost.  */
731   1,                                    /* vec_store_cost.  */
732   3,                                    /* cond_taken_branch_cost.  */
733   1,                                    /* cond_not_taken_branch_cost.  */
734 };
735
736 static const
737 struct processor_costs pentium_cost = {
738   COSTS_N_INSNS (1),                    /* cost of an add instruction */
739   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
740   COSTS_N_INSNS (4),                    /* variable shift costs */
741   COSTS_N_INSNS (1),                    /* constant shift costs */
742   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
743    COSTS_N_INSNS (11),                  /*                               HI */
744    COSTS_N_INSNS (11),                  /*                               SI */
745    COSTS_N_INSNS (11),                  /*                               DI */
746    COSTS_N_INSNS (11)},                 /*                            other */
747   0,                                    /* cost of multiply per each bit set */
748   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
749    COSTS_N_INSNS (25),                  /*                          HI */
750    COSTS_N_INSNS (25),                  /*                          SI */
751    COSTS_N_INSNS (25),                  /*                          DI */
752    COSTS_N_INSNS (25)},                 /*                          other */
753   COSTS_N_INSNS (3),                    /* cost of movsx */
754   COSTS_N_INSNS (2),                    /* cost of movzx */
755   8,                                    /* "large" insn */
756   6,                                    /* MOVE_RATIO */
757   6,                                 /* cost for loading QImode using movzbl */
758   {2, 4, 2},                            /* cost of loading integer registers
759                                            in QImode, HImode and SImode.
760                                            Relative to reg-reg move (2).  */
761   {2, 4, 2},                            /* cost of storing integer registers */
762   2,                                    /* cost of reg,reg fld/fst */
763   {2, 2, 6},                            /* cost of loading fp registers
764                                            in SFmode, DFmode and XFmode */
765   {4, 4, 6},                            /* cost of storing fp registers
766                                            in SFmode, DFmode and XFmode */
767   8,                                    /* cost of moving MMX register */
768   {8, 8},                               /* cost of loading MMX registers
769                                            in SImode and DImode */
770   {8, 8},                               /* cost of storing MMX registers
771                                            in SImode and DImode */
772   2,                                    /* cost of moving SSE register */
773   {4, 8, 16},                           /* cost of loading SSE registers
774                                            in SImode, DImode and TImode */
775   {4, 8, 16},                           /* cost of storing SSE registers
776                                            in SImode, DImode and TImode */
777   3,                                    /* MMX or SSE register to integer */
778   8,                                    /* size of l1 cache.  */
779   8,                                    /* size of l2 cache  */
780   0,                                    /* size of prefetch block */
781   0,                                    /* number of parallel prefetches */
782   2,                                    /* Branch cost */
783   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
784   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
785   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
786   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
787   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
788   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
789   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
790    DUMMY_STRINGOP_ALGS},
791    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
792    DUMMY_STRINGOP_ALGS}},
793   {{{libcall, {{-1, rep_prefix_4_byte}}},
794    DUMMY_STRINGOP_ALGS},
795    {{libcall, {{-1, rep_prefix_4_byte}}},
796    DUMMY_STRINGOP_ALGS}},
797   1,                                    /* scalar_stmt_cost.  */
798   1,                                    /* scalar load_cost.  */
799   1,                                    /* scalar_store_cost.  */
800   1,                                    /* vec_stmt_cost.  */
801   1,                                    /* vec_to_scalar_cost.  */
802   1,                                    /* scalar_to_vec_cost.  */
803   1,                                    /* vec_align_load_cost.  */
804   2,                                    /* vec_unalign_load_cost.  */
805   1,                                    /* vec_store_cost.  */
806   3,                                    /* cond_taken_branch_cost.  */
807   1,                                    /* cond_not_taken_branch_cost.  */
808 };
809
810 static const
811 struct processor_costs pentiumpro_cost = {
812   COSTS_N_INSNS (1),                    /* cost of an add instruction */
813   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
814   COSTS_N_INSNS (1),                    /* variable shift costs */
815   COSTS_N_INSNS (1),                    /* constant shift costs */
816   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
817    COSTS_N_INSNS (4),                   /*                               HI */
818    COSTS_N_INSNS (4),                   /*                               SI */
819    COSTS_N_INSNS (4),                   /*                               DI */
820    COSTS_N_INSNS (4)},                  /*                            other */
821   0,                                    /* cost of multiply per each bit set */
822   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
823    COSTS_N_INSNS (17),                  /*                          HI */
824    COSTS_N_INSNS (17),                  /*                          SI */
825    COSTS_N_INSNS (17),                  /*                          DI */
826    COSTS_N_INSNS (17)},                 /*                          other */
827   COSTS_N_INSNS (1),                    /* cost of movsx */
828   COSTS_N_INSNS (1),                    /* cost of movzx */
829   8,                                    /* "large" insn */
830   6,                                    /* MOVE_RATIO */
831   2,                                 /* cost for loading QImode using movzbl */
832   {4, 4, 4},                            /* cost of loading integer registers
833                                            in QImode, HImode and SImode.
834                                            Relative to reg-reg move (2).  */
835   {2, 2, 2},                            /* cost of storing integer registers */
836   2,                                    /* cost of reg,reg fld/fst */
837   {2, 2, 6},                            /* cost of loading fp registers
838                                            in SFmode, DFmode and XFmode */
839   {4, 4, 6},                            /* cost of storing fp registers
840                                            in SFmode, DFmode and XFmode */
841   2,                                    /* cost of moving MMX register */
842   {2, 2},                               /* cost of loading MMX registers
843                                            in SImode and DImode */
844   {2, 2},                               /* cost of storing MMX registers
845                                            in SImode and DImode */
846   2,                                    /* cost of moving SSE register */
847   {2, 2, 8},                            /* cost of loading SSE registers
848                                            in SImode, DImode and TImode */
849   {2, 2, 8},                            /* cost of storing SSE registers
850                                            in SImode, DImode and TImode */
851   3,                                    /* MMX or SSE register to integer */
852   8,                                    /* size of l1 cache.  */
853   256,                                  /* size of l2 cache  */
854   32,                                   /* size of prefetch block */
855   6,                                    /* number of parallel prefetches */
856   2,                                    /* Branch cost */
857   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
858   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
859   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
860   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
861   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
862   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
863   /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes
864      (we ensure the alignment).  For small blocks inline loop is still a
865      noticeable win, for bigger blocks either rep movsl or rep movsb is
866      way to go.  Rep movsb has apparently more expensive startup time in CPU,
867      but after 4K the difference is down in the noise.  */
868   {{{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
869                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
870    DUMMY_STRINGOP_ALGS},
871    {{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
872                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
873    DUMMY_STRINGOP_ALGS}},
874   {{{rep_prefix_4_byte, {{1024, unrolled_loop},
875                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
876    DUMMY_STRINGOP_ALGS},
877    {{rep_prefix_4_byte, {{1024, unrolled_loop},
878                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
879    DUMMY_STRINGOP_ALGS}},
880   1,                                    /* scalar_stmt_cost.  */
881   1,                                    /* scalar load_cost.  */
882   1,                                    /* scalar_store_cost.  */
883   1,                                    /* vec_stmt_cost.  */
884   1,                                    /* vec_to_scalar_cost.  */
885   1,                                    /* scalar_to_vec_cost.  */
886   1,                                    /* vec_align_load_cost.  */
887   2,                                    /* vec_unalign_load_cost.  */
888   1,                                    /* vec_store_cost.  */
889   3,                                    /* cond_taken_branch_cost.  */
890   1,                                    /* cond_not_taken_branch_cost.  */
891 };
892
893 static const
894 struct processor_costs geode_cost = {
895   COSTS_N_INSNS (1),                    /* cost of an add instruction */
896   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
897   COSTS_N_INSNS (2),                    /* variable shift costs */
898   COSTS_N_INSNS (1),                    /* constant shift costs */
899   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
900    COSTS_N_INSNS (4),                   /*                               HI */
901    COSTS_N_INSNS (7),                   /*                               SI */
902    COSTS_N_INSNS (7),                   /*                               DI */
903    COSTS_N_INSNS (7)},                  /*                            other */
904   0,                                    /* cost of multiply per each bit set */
905   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
906    COSTS_N_INSNS (23),                  /*                          HI */
907    COSTS_N_INSNS (39),                  /*                          SI */
908    COSTS_N_INSNS (39),                  /*                          DI */
909    COSTS_N_INSNS (39)},                 /*                          other */
910   COSTS_N_INSNS (1),                    /* cost of movsx */
911   COSTS_N_INSNS (1),                    /* cost of movzx */
912   8,                                    /* "large" insn */
913   4,                                    /* MOVE_RATIO */
914   1,                                 /* cost for loading QImode using movzbl */
915   {1, 1, 1},                            /* cost of loading integer registers
916                                            in QImode, HImode and SImode.
917                                            Relative to reg-reg move (2).  */
918   {1, 1, 1},                            /* cost of storing integer registers */
919   1,                                    /* cost of reg,reg fld/fst */
920   {1, 1, 1},                            /* cost of loading fp registers
921                                            in SFmode, DFmode and XFmode */
922   {4, 6, 6},                            /* cost of storing fp registers
923                                            in SFmode, DFmode and XFmode */
924
925   1,                                    /* cost of moving MMX register */
926   {1, 1},                               /* cost of loading MMX registers
927                                            in SImode and DImode */
928   {1, 1},                               /* cost of storing MMX registers
929                                            in SImode and DImode */
930   1,                                    /* cost of moving SSE register */
931   {1, 1, 1},                            /* cost of loading SSE registers
932                                            in SImode, DImode and TImode */
933   {1, 1, 1},                            /* cost of storing SSE registers
934                                            in SImode, DImode and TImode */
935   1,                                    /* MMX or SSE register to integer */
936   64,                                   /* size of l1 cache.  */
937   128,                                  /* size of l2 cache.  */
938   32,                                   /* size of prefetch block */
939   1,                                    /* number of parallel prefetches */
940   1,                                    /* Branch cost */
941   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
942   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
943   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
944   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
945   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
946   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
947   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
948    DUMMY_STRINGOP_ALGS},
949    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
950    DUMMY_STRINGOP_ALGS}},
951   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
952    DUMMY_STRINGOP_ALGS},
953    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
954    DUMMY_STRINGOP_ALGS}},
955   1,                                    /* scalar_stmt_cost.  */
956   1,                                    /* scalar load_cost.  */
957   1,                                    /* scalar_store_cost.  */
958   1,                                    /* vec_stmt_cost.  */
959   1,                                    /* vec_to_scalar_cost.  */
960   1,                                    /* scalar_to_vec_cost.  */
961   1,                                    /* vec_align_load_cost.  */
962   2,                                    /* vec_unalign_load_cost.  */
963   1,                                    /* vec_store_cost.  */
964   3,                                    /* cond_taken_branch_cost.  */
965   1,                                    /* cond_not_taken_branch_cost.  */
966 };
967
968 static const
969 struct processor_costs k6_cost = {
970   COSTS_N_INSNS (1),                    /* cost of an add instruction */
971   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
972   COSTS_N_INSNS (1),                    /* variable shift costs */
973   COSTS_N_INSNS (1),                    /* constant shift costs */
974   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
975    COSTS_N_INSNS (3),                   /*                               HI */
976    COSTS_N_INSNS (3),                   /*                               SI */
977    COSTS_N_INSNS (3),                   /*                               DI */
978    COSTS_N_INSNS (3)},                  /*                            other */
979   0,                                    /* cost of multiply per each bit set */
980   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
981    COSTS_N_INSNS (18),                  /*                          HI */
982    COSTS_N_INSNS (18),                  /*                          SI */
983    COSTS_N_INSNS (18),                  /*                          DI */
984    COSTS_N_INSNS (18)},                 /*                          other */
985   COSTS_N_INSNS (2),                    /* cost of movsx */
986   COSTS_N_INSNS (2),                    /* cost of movzx */
987   8,                                    /* "large" insn */
988   4,                                    /* MOVE_RATIO */
989   3,                                 /* cost for loading QImode using movzbl */
990   {4, 5, 4},                            /* cost of loading integer registers
991                                            in QImode, HImode and SImode.
992                                            Relative to reg-reg move (2).  */
993   {2, 3, 2},                            /* cost of storing integer registers */
994   4,                                    /* cost of reg,reg fld/fst */
995   {6, 6, 6},                            /* cost of loading fp registers
996                                            in SFmode, DFmode and XFmode */
997   {4, 4, 4},                            /* cost of storing fp registers
998                                            in SFmode, DFmode and XFmode */
999   2,                                    /* cost of moving MMX register */
1000   {2, 2},                               /* cost of loading MMX registers
1001                                            in SImode and DImode */
1002   {2, 2},                               /* cost of storing MMX registers
1003                                            in SImode and DImode */
1004   2,                                    /* cost of moving SSE register */
1005   {2, 2, 8},                            /* cost of loading SSE registers
1006                                            in SImode, DImode and TImode */
1007   {2, 2, 8},                            /* cost of storing SSE registers
1008                                            in SImode, DImode and TImode */
1009   6,                                    /* MMX or SSE register to integer */
1010   32,                                   /* size of l1 cache.  */
1011   32,                                   /* size of l2 cache.  Some models
1012                                            have integrated l2 cache, but
1013                                            optimizing for k6 is not important
1014                                            enough to worry about that.  */
1015   32,                                   /* size of prefetch block */
1016   1,                                    /* number of parallel prefetches */
1017   1,                                    /* Branch cost */
1018   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
1019   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
1020   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
1021   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1022   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1023   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
1024   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1025    DUMMY_STRINGOP_ALGS},
1026    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1027    DUMMY_STRINGOP_ALGS}},
1028   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1029    DUMMY_STRINGOP_ALGS},
1030    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1031    DUMMY_STRINGOP_ALGS}},
1032   1,                                    /* scalar_stmt_cost.  */
1033   1,                                    /* scalar load_cost.  */
1034   1,                                    /* scalar_store_cost.  */
1035   1,                                    /* vec_stmt_cost.  */
1036   1,                                    /* vec_to_scalar_cost.  */
1037   1,                                    /* scalar_to_vec_cost.  */
1038   1,                                    /* vec_align_load_cost.  */
1039   2,                                    /* vec_unalign_load_cost.  */
1040   1,                                    /* vec_store_cost.  */
1041   3,                                    /* cond_taken_branch_cost.  */
1042   1,                                    /* cond_not_taken_branch_cost.  */
1043 };
1044
1045 static const
1046 struct processor_costs athlon_cost = {
1047   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1048   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1049   COSTS_N_INSNS (1),                    /* variable shift costs */
1050   COSTS_N_INSNS (1),                    /* constant shift costs */
1051   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
1052    COSTS_N_INSNS (5),                   /*                               HI */
1053    COSTS_N_INSNS (5),                   /*                               SI */
1054    COSTS_N_INSNS (5),                   /*                               DI */
1055    COSTS_N_INSNS (5)},                  /*                            other */
1056   0,                                    /* cost of multiply per each bit set */
1057   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1058    COSTS_N_INSNS (26),                  /*                          HI */
1059    COSTS_N_INSNS (42),                  /*                          SI */
1060    COSTS_N_INSNS (74),                  /*                          DI */
1061    COSTS_N_INSNS (74)},                 /*                          other */
1062   COSTS_N_INSNS (1),                    /* cost of movsx */
1063   COSTS_N_INSNS (1),                    /* cost of movzx */
1064   8,                                    /* "large" insn */
1065   9,                                    /* MOVE_RATIO */
1066   4,                                 /* cost for loading QImode using movzbl */
1067   {3, 4, 3},                            /* cost of loading integer registers
1068                                            in QImode, HImode and SImode.
1069                                            Relative to reg-reg move (2).  */
1070   {3, 4, 3},                            /* cost of storing integer registers */
1071   4,                                    /* cost of reg,reg fld/fst */
1072   {4, 4, 12},                           /* cost of loading fp registers
1073                                            in SFmode, DFmode and XFmode */
1074   {6, 6, 8},                            /* cost of storing fp registers
1075                                            in SFmode, DFmode and XFmode */
1076   2,                                    /* cost of moving MMX register */
1077   {4, 4},                               /* cost of loading MMX registers
1078                                            in SImode and DImode */
1079   {4, 4},                               /* cost of storing MMX registers
1080                                            in SImode and DImode */
1081   2,                                    /* cost of moving SSE register */
1082   {4, 4, 6},                            /* cost of loading SSE registers
1083                                            in SImode, DImode and TImode */
1084   {4, 4, 5},                            /* cost of storing SSE registers
1085                                            in SImode, DImode and TImode */
1086   5,                                    /* MMX or SSE register to integer */
1087   64,                                   /* size of l1 cache.  */
1088   256,                                  /* size of l2 cache.  */
1089   64,                                   /* size of prefetch block */
1090   6,                                    /* number of parallel prefetches */
1091   5,                                    /* Branch cost */
1092   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1093   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1094   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
1095   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1096   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1097   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1098   /* For some reason, Athlon deals better with REP prefix (relative to loops)
1099      compared to K8. Alignment becomes important after 8 bytes for memcpy and
1100      128 bytes for memset.  */
1101   {{{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1102    DUMMY_STRINGOP_ALGS},
1103    {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1104    DUMMY_STRINGOP_ALGS}},
1105   {{{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1106    DUMMY_STRINGOP_ALGS},
1107    {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1108    DUMMY_STRINGOP_ALGS}},
1109   1,                                    /* scalar_stmt_cost.  */
1110   1,                                    /* scalar load_cost.  */
1111   1,                                    /* scalar_store_cost.  */
1112   1,                                    /* vec_stmt_cost.  */
1113   1,                                    /* vec_to_scalar_cost.  */
1114   1,                                    /* scalar_to_vec_cost.  */
1115   1,                                    /* vec_align_load_cost.  */
1116   2,                                    /* vec_unalign_load_cost.  */
1117   1,                                    /* vec_store_cost.  */
1118   3,                                    /* cond_taken_branch_cost.  */
1119   1,                                    /* cond_not_taken_branch_cost.  */
1120 };
1121
1122 static const
1123 struct processor_costs k8_cost = {
1124   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1125   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1126   COSTS_N_INSNS (1),                    /* variable shift costs */
1127   COSTS_N_INSNS (1),                    /* constant shift costs */
1128   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1129    COSTS_N_INSNS (4),                   /*                               HI */
1130    COSTS_N_INSNS (3),                   /*                               SI */
1131    COSTS_N_INSNS (4),                   /*                               DI */
1132    COSTS_N_INSNS (5)},                  /*                            other */
1133   0,                                    /* cost of multiply per each bit set */
1134   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1135    COSTS_N_INSNS (26),                  /*                          HI */
1136    COSTS_N_INSNS (42),                  /*                          SI */
1137    COSTS_N_INSNS (74),                  /*                          DI */
1138    COSTS_N_INSNS (74)},                 /*                          other */
1139   COSTS_N_INSNS (1),                    /* cost of movsx */
1140   COSTS_N_INSNS (1),                    /* cost of movzx */
1141   8,                                    /* "large" insn */
1142   9,                                    /* MOVE_RATIO */
1143   4,                                 /* cost for loading QImode using movzbl */
1144   {3, 4, 3},                            /* cost of loading integer registers
1145                                            in QImode, HImode and SImode.
1146                                            Relative to reg-reg move (2).  */
1147   {3, 4, 3},                            /* cost of storing integer registers */
1148   4,                                    /* cost of reg,reg fld/fst */
1149   {4, 4, 12},                           /* cost of loading fp registers
1150                                            in SFmode, DFmode and XFmode */
1151   {6, 6, 8},                            /* cost of storing fp registers
1152                                            in SFmode, DFmode and XFmode */
1153   2,                                    /* cost of moving MMX register */
1154   {3, 3},                               /* cost of loading MMX registers
1155                                            in SImode and DImode */
1156   {4, 4},                               /* cost of storing MMX registers
1157                                            in SImode and DImode */
1158   2,                                    /* cost of moving SSE register */
1159   {4, 3, 6},                            /* cost of loading SSE registers
1160                                            in SImode, DImode and TImode */
1161   {4, 4, 5},                            /* cost of storing SSE registers
1162                                            in SImode, DImode and TImode */
1163   5,                                    /* MMX or SSE register to integer */
1164   64,                                   /* size of l1 cache.  */
1165   512,                                  /* size of l2 cache.  */
1166   64,                                   /* size of prefetch block */
1167   /* New AMD processors never drop prefetches; if they cannot be performed
1168      immediately, they are queued.  We set number of simultaneous prefetches
1169      to a large constant to reflect this (it probably is not a good idea not
1170      to limit number of prefetches at all, as their execution also takes some
1171      time).  */
1172   100,                                  /* number of parallel prefetches */
1173   3,                                    /* Branch cost */
1174   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1175   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1176   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1177   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1178   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1179   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1180   /* K8 has optimized REP instruction for medium sized blocks, but for very
1181      small blocks it is better to use loop. For large blocks, libcall can
1182      do nontemporary accesses and beat inline considerably.  */
1183   {{{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1184    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1185    {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1186    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1187   {{{libcall, {{8, loop}, {24, unrolled_loop},
1188               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1189    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1190    {{libcall, {{8, loop}, {24, unrolled_loop},
1191               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1192    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1193   4,                                    /* scalar_stmt_cost.  */
1194   2,                                    /* scalar load_cost.  */
1195   2,                                    /* scalar_store_cost.  */
1196   5,                                    /* vec_stmt_cost.  */
1197   0,                                    /* vec_to_scalar_cost.  */
1198   2,                                    /* scalar_to_vec_cost.  */
1199   2,                                    /* vec_align_load_cost.  */
1200   3,                                    /* vec_unalign_load_cost.  */
1201   3,                                    /* vec_store_cost.  */
1202   3,                                    /* cond_taken_branch_cost.  */
1203   2,                                    /* cond_not_taken_branch_cost.  */
1204 };
1205
1206 struct processor_costs amdfam10_cost = {
1207   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1208   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1209   COSTS_N_INSNS (1),                    /* variable shift costs */
1210   COSTS_N_INSNS (1),                    /* constant shift costs */
1211   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1212    COSTS_N_INSNS (4),                   /*                               HI */
1213    COSTS_N_INSNS (3),                   /*                               SI */
1214    COSTS_N_INSNS (4),                   /*                               DI */
1215    COSTS_N_INSNS (5)},                  /*                            other */
1216   0,                                    /* cost of multiply per each bit set */
1217   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1218    COSTS_N_INSNS (35),                  /*                          HI */
1219    COSTS_N_INSNS (51),                  /*                          SI */
1220    COSTS_N_INSNS (83),                  /*                          DI */
1221    COSTS_N_INSNS (83)},                 /*                          other */
1222   COSTS_N_INSNS (1),                    /* cost of movsx */
1223   COSTS_N_INSNS (1),                    /* cost of movzx */
1224   8,                                    /* "large" insn */
1225   9,                                    /* MOVE_RATIO */
1226   4,                                 /* cost for loading QImode using movzbl */
1227   {3, 4, 3},                            /* cost of loading integer registers
1228                                            in QImode, HImode and SImode.
1229                                            Relative to reg-reg move (2).  */
1230   {3, 4, 3},                            /* cost of storing integer registers */
1231   4,                                    /* cost of reg,reg fld/fst */
1232   {4, 4, 12},                           /* cost of loading fp registers
1233                                            in SFmode, DFmode and XFmode */
1234   {6, 6, 8},                            /* cost of storing fp registers
1235                                            in SFmode, DFmode and XFmode */
1236   2,                                    /* cost of moving MMX register */
1237   {3, 3},                               /* cost of loading MMX registers
1238                                            in SImode and DImode */
1239   {4, 4},                               /* cost of storing MMX registers
1240                                            in SImode and DImode */
1241   2,                                    /* cost of moving SSE register */
1242   {4, 4, 3},                            /* cost of loading SSE registers
1243                                            in SImode, DImode and TImode */
1244   {4, 4, 5},                            /* cost of storing SSE registers
1245                                            in SImode, DImode and TImode */
1246   3,                                    /* MMX or SSE register to integer */
1247                                         /* On K8:
1248                                             MOVD reg64, xmmreg Double FSTORE 4
1249                                             MOVD reg32, xmmreg Double FSTORE 4
1250                                            On AMDFAM10:
1251                                             MOVD reg64, xmmreg Double FADD 3
1252                                                                1/1  1/1
1253                                             MOVD reg32, xmmreg Double FADD 3
1254                                                                1/1  1/1 */
1255   64,                                   /* size of l1 cache.  */
1256   512,                                  /* size of l2 cache.  */
1257   64,                                   /* size of prefetch block */
1258   /* New AMD processors never drop prefetches; if they cannot be performed
1259      immediately, they are queued.  We set number of simultaneous prefetches
1260      to a large constant to reflect this (it probably is not a good idea not
1261      to limit number of prefetches at all, as their execution also takes some
1262      time).  */
1263   100,                                  /* number of parallel prefetches */
1264   2,                                    /* Branch cost */
1265   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1266   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1267   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1268   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1269   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1270   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1271
1272   /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
1273      very small blocks it is better to use loop. For large blocks, libcall can
1274      do nontemporary accesses and beat inline considerably.  */
1275   {{{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1276    {libcall, {{16, loop}, {512, rep_prefix_8_byte}, {-1, libcall}}}},
1277    {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1278    {libcall, {{16, loop}, {512, rep_prefix_8_byte}, {-1, libcall}}}}},
1279   {{{libcall, {{8, loop}, {24, unrolled_loop},
1280               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1281    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1282    {{libcall, {{8, loop}, {24, unrolled_loop},
1283               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1284    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1285   4,                                    /* scalar_stmt_cost.  */
1286   2,                                    /* scalar load_cost.  */
1287   2,                                    /* scalar_store_cost.  */
1288   6,                                    /* vec_stmt_cost.  */
1289   0,                                    /* vec_to_scalar_cost.  */
1290   2,                                    /* scalar_to_vec_cost.  */
1291   2,                                    /* vec_align_load_cost.  */
1292   2,                                    /* vec_unalign_load_cost.  */
1293   2,                                    /* vec_store_cost.  */
1294   2,                                    /* cond_taken_branch_cost.  */
1295   1,                                    /* cond_not_taken_branch_cost.  */
1296 };
1297
1298 struct processor_costs bdver1_cost = {
1299   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1300   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1301   COSTS_N_INSNS (1),                    /* variable shift costs */
1302   COSTS_N_INSNS (1),                    /* constant shift costs */
1303   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1304    COSTS_N_INSNS (4),                   /*                               HI */
1305    COSTS_N_INSNS (4),                   /*                               SI */
1306    COSTS_N_INSNS (6),                   /*                               DI */
1307    COSTS_N_INSNS (6)},                  /*                            other */
1308   0,                                    /* cost of multiply per each bit set */
1309   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1310    COSTS_N_INSNS (35),                  /*                          HI */
1311    COSTS_N_INSNS (51),                  /*                          SI */
1312    COSTS_N_INSNS (83),                  /*                          DI */
1313    COSTS_N_INSNS (83)},                 /*                          other */
1314   COSTS_N_INSNS (1),                    /* cost of movsx */
1315   COSTS_N_INSNS (1),                    /* cost of movzx */
1316   8,                                    /* "large" insn */
1317   9,                                    /* MOVE_RATIO */
1318   4,                                 /* cost for loading QImode using movzbl */
1319   {5, 5, 4},                            /* cost of loading integer registers
1320                                            in QImode, HImode and SImode.
1321                                            Relative to reg-reg move (2).  */
1322   {4, 4, 4},                            /* cost of storing integer registers */
1323   2,                                    /* cost of reg,reg fld/fst */
1324   {5, 5, 12},                           /* cost of loading fp registers
1325                                            in SFmode, DFmode and XFmode */
1326   {4, 4, 8},                            /* cost of storing fp registers
1327                                            in SFmode, DFmode and XFmode */
1328   2,                                    /* cost of moving MMX register */
1329   {4, 4},                               /* cost of loading MMX registers
1330                                            in SImode and DImode */
1331   {4, 4},                               /* cost of storing MMX registers
1332                                            in SImode and DImode */
1333   2,                                    /* cost of moving SSE register */
1334   {4, 4, 4},                            /* cost of loading SSE registers
1335                                            in SImode, DImode and TImode */
1336   {4, 4, 4},                            /* cost of storing SSE registers
1337                                            in SImode, DImode and TImode */
1338   2,                                    /* MMX or SSE register to integer */
1339                                         /* On K8:
1340                                             MOVD reg64, xmmreg Double FSTORE 4
1341                                             MOVD reg32, xmmreg Double FSTORE 4
1342                                            On AMDFAM10:
1343                                             MOVD reg64, xmmreg Double FADD 3
1344                                                                1/1  1/1
1345                                             MOVD reg32, xmmreg Double FADD 3
1346                                                                1/1  1/1 */
1347   16,                                   /* size of l1 cache.  */
1348   2048,                                 /* size of l2 cache.  */
1349   64,                                   /* size of prefetch block */
1350   /* New AMD processors never drop prefetches; if they cannot be performed
1351      immediately, they are queued.  We set number of simultaneous prefetches
1352      to a large constant to reflect this (it probably is not a good idea not
1353      to limit number of prefetches at all, as their execution also takes some
1354      time).  */
1355   100,                                  /* number of parallel prefetches */
1356   2,                                    /* Branch cost */
1357   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1358   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1359   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1360   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1361   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1362   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1363
1364   /*  BDVER1 has optimized REP instruction for medium sized blocks, but for
1365       very small blocks it is better to use loop. For large blocks, libcall
1366       can do nontemporary accesses and beat inline considerably.  */
1367   {{{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1368    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1369    {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1370    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1371   {{{libcall, {{8, loop}, {24, unrolled_loop},
1372               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1373    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1374    {{libcall, {{8, loop}, {24, unrolled_loop},
1375               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1376    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1377   6,                                    /* scalar_stmt_cost.  */
1378   4,                                    /* scalar load_cost.  */
1379   4,                                    /* scalar_store_cost.  */
1380   6,                                    /* vec_stmt_cost.  */
1381   0,                                    /* vec_to_scalar_cost.  */
1382   2,                                    /* scalar_to_vec_cost.  */
1383   4,                                    /* vec_align_load_cost.  */
1384   4,                                    /* vec_unalign_load_cost.  */
1385   4,                                    /* vec_store_cost.  */
1386   2,                                    /* cond_taken_branch_cost.  */
1387   1,                                    /* cond_not_taken_branch_cost.  */
1388 };
1389
1390 struct processor_costs bdver2_cost = {
1391   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1392   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1393   COSTS_N_INSNS (1),                    /* variable shift costs */
1394   COSTS_N_INSNS (1),                    /* constant shift costs */
1395   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1396    COSTS_N_INSNS (4),                   /*                               HI */
1397    COSTS_N_INSNS (4),                   /*                               SI */
1398    COSTS_N_INSNS (6),                   /*                               DI */
1399    COSTS_N_INSNS (6)},                  /*                            other */
1400   0,                                    /* cost of multiply per each bit set */
1401   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1402    COSTS_N_INSNS (35),                  /*                          HI */
1403    COSTS_N_INSNS (51),                  /*                          SI */
1404    COSTS_N_INSNS (83),                  /*                          DI */
1405    COSTS_N_INSNS (83)},                 /*                          other */
1406   COSTS_N_INSNS (1),                    /* cost of movsx */
1407   COSTS_N_INSNS (1),                    /* cost of movzx */
1408   8,                                    /* "large" insn */
1409   9,                                    /* MOVE_RATIO */
1410   4,                                 /* cost for loading QImode using movzbl */
1411   {5, 5, 4},                            /* cost of loading integer registers
1412                                            in QImode, HImode and SImode.
1413                                            Relative to reg-reg move (2).  */
1414   {4, 4, 4},                            /* cost of storing integer registers */
1415   2,                                    /* cost of reg,reg fld/fst */
1416   {5, 5, 12},                           /* cost of loading fp registers
1417                                            in SFmode, DFmode and XFmode */
1418   {4, 4, 8},                            /* cost of storing fp registers
1419                                            in SFmode, DFmode and XFmode */
1420   2,                                    /* cost of moving MMX register */
1421   {4, 4},                               /* cost of loading MMX registers
1422                                            in SImode and DImode */
1423   {4, 4},                               /* cost of storing MMX registers
1424                                            in SImode and DImode */
1425   2,                                    /* cost of moving SSE register */
1426   {4, 4, 4},                            /* cost of loading SSE registers
1427                                            in SImode, DImode and TImode */
1428   {4, 4, 4},                            /* cost of storing SSE registers
1429                                            in SImode, DImode and TImode */
1430   2,                                    /* MMX or SSE register to integer */
1431                                         /* On K8:
1432                                             MOVD reg64, xmmreg Double FSTORE 4
1433                                             MOVD reg32, xmmreg Double FSTORE 4
1434                                            On AMDFAM10:
1435                                             MOVD reg64, xmmreg Double FADD 3
1436                                                                1/1  1/1
1437                                             MOVD reg32, xmmreg Double FADD 3
1438                                                                1/1  1/1 */
1439   16,                                   /* size of l1 cache.  */
1440   2048,                                 /* size of l2 cache.  */
1441   64,                                   /* size of prefetch block */
1442   /* New AMD processors never drop prefetches; if they cannot be performed
1443      immediately, they are queued.  We set number of simultaneous prefetches
1444      to a large constant to reflect this (it probably is not a good idea not
1445      to limit number of prefetches at all, as their execution also takes some
1446      time).  */
1447   100,                                  /* number of parallel prefetches */
1448   2,                                    /* Branch cost */
1449   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1450   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1451   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1452   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1453   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1454   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1455
1456   /*  BDVER2 has optimized REP instruction for medium sized blocks, but for
1457       very small blocks it is better to use loop. For large blocks, libcall
1458       can do nontemporary accesses and beat inline considerably.  */
1459   {{{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1460    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1461   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1462    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1463   {{{libcall, {{8, loop}, {24, unrolled_loop},
1464               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1465    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1466   {{libcall, {{8, loop}, {24, unrolled_loop},
1467               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1468    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1469   6,                                    /* scalar_stmt_cost.  */
1470   4,                                    /* scalar load_cost.  */
1471   4,                                    /* scalar_store_cost.  */
1472   6,                                    /* vec_stmt_cost.  */
1473   0,                                    /* vec_to_scalar_cost.  */
1474   2,                                    /* scalar_to_vec_cost.  */
1475   4,                                    /* vec_align_load_cost.  */
1476   4,                                    /* vec_unalign_load_cost.  */
1477   4,                                    /* vec_store_cost.  */
1478   2,                                    /* cond_taken_branch_cost.  */
1479   1,                                    /* cond_not_taken_branch_cost.  */
1480 };
1481
1482 struct processor_costs btver1_cost = {
1483   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1484   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1485   COSTS_N_INSNS (1),                    /* variable shift costs */
1486   COSTS_N_INSNS (1),                    /* constant shift costs */
1487   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1488    COSTS_N_INSNS (4),                   /*                               HI */
1489    COSTS_N_INSNS (3),                   /*                               SI */
1490    COSTS_N_INSNS (4),                   /*                               DI */
1491    COSTS_N_INSNS (5)},                  /*                            other */
1492   0,                                    /* cost of multiply per each bit set */
1493   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1494    COSTS_N_INSNS (35),                  /*                          HI */
1495    COSTS_N_INSNS (51),                  /*                          SI */
1496    COSTS_N_INSNS (83),                  /*                          DI */
1497    COSTS_N_INSNS (83)},                 /*                          other */
1498   COSTS_N_INSNS (1),                    /* cost of movsx */
1499   COSTS_N_INSNS (1),                    /* cost of movzx */
1500   8,                                    /* "large" insn */
1501   9,                                    /* MOVE_RATIO */
1502   4,                                 /* cost for loading QImode using movzbl */
1503   {3, 4, 3},                            /* cost of loading integer registers
1504                                            in QImode, HImode and SImode.
1505                                            Relative to reg-reg move (2).  */
1506   {3, 4, 3},                            /* cost of storing integer registers */
1507   4,                                    /* cost of reg,reg fld/fst */
1508   {4, 4, 12},                           /* cost of loading fp registers
1509                                            in SFmode, DFmode and XFmode */
1510   {6, 6, 8},                            /* cost of storing fp registers
1511                                            in SFmode, DFmode and XFmode */
1512   2,                                    /* cost of moving MMX register */
1513   {3, 3},                               /* cost of loading MMX registers
1514                                            in SImode and DImode */
1515   {4, 4},                               /* cost of storing MMX registers
1516                                            in SImode and DImode */
1517   2,                                    /* cost of moving SSE register */
1518   {4, 4, 3},                            /* cost of loading SSE registers
1519                                            in SImode, DImode and TImode */
1520   {4, 4, 5},                            /* cost of storing SSE registers
1521                                            in SImode, DImode and TImode */
1522   3,                                    /* MMX or SSE register to integer */
1523                                         /* On K8:
1524                                            MOVD reg64, xmmreg Double FSTORE 4
1525                                            MOVD reg32, xmmreg Double FSTORE 4
1526                                            On AMDFAM10:
1527                                            MOVD reg64, xmmreg Double FADD 3
1528                                                                1/1  1/1
1529                                             MOVD reg32, xmmreg Double FADD 3
1530                                                                1/1  1/1 */
1531   32,                                   /* size of l1 cache.  */
1532   512,                                  /* size of l2 cache.  */
1533   64,                                   /* size of prefetch block */
1534   100,                                  /* number of parallel prefetches */
1535   2,                                    /* Branch cost */
1536   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1537   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1538   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1539   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1540   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1541   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1542
1543   /* BTVER1 has optimized REP instruction for medium sized blocks, but for
1544      very small blocks it is better to use loop. For large blocks, libcall can
1545      do nontemporary accesses and beat inline considerably.  */
1546   {{{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1547    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1548    {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1549    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1550   {{{libcall, {{8, loop}, {24, unrolled_loop},
1551               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1552    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1553    {{libcall, {{8, loop}, {24, unrolled_loop},
1554               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1555    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1556   4,                                    /* scalar_stmt_cost.  */
1557   2,                                    /* scalar load_cost.  */
1558   2,                                    /* scalar_store_cost.  */
1559   6,                                    /* vec_stmt_cost.  */
1560   0,                                    /* vec_to_scalar_cost.  */
1561   2,                                    /* scalar_to_vec_cost.  */
1562   2,                                    /* vec_align_load_cost.  */
1563   2,                                    /* vec_unalign_load_cost.  */
1564   2,                                    /* vec_store_cost.  */
1565   2,                                    /* cond_taken_branch_cost.  */
1566   1,                                    /* cond_not_taken_branch_cost.  */
1567 };
1568
1569 static const
1570 struct processor_costs pentium4_cost = {
1571   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1572   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
1573   COSTS_N_INSNS (4),                    /* variable shift costs */
1574   COSTS_N_INSNS (4),                    /* constant shift costs */
1575   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
1576    COSTS_N_INSNS (15),                  /*                               HI */
1577    COSTS_N_INSNS (15),                  /*                               SI */
1578    COSTS_N_INSNS (15),                  /*                               DI */
1579    COSTS_N_INSNS (15)},                 /*                            other */
1580   0,                                    /* cost of multiply per each bit set */
1581   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
1582    COSTS_N_INSNS (56),                  /*                          HI */
1583    COSTS_N_INSNS (56),                  /*                          SI */
1584    COSTS_N_INSNS (56),                  /*                          DI */
1585    COSTS_N_INSNS (56)},                 /*                          other */
1586   COSTS_N_INSNS (1),                    /* cost of movsx */
1587   COSTS_N_INSNS (1),                    /* cost of movzx */
1588   16,                                   /* "large" insn */
1589   6,                                    /* MOVE_RATIO */
1590   2,                                 /* cost for loading QImode using movzbl */
1591   {4, 5, 4},                            /* cost of loading integer registers
1592                                            in QImode, HImode and SImode.
1593                                            Relative to reg-reg move (2).  */
1594   {2, 3, 2},                            /* cost of storing integer registers */
1595   2,                                    /* cost of reg,reg fld/fst */
1596   {2, 2, 6},                            /* cost of loading fp registers
1597                                            in SFmode, DFmode and XFmode */
1598   {4, 4, 6},                            /* cost of storing fp registers
1599                                            in SFmode, DFmode and XFmode */
1600   2,                                    /* cost of moving MMX register */
1601   {2, 2},                               /* cost of loading MMX registers
1602                                            in SImode and DImode */
1603   {2, 2},                               /* cost of storing MMX registers
1604                                            in SImode and DImode */
1605   12,                                   /* cost of moving SSE register */
1606   {12, 12, 12},                         /* cost of loading SSE registers
1607                                            in SImode, DImode and TImode */
1608   {2, 2, 8},                            /* cost of storing SSE registers
1609                                            in SImode, DImode and TImode */
1610   10,                                   /* MMX or SSE register to integer */
1611   8,                                    /* size of l1 cache.  */
1612   256,                                  /* size of l2 cache.  */
1613   64,                                   /* size of prefetch block */
1614   6,                                    /* number of parallel prefetches */
1615   2,                                    /* Branch cost */
1616   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
1617   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
1618   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
1619   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1620   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1621   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
1622
1623   {{{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1624    DUMMY_STRINGOP_ALGS},
1625    {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1626    DUMMY_STRINGOP_ALGS}},
1627
1628   {{{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1629    {-1, libcall}}},
1630    DUMMY_STRINGOP_ALGS},
1631    {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1632    {-1, libcall}}},
1633    DUMMY_STRINGOP_ALGS}},
1634   1,                                    /* scalar_stmt_cost.  */
1635   1,                                    /* scalar load_cost.  */
1636   1,                                    /* scalar_store_cost.  */
1637   1,                                    /* vec_stmt_cost.  */
1638   1,                                    /* vec_to_scalar_cost.  */
1639   1,                                    /* scalar_to_vec_cost.  */
1640   1,                                    /* vec_align_load_cost.  */
1641   2,                                    /* vec_unalign_load_cost.  */
1642   1,                                    /* vec_store_cost.  */
1643   3,                                    /* cond_taken_branch_cost.  */
1644   1,                                    /* cond_not_taken_branch_cost.  */
1645 };
1646
1647 static const
1648 struct processor_costs nocona_cost = {
1649   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1650   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1651   COSTS_N_INSNS (1),                    /* variable shift costs */
1652   COSTS_N_INSNS (1),                    /* constant shift costs */
1653   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
1654    COSTS_N_INSNS (10),                  /*                               HI */
1655    COSTS_N_INSNS (10),                  /*                               SI */
1656    COSTS_N_INSNS (10),                  /*                               DI */
1657    COSTS_N_INSNS (10)},                 /*                            other */
1658   0,                                    /* cost of multiply per each bit set */
1659   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
1660    COSTS_N_INSNS (66),                  /*                          HI */
1661    COSTS_N_INSNS (66),                  /*                          SI */
1662    COSTS_N_INSNS (66),                  /*                          DI */
1663    COSTS_N_INSNS (66)},                 /*                          other */
1664   COSTS_N_INSNS (1),                    /* cost of movsx */
1665   COSTS_N_INSNS (1),                    /* cost of movzx */
1666   16,                                   /* "large" insn */
1667   17,                                   /* MOVE_RATIO */
1668   4,                                 /* cost for loading QImode using movzbl */
1669   {4, 4, 4},                            /* cost of loading integer registers
1670                                            in QImode, HImode and SImode.
1671                                            Relative to reg-reg move (2).  */
1672   {4, 4, 4},                            /* cost of storing integer registers */
1673   3,                                    /* cost of reg,reg fld/fst */
1674   {12, 12, 12},                         /* cost of loading fp registers
1675                                            in SFmode, DFmode and XFmode */
1676   {4, 4, 4},                            /* cost of storing fp registers
1677                                            in SFmode, DFmode and XFmode */
1678   6,                                    /* cost of moving MMX register */
1679   {12, 12},                             /* cost of loading MMX registers
1680                                            in SImode and DImode */
1681   {12, 12},                             /* cost of storing MMX registers
1682                                            in SImode and DImode */
1683   6,                                    /* cost of moving SSE register */
1684   {12, 12, 12},                         /* cost of loading SSE registers
1685                                            in SImode, DImode and TImode */
1686   {12, 12, 12},                         /* cost of storing SSE registers
1687                                            in SImode, DImode and TImode */
1688   8,                                    /* MMX or SSE register to integer */
1689   8,                                    /* size of l1 cache.  */
1690   1024,                                 /* size of l2 cache.  */
1691   128,                                  /* size of prefetch block */
1692   8,                                    /* number of parallel prefetches */
1693   1,                                    /* Branch cost */
1694   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1695   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1696   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
1697   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
1698   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
1699   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
1700
1701   {{{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1702    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
1703               {100000, unrolled_loop}, {-1, libcall}}}},
1704    {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1705    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
1706               {100000, unrolled_loop}, {-1, libcall}}}}},
1707
1708   {{{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1709    {-1, libcall}}},
1710    {libcall, {{24, loop}, {64, unrolled_loop},
1711               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1712    {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1713    {-1, libcall}}},
1714    {libcall, {{24, loop}, {64, unrolled_loop},
1715               {8192, rep_prefix_8_byte}, {-1, libcall}}}}},
1716   1,                                    /* scalar_stmt_cost.  */
1717   1,                                    /* scalar load_cost.  */
1718   1,                                    /* scalar_store_cost.  */
1719   1,                                    /* vec_stmt_cost.  */
1720   1,                                    /* vec_to_scalar_cost.  */
1721   1,                                    /* scalar_to_vec_cost.  */
1722   1,                                    /* vec_align_load_cost.  */
1723   2,                                    /* vec_unalign_load_cost.  */
1724   1,                                    /* vec_store_cost.  */
1725   3,                                    /* cond_taken_branch_cost.  */
1726   1,                                    /* cond_not_taken_branch_cost.  */
1727 };
1728
1729 static const
1730 struct processor_costs atom_cost = {
1731   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1732   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1733   COSTS_N_INSNS (1),                    /* variable shift costs */
1734   COSTS_N_INSNS (1),                    /* constant shift costs */
1735   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1736    COSTS_N_INSNS (4),                   /*                               HI */
1737    COSTS_N_INSNS (3),                   /*                               SI */
1738    COSTS_N_INSNS (4),                   /*                               DI */
1739    COSTS_N_INSNS (2)},                  /*                            other */
1740   0,                                    /* cost of multiply per each bit set */
1741   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1742    COSTS_N_INSNS (26),                  /*                          HI */
1743    COSTS_N_INSNS (42),                  /*                          SI */
1744    COSTS_N_INSNS (74),                  /*                          DI */
1745    COSTS_N_INSNS (74)},                 /*                          other */
1746   COSTS_N_INSNS (1),                    /* cost of movsx */
1747   COSTS_N_INSNS (1),                    /* cost of movzx */
1748   8,                                    /* "large" insn */
1749   17,                                   /* MOVE_RATIO */
1750   4,                                    /* cost for loading QImode using movzbl */
1751   {4, 4, 4},                            /* cost of loading integer registers
1752                                            in QImode, HImode and SImode.
1753                                            Relative to reg-reg move (2).  */
1754   {4, 4, 4},                            /* cost of storing integer registers */
1755   4,                                    /* cost of reg,reg fld/fst */
1756   {12, 12, 12},                         /* cost of loading fp registers
1757                                            in SFmode, DFmode and XFmode */
1758   {6, 6, 8},                            /* cost of storing fp registers
1759                                            in SFmode, DFmode and XFmode */
1760   2,                                    /* cost of moving MMX register */
1761   {8, 8},                               /* cost of loading MMX registers
1762                                            in SImode and DImode */
1763   {8, 8},                               /* cost of storing MMX registers
1764                                            in SImode and DImode */
1765   2,                                    /* cost of moving SSE register */
1766   {8, 8, 8},                            /* cost of loading SSE registers
1767                                            in SImode, DImode and TImode */
1768   {8, 8, 8},                            /* cost of storing SSE registers
1769                                            in SImode, DImode and TImode */
1770   5,                                    /* MMX or SSE register to integer */
1771   32,                                   /* size of l1 cache.  */
1772   256,                                  /* size of l2 cache.  */
1773   64,                                   /* size of prefetch block */
1774   6,                                    /* number of parallel prefetches */
1775   3,                                    /* Branch cost */
1776   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1777   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1778   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1779   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1780   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1781   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1782
1783   /* stringop_algs for memcpy.  
1784      SSE loops works best on Atom, but fall back into non-SSE unrolled loop variant
1785      if that fails.  */
1786   {{{libcall, {{4096, sse_loop}, {4096, unrolled_loop}, {-1, libcall}}}, /* Known alignment.  */
1787     {libcall, {{4096, sse_loop}, {4096, unrolled_loop}, {-1, libcall}}}},
1788    {{libcall, {{2048, sse_loop}, {2048, unrolled_loop}, {-1, libcall}}}, /* Unknown alignment.  */
1789     {libcall, {{2048, sse_loop}, {2048, unrolled_loop},
1790                {-1, libcall}}}}},
1791
1792   /* stringop_algs for memset.  */
1793   {{{libcall, {{4096, sse_loop}, {4096, unrolled_loop}, {-1, libcall}}}, /* Known alignment.  */
1794     {libcall, {{4096, sse_loop}, {4096, unrolled_loop}, {-1, libcall}}}},
1795    {{libcall, {{1024, sse_loop}, {1024, unrolled_loop},  /* Unknown alignment.  */
1796                {-1, libcall}}},
1797     {libcall, {{2048, sse_loop}, {2048, unrolled_loop},
1798                {-1, libcall}}}}},
1799   1,                                    /* scalar_stmt_cost.  */
1800   1,                                    /* scalar load_cost.  */
1801   1,                                    /* scalar_store_cost.  */
1802   1,                                    /* vec_stmt_cost.  */
1803   1,                                    /* vec_to_scalar_cost.  */
1804   1,                                    /* scalar_to_vec_cost.  */
1805   1,                                    /* vec_align_load_cost.  */
1806   2,                                    /* vec_unalign_load_cost.  */
1807   1,                                    /* vec_store_cost.  */
1808   3,                                    /* cond_taken_branch_cost.  */
1809   1,                                    /* cond_not_taken_branch_cost.  */
1810 };
1811
1812 /* Core should produce code tuned for core variants.  */
1813 static const
1814 struct processor_costs core_cost = {
1815   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1816   /* On all chips taken into consideration lea is 2 cycles and more.  With
1817      this cost however our current implementation of synth_mult results in
1818      use of unnecessary temporary registers causing regression on several
1819      SPECfp benchmarks.  */
1820   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1821   COSTS_N_INSNS (1),                    /* variable shift costs */
1822   COSTS_N_INSNS (1),                    /* constant shift costs */
1823   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1824    COSTS_N_INSNS (4),                   /*                               HI */
1825    COSTS_N_INSNS (3),                   /*                               SI */
1826    COSTS_N_INSNS (4),                   /*                               DI */
1827    COSTS_N_INSNS (2)},                  /*                            other */
1828   0,                                    /* cost of multiply per each bit set */
1829   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1830    COSTS_N_INSNS (26),                  /*                          HI */
1831    COSTS_N_INSNS (42),                  /*                          SI */
1832    COSTS_N_INSNS (74),                  /*                          DI */
1833    COSTS_N_INSNS (74)},                 /*                          other */
1834   COSTS_N_INSNS (1),                    /* cost of movsx */
1835   COSTS_N_INSNS (1),                    /* cost of movzx */
1836   8,                                    /* "large" insn */
1837   17,                                   /* MOVE_RATIO */
1838   4,                                 /* cost for loading QImode using movzbl */
1839   {4, 4, 4},                            /* cost of loading integer registers
1840                                            in QImode, HImode and SImode.
1841                                            Relative to reg-reg move (2).  */
1842   {4, 4, 4},                            /* cost of storing integer registers */
1843   4,                                    /* cost of reg,reg fld/fst */
1844   {12, 12, 12},                         /* cost of loading fp registers
1845                                            in SFmode, DFmode and XFmode */
1846   {6, 6, 8},                            /* cost of storing fp registers
1847                                            in SFmode, DFmode and XFmode */
1848   2,                                    /* cost of moving MMX register */
1849   {8, 8},                               /* cost of loading MMX registers
1850                                            in SImode and DImode */
1851   {8, 8},                               /* cost of storing MMX registers
1852                                            in SImode and DImode */
1853   2,                                    /* cost of moving SSE register */
1854   {8, 8, 8},                            /* cost of loading SSE registers
1855                                            in SImode, DImode and TImode */
1856   {8, 8, 8},                            /* cost of storing SSE registers
1857                                            in SImode, DImode and TImode */
1858   5,                                    /* MMX or SSE register to integer */
1859   32,                                   /* size of l1 cache.  */
1860   512,                                  /* size of l2 cache.  */
1861   64,                                   /* size of prefetch block */
1862   6,                                    /* number of parallel prefetches */
1863   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1864      value is increased to perhaps more appropriate value of 5.  */
1865   3,                                    /* Branch cost */
1866   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1867   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1868   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1869   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1870   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1871   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1872
1873   /* stringop_algs for memcpy.  */
1874   {{{libcall, {{16, loop}, {24, unrolled_loop}, {1024, rep_prefix_4_byte}, {-1, libcall}}}, /* Known alignment.  */
1875     {libcall, {{16, loop}, {24, unrolled_loop}, {1024, rep_prefix_8_byte}, {-1, libcall}}}},
1876    {{libcall, {{16, loop}, {24, unrolled_loop}, {1024, rep_prefix_4_byte}, {-1, libcall}}}, /* Unknown alignment.  */
1877     {libcall, {{16, loop}, {24, unrolled_loop}, {1024, rep_prefix_8_byte}, {-1, libcall}}}}},
1878
1879   /* stringop_algs for memset.  */
1880   {{{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}}, /* Known alignment.  */
1881     {libcall, {{256, rep_prefix_8_byte}, {-1, libcall}}}},
1882    {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}}, /* Unknown alignment.  */
1883     {libcall, {{256, rep_prefix_8_byte}, {-1, libcall}}}}},
1884   1,                                    /* scalar_stmt_cost.  */
1885   1,                                    /* scalar load_cost.  */
1886   1,                                    /* scalar_store_cost.  */
1887   1,                                    /* vec_stmt_cost.  */
1888   1,                                    /* vec_to_scalar_cost.  */
1889   1,                                    /* scalar_to_vec_cost.  */
1890   1,                                    /* vec_align_load_cost.  */
1891   2,                                    /* vec_unalign_load_cost.  */
1892   1,                                    /* vec_store_cost.  */
1893   3,                                    /* cond_taken_branch_cost.  */
1894   1,                                    /* cond_not_taken_branch_cost.  */
1895 };
1896
1897 /* Generic64 should produce code tuned for Nocona, Core,  K8, Amdfam10 and buldozer.  */
1898 static const
1899 struct processor_costs generic64_cost = {
1900   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1901   /* On all chips taken into consideration lea is 2 cycles and more.  With
1902      this cost however our current implementation of synth_mult results in
1903      use of unnecessary temporary registers causing regression on several
1904      SPECfp benchmarks.  */
1905   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1906   COSTS_N_INSNS (1),                    /* variable shift costs */
1907   COSTS_N_INSNS (1),                    /* constant shift costs */
1908   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1909    COSTS_N_INSNS (4),                   /*                               HI */
1910    COSTS_N_INSNS (3),                   /*                               SI */
1911    COSTS_N_INSNS (4),                   /*                               DI */
1912    COSTS_N_INSNS (2)},                  /*                            other */
1913   0,                                    /* cost of multiply per each bit set */
1914   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1915    COSTS_N_INSNS (26),                  /*                          HI */
1916    COSTS_N_INSNS (42),                  /*                          SI */
1917    COSTS_N_INSNS (74),                  /*                          DI */
1918    COSTS_N_INSNS (74)},                 /*                          other */
1919   COSTS_N_INSNS (1),                    /* cost of movsx */
1920   COSTS_N_INSNS (1),                    /* cost of movzx */
1921   8,                                    /* "large" insn */
1922   17,                                   /* MOVE_RATIO */
1923   4,                                 /* cost for loading QImode using movzbl */
1924   {4, 4, 4},                            /* cost of loading integer registers
1925                                            in QImode, HImode and SImode.
1926                                            Relative to reg-reg move (2).  */
1927   {4, 4, 4},                            /* cost of storing integer registers */
1928   4,                                    /* cost of reg,reg fld/fst */
1929   {12, 12, 12},                         /* cost of loading fp registers
1930                                            in SFmode, DFmode and XFmode */
1931   {6, 6, 8},                            /* cost of storing fp registers
1932                                            in SFmode, DFmode and XFmode */
1933   2,                                    /* cost of moving MMX register */
1934   {8, 8},                               /* cost of loading MMX registers
1935                                            in SImode and DImode */
1936   {8, 8},                               /* cost of storing MMX registers
1937                                            in SImode and DImode */
1938   2,                                    /* cost of moving SSE register */
1939   {8, 8, 8},                            /* cost of loading SSE registers
1940                                            in SImode, DImode and TImode */
1941   {8, 8, 8},                            /* cost of storing SSE registers
1942                                            in SImode, DImode and TImode */
1943   5,                                    /* MMX or SSE register to integer */
1944   32,                                   /* size of l1 cache.  */
1945   512,                                  /* size of l2 cache.  */
1946   64,                                   /* size of prefetch block */
1947   6,                                    /* number of parallel prefetches */
1948   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1949      value is increased to perhaps more appropriate value of 5.  */
1950   3,                                    /* Branch cost */
1951   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1952   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1953   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1954   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1955   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1956   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1957
1958   {{DUMMY_STRINGOP_ALGS,
1959     {libcall, {{16, rep_prefix_4_byte}, {128, rep_prefix_8_byte}, {4096, rep_prefix_1_byte}, {-1, libcall}}}},
1960    {DUMMY_STRINGOP_ALGS,
1961     {libcall, {{128, rep_prefix_4_byte}, {4096, rep_prefix_1_byte}, {-1, libcall}}}}},
1962
1963   {{DUMMY_STRINGOP_ALGS,
1964     {libcall, {{16, rep_prefix_4_byte}, {512, unrolled_loop}, {4096, rep_prefix_1_byte}, {-1, libcall}}}},
1965    {DUMMY_STRINGOP_ALGS,
1966     {libcall, {{16, rep_prefix_4_byte}, {512, unrolled_loop}, {4096, rep_prefix_1_byte}, {-1, libcall}}}}},
1967   1,                                    /* scalar_stmt_cost.  */
1968   1,                                    /* scalar load_cost.  */
1969   1,                                    /* scalar_store_cost.  */
1970   1,                                    /* vec_stmt_cost.  */
1971   1,                                    /* vec_to_scalar_cost.  */
1972   1,                                    /* scalar_to_vec_cost.  */
1973   1,                                    /* vec_align_load_cost.  */
1974   2,                                    /* vec_unalign_load_cost.  */
1975   1,                                    /* vec_store_cost.  */
1976   3,                                    /* cond_taken_branch_cost.  */
1977   1,                                    /* cond_not_taken_branch_cost.  */
1978 };
1979
1980 /* Generic32 should produce code tuned for PPro, Pentium4, Nocona, Core
1981    Athlon, K8, amdfam10, buldozer.  */
1982 static const
1983 struct processor_costs generic32_cost = {
1984   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1985   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1986   COSTS_N_INSNS (1),                    /* variable shift costs */
1987   COSTS_N_INSNS (1),                    /* constant shift costs */
1988   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1989    COSTS_N_INSNS (4),                   /*                               HI */
1990    COSTS_N_INSNS (3),                   /*                               SI */
1991    COSTS_N_INSNS (4),                   /*                               DI */
1992    COSTS_N_INSNS (2)},                  /*                            other */
1993   0,                                    /* cost of multiply per each bit set */
1994   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1995    COSTS_N_INSNS (26),                  /*                          HI */
1996    COSTS_N_INSNS (42),                  /*                          SI */
1997    COSTS_N_INSNS (74),                  /*                          DI */
1998    COSTS_N_INSNS (74)},                 /*                          other */
1999   COSTS_N_INSNS (1),                    /* cost of movsx */
2000   COSTS_N_INSNS (1),                    /* cost of movzx */
2001   8,                                    /* "large" insn */
2002   17,                                   /* MOVE_RATIO */
2003   4,                                 /* cost for loading QImode using movzbl */
2004   {4, 4, 4},                            /* cost of loading integer registers
2005                                            in QImode, HImode and SImode.
2006                                            Relative to reg-reg move (2).  */
2007   {4, 4, 4},                            /* cost of storing integer registers */
2008   4,                                    /* cost of reg,reg fld/fst */
2009   {12, 12, 12},                         /* cost of loading fp registers
2010                                            in SFmode, DFmode and XFmode */
2011   {6, 6, 8},                            /* cost of storing fp registers
2012                                            in SFmode, DFmode and XFmode */
2013   2,                                    /* cost of moving MMX register */
2014   {8, 8},                               /* cost of loading MMX registers
2015                                            in SImode and DImode */
2016   {8, 8},                               /* cost of storing MMX registers
2017                                            in SImode and DImode */
2018   2,                                    /* cost of moving SSE register */
2019   {8, 8, 8},                            /* cost of loading SSE registers
2020                                            in SImode, DImode and TImode */
2021   {8, 8, 8},                            /* cost of storing SSE registers
2022                                            in SImode, DImode and TImode */
2023   5,                                    /* MMX or SSE register to integer */
2024   32,                                   /* size of l1 cache.  */
2025   256,                                  /* size of l2 cache.  */
2026   64,                                   /* size of prefetch block */
2027   6,                                    /* number of parallel prefetches */
2028   3,                                    /* Branch cost */
2029   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
2030   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
2031   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
2032   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
2033   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
2034   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
2035   /* stringop_algs for memcpy.  */
2036   {{{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
2037    DUMMY_STRINGOP_ALGS},
2038    {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
2039    DUMMY_STRINGOP_ALGS}},
2040   /* stringop_algs for memset.  */
2041   {{{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
2042    DUMMY_STRINGOP_ALGS},
2043    {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
2044    DUMMY_STRINGOP_ALGS}},
2045   1,                                    /* scalar_stmt_cost.  */
2046   1,                                    /* scalar load_cost.  */
2047   1,                                    /* scalar_store_cost.  */
2048   1,                                    /* vec_stmt_cost.  */
2049   1,                                    /* vec_to_scalar_cost.  */
2050   1,                                    /* scalar_to_vec_cost.  */
2051   1,                                    /* vec_align_load_cost.  */
2052   2,                                    /* vec_unalign_load_cost.  */
2053   1,                                    /* vec_store_cost.  */
2054   3,                                    /* cond_taken_branch_cost.  */
2055   1,                                    /* cond_not_taken_branch_cost.  */
2056 };
2057
2058 const struct processor_costs *ix86_cost = &pentium_cost;
2059
2060 /* Processor feature/optimization bitmasks.  */
2061 #define m_386 (1<<PROCESSOR_I386)
2062 #define m_486 (1<<PROCESSOR_I486)
2063 #define m_PENT (1<<PROCESSOR_PENTIUM)
2064 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
2065 #define m_PENT4 (1<<PROCESSOR_PENTIUM4)
2066 #define m_NOCONA (1<<PROCESSOR_NOCONA)
2067 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
2068 #define m_CORE2_32 (1<<PROCESSOR_CORE2_32)
2069 #define m_CORE2_64 (1<<PROCESSOR_CORE2_64)
2070 #define m_COREI7_32 (1<<PROCESSOR_COREI7_32)
2071 #define m_COREI7_64 (1<<PROCESSOR_COREI7_64)
2072 #define m_COREI7 (m_COREI7_32 | m_COREI7_64)
2073 #define m_CORE2I7_32 (m_CORE2_32 | m_COREI7_32)
2074 #define m_CORE2I7_64 (m_CORE2_64 | m_COREI7_64)
2075 #define m_CORE2I7 (m_CORE2I7_32 | m_CORE2I7_64)
2076 #define m_ATOM (1<<PROCESSOR_ATOM)
2077
2078 #define m_GEODE (1<<PROCESSOR_GEODE)
2079 #define m_K6 (1<<PROCESSOR_K6)
2080 #define m_K6_GEODE (m_K6 | m_GEODE)
2081 #define m_K8 (1<<PROCESSOR_K8)
2082 #define m_ATHLON (1<<PROCESSOR_ATHLON)
2083 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
2084 #define m_AMDFAM10 (1<<PROCESSOR_AMDFAM10)
2085 #define m_BDVER1 (1<<PROCESSOR_BDVER1)
2086 #define m_BDVER2 (1<<PROCESSOR_BDVER2)
2087 #define m_BDVER (m_BDVER1 | m_BDVER2)
2088 #define m_BTVER1 (1<<PROCESSOR_BTVER1)
2089 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1)
2090
2091 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
2092 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
2093
2094 /* Generic instruction choice should be common subset of supported CPUs
2095    (PPro/PENT4/NOCONA/CORE2/Athlon/K8).  */
2096 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
2097
2098 /* Feature tests against the various tunings.  */
2099 unsigned char ix86_tune_features[X86_TUNE_LAST];
2100
2101 /* Feature tests against the various tunings used to create ix86_tune_features
2102    based on the processor mask.  */
2103 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
2104   /* X86_TUNE_USE_LEAVE: Leave does not affect Nocona SPEC2000 results
2105      negatively, so enabling for Generic64 seems like good code size
2106      tradeoff.  We can't enable it for 32bit generic because it does not
2107      work well with PPro base chips.  */
2108   m_386 | m_CORE2I7_64 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC64,
2109
2110   /* X86_TUNE_PUSH_MEMORY */
2111   m_386 | m_P4_NOCONA | m_CORE2I7 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2112
2113   /* X86_TUNE_ZERO_EXTEND_WITH_AND */
2114   m_486 | m_PENT,
2115
2116   /* X86_TUNE_UNROLL_STRLEN */
2117   m_486 | m_PENT | m_PPRO | m_ATOM | m_CORE2I7 | m_K6 | m_AMD_MULTIPLE | m_GENERIC,
2118
2119   /* X86_TUNE_BRANCH_PREDICTION_HINTS: Branch hints were put in P4 based
2120      on simulation result. But after P4 was made, no performance benefit
2121      was observed with branch hints.  It also increases the code size.
2122      As a result, icc never generates branch hints.  */
2123   0,
2124
2125   /* X86_TUNE_DOUBLE_WITH_ADD */
2126   ~m_386,
2127
2128   /* X86_TUNE_USE_SAHF */
2129   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC,
2130
2131   /* X86_TUNE_MOVX: Enable to zero extend integer registers to avoid
2132      partial dependencies.  */
2133   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE  | m_GENERIC,
2134
2135   /* X86_TUNE_PARTIAL_REG_STALL: We probably ought to watch for partial
2136      register stalls on Generic32 compilation setting as well.  However
2137      in current implementation the partial register stalls are not eliminated
2138      very well - they can be introduced via subregs synthesized by combine
2139      and can happen in caller/callee saving sequences.  Because this option
2140      pays back little on PPro based chips and is in conflict with partial reg
2141      dependencies used by Athlon/P4 based chips, it is better to leave it off
2142      for generic32 for now.  */
2143   m_PPRO,
2144
2145   /* X86_TUNE_PARTIAL_FLAG_REG_STALL */
2146   m_CORE2I7 | m_GENERIC,
2147
2148   /* X86_TUNE_USE_HIMODE_FIOP */
2149   m_386 | m_486 | m_K6_GEODE,
2150
2151   /* X86_TUNE_USE_SIMODE_FIOP */
2152   ~(m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC),
2153
2154   /* X86_TUNE_USE_MOV0 */
2155   m_K6,
2156
2157   /* X86_TUNE_USE_CLTD */
2158   ~(m_PENT | m_CORE2I7 | m_ATOM | m_K6 | m_GENERIC),
2159
2160   /* X86_TUNE_USE_XCHGB: Use xchgb %rh,%rl instead of rolw/rorw $8,rx.  */
2161   m_PENT4,
2162
2163   /* X86_TUNE_SPLIT_LONG_MOVES */
2164   m_PPRO,
2165
2166   /* X86_TUNE_READ_MODIFY_WRITE */
2167   ~m_PENT,
2168
2169   /* X86_TUNE_READ_MODIFY */
2170   ~(m_PENT | m_PPRO),
2171
2172   /* X86_TUNE_PROMOTE_QIMODE */
2173   m_386 | m_486 | m_PENT | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2174
2175   /* X86_TUNE_FAST_PREFIX */
2176   ~(m_386 | m_486 | m_PENT),
2177
2178   /* X86_TUNE_SINGLE_STRINGOP */
2179   m_386 | m_P4_NOCONA,
2180
2181   /* X86_TUNE_QIMODE_MATH */
2182   ~0,
2183
2184   /* X86_TUNE_HIMODE_MATH: On PPro this flag is meant to avoid partial
2185      register stalls.  Just like X86_TUNE_PARTIAL_REG_STALL this option
2186      might be considered for Generic32 if our scheme for avoiding partial
2187      stalls was more effective.  */
2188   ~m_PPRO,
2189
2190   /* X86_TUNE_PROMOTE_QI_REGS */
2191   0,
2192
2193   /* X86_TUNE_PROMOTE_HI_REGS */
2194   m_PPRO,
2195
2196   /* X86_TUNE_SINGLE_POP: Enable if single pop insn is preferred
2197      over esp addition.  */
2198   m_386 | m_486 | m_PENT | m_PPRO,
2199
2200   /* X86_TUNE_DOUBLE_POP: Enable if double pop insn is preferred
2201      over esp addition.  */
2202   m_PENT,
2203
2204   /* X86_TUNE_SINGLE_PUSH: Enable if single push insn is preferred
2205      over esp subtraction.  */
2206   m_386 | m_486 | m_PENT | m_K6_GEODE,
2207
2208   /* X86_TUNE_DOUBLE_PUSH. Enable if double push insn is preferred
2209      over esp subtraction.  */
2210   m_PENT | m_K6_GEODE,
2211
2212   /* X86_TUNE_INTEGER_DFMODE_MOVES: Enable if integer moves are preferred
2213      for DFmode copies */
2214   ~(m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE | m_ATOM | m_GENERIC),
2215
2216   /* X86_TUNE_PARTIAL_REG_DEPENDENCY */
2217   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2218
2219   /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: In the Generic model we have a
2220      conflict here in between PPro/Pentium4 based chips that thread 128bit
2221      SSE registers as single units versus K8 based chips that divide SSE
2222      registers to two 64bit halves.  This knob promotes all store destinations
2223      to be 128bit to allow register renaming on 128bit SSE units, but usually
2224      results in one extra microop on 64bit SSE units.  Experimental results
2225      shows that disabling this option on P4 brings over 20% SPECfp regression,
2226      while enabling it on K8 brings roughly 2.4% regression that can be partly
2227      masked by careful scheduling of moves.  */
2228   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM  | m_AMDFAM10 | m_BDVER | m_GENERIC,
2229
2230   /* X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL */
2231   m_COREI7 | m_AMDFAM10 | m_BDVER | m_BTVER1,
2232
2233   /* X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL */
2234   m_COREI7 | m_BDVER,
2235
2236   /* X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL */
2237   m_BDVER ,
2238
2239   /* X86_TUNE_SSE_SPLIT_REGS: Set for machines where the type and dependencies
2240      are resolved on SSE register parts instead of whole registers, so we may
2241      maintain just lower part of scalar values in proper format leaving the
2242      upper part undefined.  */
2243   m_ATHLON_K8,
2244
2245   /* X86_TUNE_SSE_TYPELESS_STORES */
2246   m_AMD_MULTIPLE,
2247
2248   /* X86_TUNE_SSE_LOAD0_BY_PXOR */
2249   m_PPRO | m_P4_NOCONA,
2250
2251   /* X86_TUNE_MEMORY_MISMATCH_STALL */
2252   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2253
2254   /* X86_TUNE_PROLOGUE_USING_MOVE */
2255   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2256
2257   /* X86_TUNE_EPILOGUE_USING_MOVE */
2258   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2259
2260   /* X86_TUNE_SHIFT1 */
2261   ~m_486,
2262
2263   /* X86_TUNE_USE_FFREEP */
2264   m_AMD_MULTIPLE,
2265
2266   /* X86_TUNE_INTER_UNIT_MOVES */
2267   ~(m_AMD_MULTIPLE | m_GENERIC),
2268
2269   /* X86_TUNE_INTER_UNIT_CONVERSIONS */
2270   ~(m_AMDFAM10 | m_BDVER ),
2271
2272   /* X86_TUNE_FOUR_JUMP_LIMIT: Some CPU cores are not able to predict more
2273      than 4 branch instructions in the 16 byte window.  */
2274   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2275
2276   /* X86_TUNE_SCHEDULE */
2277   m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2278
2279   /* X86_TUNE_USE_BT */
2280   m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2281
2282   /* X86_TUNE_USE_INCDEC */
2283   ~(m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GENERIC),
2284
2285   /* X86_TUNE_PAD_RETURNS */
2286   m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC,
2287
2288   /* X86_TUNE_PAD_SHORT_FUNCTION: Pad short funtion.  */
2289   m_ATOM,
2290
2291   /* X86_TUNE_EXT_80387_CONSTANTS */
2292   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_ATHLON_K8 | m_GENERIC,
2293
2294   /* X86_TUNE_SHORTEN_X87_SSE */
2295   ~m_K8,
2296
2297   /* X86_TUNE_AVOID_VECTOR_DECODE */
2298   m_CORE2I7_64 | m_K8 | m_GENERIC64,
2299
2300   /* X86_TUNE_PROMOTE_HIMODE_IMUL: Modern CPUs have same latency for HImode
2301      and SImode multiply, but 386 and 486 do HImode multiply faster.  */
2302   ~(m_386 | m_486),
2303
2304   /* X86_TUNE_SLOW_IMUL_IMM32_MEM: Imul of 32-bit constant and memory is
2305      vector path on AMD machines.  */
2306   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2307
2308   /* X86_TUNE_SLOW_IMUL_IMM8: Imul of 8-bit constant is vector path on AMD
2309      machines.  */
2310   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2311
2312   /* X86_TUNE_MOVE_M1_VIA_OR: On pentiums, it is faster to load -1 via OR
2313      than a MOV.  */
2314   m_PENT,
2315
2316   /* X86_TUNE_NOT_UNPAIRABLE: NOT is not pairable on Pentium, while XOR is,
2317      but one byte longer.  */
2318   m_PENT,
2319
2320   /* X86_TUNE_NOT_VECTORMODE: On AMD K6, NOT is vector decoded with memory
2321      operand that cannot be represented using a modRM byte.  The XOR
2322      replacement is long decoded, so this split helps here as well.  */
2323   m_K6,
2324
2325   /* X86_TUNE_USE_VECTOR_FP_CONVERTS: Prefer vector packed SSE conversion
2326      from FP to FP. */
2327   m_CORE2I7 | m_AMDFAM10 | m_GENERIC,
2328
2329   /* X86_TUNE_USE_VECTOR_CONVERTS: Prefer vector packed SSE conversion
2330      from integer to FP. */
2331   m_AMDFAM10,
2332
2333   /* X86_TUNE_FUSE_CMP_AND_BRANCH: Fuse a compare or test instruction
2334      with a subsequent conditional jump instruction into a single
2335      compare-and-branch uop.  */
2336   m_BDVER,
2337
2338   /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
2339      will impact LEA instruction selection. */
2340   m_ATOM,
2341
2342   /* X86_TUNE_VECTORIZE_DOUBLE: Enable double precision vector
2343      instructions.  */
2344   ~m_ATOM,
2345
2346   /* X86_SOFTARE_PREFETCHING_BENEFICIAL: Enable software prefetching
2347      at -O3.  For the moment, the prefetching seems badly tuned for Intel
2348      chips.  */
2349   m_K6_GEODE | m_AMD_MULTIPLE,
2350
2351   /* X86_TUNE_AVX128_OPTIMAL: Enable 128-bit AVX instruction generation for
2352      the auto-vectorizer.  */
2353   m_BDVER,
2354
2355   /* X86_TUNE_REASSOC_INT_TO_PARALLEL: Try to produce parallel computations
2356      during reassociation of integer computation.  */
2357   m_ATOM,
2358
2359   /* X86_TUNE_REASSOC_FP_TO_PARALLEL: Try to produce parallel computations
2360      during reassociation of fp computation.  */
2361   m_ATOM
2362 };
2363
2364 /* Feature tests against the various architecture variations.  */
2365 unsigned char ix86_arch_features[X86_ARCH_LAST];
2366
2367 /* Feature tests against the various architecture variations, used to create
2368    ix86_arch_features based on the processor mask.  */
2369 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
2370   /* X86_ARCH_CMOVE: Conditional move was added for pentiumpro.  */
2371   ~(m_386 | m_486 | m_PENT | m_K6),
2372
2373   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
2374   ~m_386,
2375
2376   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
2377   ~(m_386 | m_486),
2378
2379   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
2380   ~m_386,
2381
2382   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
2383   ~m_386,
2384 };
2385
2386 static const unsigned int x86_accumulate_outgoing_args
2387   = m_PPRO | m_P4_NOCONA | m_ATOM | m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC;
2388
2389 static const unsigned int x86_arch_always_fancy_math_387
2390   = m_PENT | m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC;
2391
2392 static const unsigned int x86_avx256_split_unaligned_load
2393   = m_COREI7 | m_GENERIC;
2394
2395 static const unsigned int x86_avx256_split_unaligned_store
2396   = m_COREI7 | m_BDVER | m_GENERIC;
2397
2398 /* In case the average insn count for single function invocation is
2399    lower than this constant, emit fast (but longer) prologue and
2400    epilogue code.  */
2401 #define FAST_PROLOGUE_INSN_COUNT 20
2402
2403 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
2404 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
2405 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
2406 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
2407
2408 /* Array of the smallest class containing reg number REGNO, indexed by
2409    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
2410
2411 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
2412 {
2413   /* ax, dx, cx, bx */
2414   AREG, DREG, CREG, BREG,
2415   /* si, di, bp, sp */
2416   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
2417   /* FP registers */
2418   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
2419   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
2420   /* arg pointer */
2421   NON_Q_REGS,
2422   /* flags, fpsr, fpcr, frame */
2423   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
2424   /* SSE registers */
2425   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2426   SSE_REGS, SSE_REGS,
2427   /* MMX registers */
2428   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
2429   MMX_REGS, MMX_REGS,
2430   /* REX registers */
2431   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2432   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2433   /* SSE REX registers */
2434   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2435   SSE_REGS, SSE_REGS,
2436 };
2437
2438 /* The "default" register map used in 32bit mode.  */
2439
2440 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
2441 {
2442   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
2443   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
2444   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2445   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
2446   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
2447   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2448   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2449 };
2450
2451 /* The "default" register map used in 64bit mode.  */
2452
2453 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
2454 {
2455   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
2456   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
2457   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2458   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
2459   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
2460   8,9,10,11,12,13,14,15,                /* extended integer registers */
2461   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
2462 };
2463
2464 /* Define the register numbers to be used in Dwarf debugging information.
2465    The SVR4 reference port C compiler uses the following register numbers
2466    in its Dwarf output code:
2467         0 for %eax (gcc regno = 0)
2468         1 for %ecx (gcc regno = 2)
2469         2 for %edx (gcc regno = 1)
2470         3 for %ebx (gcc regno = 3)
2471         4 for %esp (gcc regno = 7)
2472         5 for %ebp (gcc regno = 6)
2473         6 for %esi (gcc regno = 4)
2474         7 for %edi (gcc regno = 5)
2475    The following three DWARF register numbers are never generated by
2476    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
2477    believes these numbers have these meanings.
2478         8  for %eip    (no gcc equivalent)
2479         9  for %eflags (gcc regno = 17)
2480         10 for %trapno (no gcc equivalent)
2481    It is not at all clear how we should number the FP stack registers
2482    for the x86 architecture.  If the version of SDB on x86/svr4 were
2483    a bit less brain dead with respect to floating-point then we would
2484    have a precedent to follow with respect to DWARF register numbers
2485    for x86 FP registers, but the SDB on x86/svr4 is so completely
2486    broken with respect to FP registers that it is hardly worth thinking
2487    of it as something to strive for compatibility with.
2488    The version of x86/svr4 SDB I have at the moment does (partially)
2489    seem to believe that DWARF register number 11 is associated with
2490    the x86 register %st(0), but that's about all.  Higher DWARF
2491    register numbers don't seem to be associated with anything in
2492    particular, and even for DWARF regno 11, SDB only seems to under-
2493    stand that it should say that a variable lives in %st(0) (when
2494    asked via an `=' command) if we said it was in DWARF regno 11,
2495    but SDB still prints garbage when asked for the value of the
2496    variable in question (via a `/' command).
2497    (Also note that the labels SDB prints for various FP stack regs
2498    when doing an `x' command are all wrong.)
2499    Note that these problems generally don't affect the native SVR4
2500    C compiler because it doesn't allow the use of -O with -g and
2501    because when it is *not* optimizing, it allocates a memory
2502    location for each floating-point variable, and the memory
2503    location is what gets described in the DWARF AT_location
2504    attribute for the variable in question.
2505    Regardless of the severe mental illness of the x86/svr4 SDB, we
2506    do something sensible here and we use the following DWARF
2507    register numbers.  Note that these are all stack-top-relative
2508    numbers.
2509         11 for %st(0) (gcc regno = 8)
2510         12 for %st(1) (gcc regno = 9)
2511         13 for %st(2) (gcc regno = 10)
2512         14 for %st(3) (gcc regno = 11)
2513         15 for %st(4) (gcc regno = 12)
2514         16 for %st(5) (gcc regno = 13)
2515         17 for %st(6) (gcc regno = 14)
2516         18 for %st(7) (gcc regno = 15)
2517 */
2518 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
2519 {
2520   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
2521   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
2522   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
2523   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
2524   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
2525   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2526   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2527 };
2528
2529 /* Define parameter passing and return registers.  */
2530
2531 static int const x86_64_int_parameter_registers[6] =
2532 {
2533   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
2534 };
2535
2536 static int const x86_64_ms_abi_int_parameter_registers[4] =
2537 {
2538   CX_REG, DX_REG, R8_REG, R9_REG
2539 };
2540
2541 static int const x86_64_int_return_registers[4] =
2542 {
2543   AX_REG, DX_REG, DI_REG, SI_REG
2544 };
2545
2546 /* Define the structure for the machine field in struct function.  */
2547
2548 struct GTY(()) stack_local_entry {
2549   unsigned short mode;
2550   unsigned short n;
2551   rtx rtl;
2552   struct stack_local_entry *next;
2553 };
2554
2555 /* Structure describing stack frame layout.
2556    Stack grows downward:
2557
2558    [arguments]
2559                                         <- ARG_POINTER
2560    saved pc
2561
2562    saved static chain                   if ix86_static_chain_on_stack
2563
2564    saved frame pointer                  if frame_pointer_needed
2565                                         <- HARD_FRAME_POINTER
2566    [saved regs]
2567                                         <- regs_save_offset
2568    [padding0]
2569
2570    [saved SSE regs]
2571                                         <- sse_regs_save_offset
2572    [padding1]          |
2573                        |                <- FRAME_POINTER
2574    [va_arg registers]  |
2575                        |
2576    [frame]             |
2577                        |
2578    [padding2]          | = to_allocate
2579                                         <- STACK_POINTER
2580   */
2581 struct ix86_frame
2582 {
2583   int nsseregs;
2584   int nregs;
2585   int va_arg_size;
2586   int red_zone_size;
2587   int outgoing_arguments_size;
2588   HOST_WIDE_INT frame;
2589
2590   /* The offsets relative to ARG_POINTER.  */
2591   HOST_WIDE_INT frame_pointer_offset;
2592   HOST_WIDE_INT hard_frame_pointer_offset;
2593   HOST_WIDE_INT stack_pointer_offset;
2594   HOST_WIDE_INT hfp_save_offset;
2595   HOST_WIDE_INT reg_save_offset;
2596   HOST_WIDE_INT sse_reg_save_offset;
2597
2598   /* When save_regs_using_mov is set, emit prologue using
2599      move instead of push instructions.  */
2600   bool save_regs_using_mov;
2601 };
2602
2603 /* Which cpu are we scheduling for.  */
2604 enum attr_cpu ix86_schedule;
2605
2606 /* Which cpu are we optimizing for.  */
2607 enum processor_type ix86_tune;
2608
2609 /* Which instruction set architecture to use.  */
2610 enum processor_type ix86_arch;
2611
2612 /* true if sse prefetch instruction is not NOOP.  */
2613 int x86_prefetch_sse;
2614
2615 /* -mstackrealign option */
2616 static const char ix86_force_align_arg_pointer_string[]
2617   = "force_align_arg_pointer";
2618
2619 static rtx (*ix86_gen_leave) (void);
2620 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
2621 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
2622 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
2623 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
2624 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
2625 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
2626 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
2627 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
2628 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
2629
2630 /* Preferred alignment for stack boundary in bits.  */
2631 unsigned int ix86_preferred_stack_boundary;
2632
2633 /* Alignment for incoming stack boundary in bits specified at
2634    command line.  */
2635 static unsigned int ix86_user_incoming_stack_boundary;
2636
2637 /* Default alignment for incoming stack boundary in bits.  */
2638 static unsigned int ix86_default_incoming_stack_boundary;
2639
2640 /* Alignment for incoming stack boundary in bits.  */
2641 unsigned int ix86_incoming_stack_boundary;
2642
2643 /* Calling abi specific va_list type nodes.  */
2644 static GTY(()) tree sysv_va_list_type_node;
2645 static GTY(()) tree ms_va_list_type_node;
2646
2647 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
2648 char internal_label_prefix[16];
2649 int internal_label_prefix_len;
2650
2651 /* Fence to use after loop using movnt.  */
2652 tree x86_mfence;
2653
2654 /* Register class used for passing given 64bit part of the argument.
2655    These represent classes as documented by the PS ABI, with the exception
2656    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
2657    use SF or DFmode move instead of DImode to avoid reformatting penalties.
2658
2659    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
2660    whenever possible (upper half does contain padding).  */
2661 enum x86_64_reg_class
2662   {
2663     X86_64_NO_CLASS,
2664     X86_64_INTEGER_CLASS,
2665     X86_64_INTEGERSI_CLASS,
2666     X86_64_SSE_CLASS,
2667     X86_64_SSESF_CLASS,