OSDN Git Service

58f16e79563bdc023a4c98ad79dcd6b5ab6e88ea
[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   1,                                    /* scalar_stmt_cost.  */
569   1,                                    /* scalar load_cost.  */
570   1,                                    /* scalar_store_cost.  */
571   1,                                    /* vec_stmt_cost.  */
572   1,                                    /* vec_to_scalar_cost.  */
573   1,                                    /* scalar_to_vec_cost.  */
574   1,                                    /* vec_align_load_cost.  */
575   1,                                    /* vec_unalign_load_cost.  */
576   1,                                    /* vec_store_cost.  */
577   1,                                    /* cond_taken_branch_cost.  */
578   1,                                    /* cond_not_taken_branch_cost.  */
579 };
580
581 /* Processor costs (relative to an add) */
582 static const
583 struct processor_costs i386_cost = {    /* 386 specific costs */
584   COSTS_N_INSNS (1),                    /* cost of an add instruction */
585   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
586   COSTS_N_INSNS (3),                    /* variable shift costs */
587   COSTS_N_INSNS (2),                    /* constant shift costs */
588   {COSTS_N_INSNS (6),                   /* cost of starting multiply for QI */
589    COSTS_N_INSNS (6),                   /*                               HI */
590    COSTS_N_INSNS (6),                   /*                               SI */
591    COSTS_N_INSNS (6),                   /*                               DI */
592    COSTS_N_INSNS (6)},                  /*                            other */
593   COSTS_N_INSNS (1),                    /* cost of multiply per each bit set */
594   {COSTS_N_INSNS (23),                  /* cost of a divide/mod for QI */
595    COSTS_N_INSNS (23),                  /*                          HI */
596    COSTS_N_INSNS (23),                  /*                          SI */
597    COSTS_N_INSNS (23),                  /*                          DI */
598    COSTS_N_INSNS (23)},                 /*                          other */
599   COSTS_N_INSNS (3),                    /* cost of movsx */
600   COSTS_N_INSNS (2),                    /* cost of movzx */
601   15,                                   /* "large" insn */
602   3,                                    /* MOVE_RATIO */
603   4,                                 /* cost for loading QImode using movzbl */
604   {2, 4, 2},                            /* cost of loading integer registers
605                                            in QImode, HImode and SImode.
606                                            Relative to reg-reg move (2).  */
607   {2, 4, 2},                            /* cost of storing integer registers */
608   2,                                    /* cost of reg,reg fld/fst */
609   {8, 8, 8},                            /* cost of loading fp registers
610                                            in SFmode, DFmode and XFmode */
611   {8, 8, 8},                            /* cost of storing fp registers
612                                            in SFmode, DFmode and XFmode */
613   2,                                    /* cost of moving MMX register */
614   {4, 8},                               /* cost of loading MMX registers
615                                            in SImode and DImode */
616   {4, 8},                               /* cost of storing MMX registers
617                                            in SImode and DImode */
618   2,                                    /* cost of moving SSE register */
619   {4, 8, 16},                           /* cost of loading SSE registers
620                                            in SImode, DImode and TImode */
621   {4, 8, 16},                           /* cost of storing SSE registers
622                                            in SImode, DImode and TImode */
623   3,                                    /* MMX or SSE register to integer */
624   0,                                    /* size of l1 cache  */
625   0,                                    /* size of l2 cache  */
626   0,                                    /* size of prefetch block */
627   0,                                    /* number of parallel prefetches */
628   1,                                    /* Branch cost */
629   COSTS_N_INSNS (23),                   /* cost of FADD and FSUB insns.  */
630   COSTS_N_INSNS (27),                   /* cost of FMUL instruction.  */
631   COSTS_N_INSNS (88),                   /* cost of FDIV instruction.  */
632   COSTS_N_INSNS (22),                   /* cost of FABS instruction.  */
633   COSTS_N_INSNS (24),                   /* cost of FCHS instruction.  */
634   COSTS_N_INSNS (122),                  /* cost of FSQRT instruction.  */
635   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
636    DUMMY_STRINGOP_ALGS},
637   {{rep_prefix_1_byte, {{-1, rep_prefix_1_byte}}},
638    DUMMY_STRINGOP_ALGS},
639   1,                                    /* scalar_stmt_cost.  */
640   1,                                    /* scalar load_cost.  */
641   1,                                    /* scalar_store_cost.  */
642   1,                                    /* vec_stmt_cost.  */
643   1,                                    /* vec_to_scalar_cost.  */
644   1,                                    /* scalar_to_vec_cost.  */
645   1,                                    /* vec_align_load_cost.  */
646   2,                                    /* vec_unalign_load_cost.  */
647   1,                                    /* vec_store_cost.  */
648   3,                                    /* cond_taken_branch_cost.  */
649   1,                                    /* cond_not_taken_branch_cost.  */
650 };
651
652 static const
653 struct processor_costs i486_cost = {    /* 486 specific costs */
654   COSTS_N_INSNS (1),                    /* cost of an add instruction */
655   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
656   COSTS_N_INSNS (3),                    /* variable shift costs */
657   COSTS_N_INSNS (2),                    /* constant shift costs */
658   {COSTS_N_INSNS (12),                  /* cost of starting multiply for QI */
659    COSTS_N_INSNS (12),                  /*                               HI */
660    COSTS_N_INSNS (12),                  /*                               SI */
661    COSTS_N_INSNS (12),                  /*                               DI */
662    COSTS_N_INSNS (12)},                 /*                            other */
663   1,                                    /* cost of multiply per each bit set */
664   {COSTS_N_INSNS (40),                  /* cost of a divide/mod for QI */
665    COSTS_N_INSNS (40),                  /*                          HI */
666    COSTS_N_INSNS (40),                  /*                          SI */
667    COSTS_N_INSNS (40),                  /*                          DI */
668    COSTS_N_INSNS (40)},                 /*                          other */
669   COSTS_N_INSNS (3),                    /* cost of movsx */
670   COSTS_N_INSNS (2),                    /* cost of movzx */
671   15,                                   /* "large" insn */
672   3,                                    /* MOVE_RATIO */
673   4,                                 /* cost for loading QImode using movzbl */
674   {2, 4, 2},                            /* cost of loading integer registers
675                                            in QImode, HImode and SImode.
676                                            Relative to reg-reg move (2).  */
677   {2, 4, 2},                            /* cost of storing integer registers */
678   2,                                    /* cost of reg,reg fld/fst */
679   {8, 8, 8},                            /* cost of loading fp registers
680                                            in SFmode, DFmode and XFmode */
681   {8, 8, 8},                            /* cost of storing fp registers
682                                            in SFmode, DFmode and XFmode */
683   2,                                    /* cost of moving MMX register */
684   {4, 8},                               /* cost of loading MMX registers
685                                            in SImode and DImode */
686   {4, 8},                               /* cost of storing MMX registers
687                                            in SImode and DImode */
688   2,                                    /* cost of moving SSE register */
689   {4, 8, 16},                           /* cost of loading SSE registers
690                                            in SImode, DImode and TImode */
691   {4, 8, 16},                           /* cost of storing SSE registers
692                                            in SImode, DImode and TImode */
693   3,                                    /* MMX or SSE register to integer */
694   4,                                    /* size of l1 cache.  486 has 8kB cache
695                                            shared for code and data, so 4kB is
696                                            not really precise.  */
697   4,                                    /* size of l2 cache  */
698   0,                                    /* size of prefetch block */
699   0,                                    /* number of parallel prefetches */
700   1,                                    /* Branch cost */
701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
702   COSTS_N_INSNS (16),                   /* cost of FMUL instruction.  */
703   COSTS_N_INSNS (73),                   /* cost of FDIV instruction.  */
704   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
705   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
706   COSTS_N_INSNS (83),                   /* cost of FSQRT instruction.  */
707   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
708    DUMMY_STRINGOP_ALGS},
709   {{rep_prefix_4_byte, {{-1, rep_prefix_4_byte}}},
710    DUMMY_STRINGOP_ALGS},
711   1,                                    /* scalar_stmt_cost.  */
712   1,                                    /* scalar load_cost.  */
713   1,                                    /* scalar_store_cost.  */
714   1,                                    /* vec_stmt_cost.  */
715   1,                                    /* vec_to_scalar_cost.  */
716   1,                                    /* scalar_to_vec_cost.  */
717   1,                                    /* vec_align_load_cost.  */
718   2,                                    /* vec_unalign_load_cost.  */
719   1,                                    /* vec_store_cost.  */
720   3,                                    /* cond_taken_branch_cost.  */
721   1,                                    /* cond_not_taken_branch_cost.  */
722 };
723
724 static const
725 struct processor_costs pentium_cost = {
726   COSTS_N_INSNS (1),                    /* cost of an add instruction */
727   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
728   COSTS_N_INSNS (4),                    /* variable shift costs */
729   COSTS_N_INSNS (1),                    /* constant shift costs */
730   {COSTS_N_INSNS (11),                  /* cost of starting multiply for QI */
731    COSTS_N_INSNS (11),                  /*                               HI */
732    COSTS_N_INSNS (11),                  /*                               SI */
733    COSTS_N_INSNS (11),                  /*                               DI */
734    COSTS_N_INSNS (11)},                 /*                            other */
735   0,                                    /* cost of multiply per each bit set */
736   {COSTS_N_INSNS (25),                  /* cost of a divide/mod for QI */
737    COSTS_N_INSNS (25),                  /*                          HI */
738    COSTS_N_INSNS (25),                  /*                          SI */
739    COSTS_N_INSNS (25),                  /*                          DI */
740    COSTS_N_INSNS (25)},                 /*                          other */
741   COSTS_N_INSNS (3),                    /* cost of movsx */
742   COSTS_N_INSNS (2),                    /* cost of movzx */
743   8,                                    /* "large" insn */
744   6,                                    /* MOVE_RATIO */
745   6,                                 /* cost for loading QImode using movzbl */
746   {2, 4, 2},                            /* cost of loading integer registers
747                                            in QImode, HImode and SImode.
748                                            Relative to reg-reg move (2).  */
749   {2, 4, 2},                            /* cost of storing integer registers */
750   2,                                    /* cost of reg,reg fld/fst */
751   {2, 2, 6},                            /* cost of loading fp registers
752                                            in SFmode, DFmode and XFmode */
753   {4, 4, 6},                            /* cost of storing fp registers
754                                            in SFmode, DFmode and XFmode */
755   8,                                    /* cost of moving MMX register */
756   {8, 8},                               /* cost of loading MMX registers
757                                            in SImode and DImode */
758   {8, 8},                               /* cost of storing MMX registers
759                                            in SImode and DImode */
760   2,                                    /* cost of moving SSE register */
761   {4, 8, 16},                           /* cost of loading SSE registers
762                                            in SImode, DImode and TImode */
763   {4, 8, 16},                           /* cost of storing SSE registers
764                                            in SImode, DImode and TImode */
765   3,                                    /* MMX or SSE register to integer */
766   8,                                    /* size of l1 cache.  */
767   8,                                    /* size of l2 cache  */
768   0,                                    /* size of prefetch block */
769   0,                                    /* number of parallel prefetches */
770   2,                                    /* Branch cost */
771   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
772   COSTS_N_INSNS (3),                    /* cost of FMUL instruction.  */
773   COSTS_N_INSNS (39),                   /* cost of FDIV instruction.  */
774   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
775   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
776   COSTS_N_INSNS (70),                   /* cost of FSQRT instruction.  */
777   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
778    DUMMY_STRINGOP_ALGS},
779   {{libcall, {{-1, rep_prefix_4_byte}}},
780    DUMMY_STRINGOP_ALGS},
781   1,                                    /* scalar_stmt_cost.  */
782   1,                                    /* scalar load_cost.  */
783   1,                                    /* scalar_store_cost.  */
784   1,                                    /* vec_stmt_cost.  */
785   1,                                    /* vec_to_scalar_cost.  */
786   1,                                    /* scalar_to_vec_cost.  */
787   1,                                    /* vec_align_load_cost.  */
788   2,                                    /* vec_unalign_load_cost.  */
789   1,                                    /* vec_store_cost.  */
790   3,                                    /* cond_taken_branch_cost.  */
791   1,                                    /* cond_not_taken_branch_cost.  */
792 };
793
794 static const
795 struct processor_costs pentiumpro_cost = {
796   COSTS_N_INSNS (1),                    /* cost of an add instruction */
797   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
798   COSTS_N_INSNS (1),                    /* variable shift costs */
799   COSTS_N_INSNS (1),                    /* constant shift costs */
800   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
801    COSTS_N_INSNS (4),                   /*                               HI */
802    COSTS_N_INSNS (4),                   /*                               SI */
803    COSTS_N_INSNS (4),                   /*                               DI */
804    COSTS_N_INSNS (4)},                  /*                            other */
805   0,                                    /* cost of multiply per each bit set */
806   {COSTS_N_INSNS (17),                  /* cost of a divide/mod for QI */
807    COSTS_N_INSNS (17),                  /*                          HI */
808    COSTS_N_INSNS (17),                  /*                          SI */
809    COSTS_N_INSNS (17),                  /*                          DI */
810    COSTS_N_INSNS (17)},                 /*                          other */
811   COSTS_N_INSNS (1),                    /* cost of movsx */
812   COSTS_N_INSNS (1),                    /* cost of movzx */
813   8,                                    /* "large" insn */
814   6,                                    /* MOVE_RATIO */
815   2,                                 /* cost for loading QImode using movzbl */
816   {4, 4, 4},                            /* cost of loading integer registers
817                                            in QImode, HImode and SImode.
818                                            Relative to reg-reg move (2).  */
819   {2, 2, 2},                            /* cost of storing integer registers */
820   2,                                    /* cost of reg,reg fld/fst */
821   {2, 2, 6},                            /* cost of loading fp registers
822                                            in SFmode, DFmode and XFmode */
823   {4, 4, 6},                            /* cost of storing fp registers
824                                            in SFmode, DFmode and XFmode */
825   2,                                    /* cost of moving MMX register */
826   {2, 2},                               /* cost of loading MMX registers
827                                            in SImode and DImode */
828   {2, 2},                               /* cost of storing MMX registers
829                                            in SImode and DImode */
830   2,                                    /* cost of moving SSE register */
831   {2, 2, 8},                            /* cost of loading SSE registers
832                                            in SImode, DImode and TImode */
833   {2, 2, 8},                            /* cost of storing SSE registers
834                                            in SImode, DImode and TImode */
835   3,                                    /* MMX or SSE register to integer */
836   8,                                    /* size of l1 cache.  */
837   256,                                  /* size of l2 cache  */
838   32,                                   /* size of prefetch block */
839   6,                                    /* number of parallel prefetches */
840   2,                                    /* Branch cost */
841   COSTS_N_INSNS (3),                    /* cost of FADD and FSUB insns.  */
842   COSTS_N_INSNS (5),                    /* cost of FMUL instruction.  */
843   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
844   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
845   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
846   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
847   /* PentiumPro has optimized rep instructions for blocks aligned by 8 bytes
848      (we ensure the alignment).  For small blocks inline loop is still a
849      noticeable win, for bigger blocks either rep movsl or rep movsb is
850      way to go.  Rep movsb has apparently more expensive startup time in CPU,
851      but after 4K the difference is down in the noise.  */
852   {{rep_prefix_4_byte, {{128, loop}, {1024, unrolled_loop},
853                         {8192, rep_prefix_4_byte}, {-1, rep_prefix_1_byte}}},
854    DUMMY_STRINGOP_ALGS},
855   {{rep_prefix_4_byte, {{1024, unrolled_loop},
856                         {8192, rep_prefix_4_byte}, {-1, libcall}}},
857    DUMMY_STRINGOP_ALGS},
858   1,                                    /* scalar_stmt_cost.  */
859   1,                                    /* scalar load_cost.  */
860   1,                                    /* scalar_store_cost.  */
861   1,                                    /* vec_stmt_cost.  */
862   1,                                    /* vec_to_scalar_cost.  */
863   1,                                    /* scalar_to_vec_cost.  */
864   1,                                    /* vec_align_load_cost.  */
865   2,                                    /* vec_unalign_load_cost.  */
866   1,                                    /* vec_store_cost.  */
867   3,                                    /* cond_taken_branch_cost.  */
868   1,                                    /* cond_not_taken_branch_cost.  */
869 };
870
871 static const
872 struct processor_costs geode_cost = {
873   COSTS_N_INSNS (1),                    /* cost of an add instruction */
874   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
875   COSTS_N_INSNS (2),                    /* variable shift costs */
876   COSTS_N_INSNS (1),                    /* constant shift costs */
877   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
878    COSTS_N_INSNS (4),                   /*                               HI */
879    COSTS_N_INSNS (7),                   /*                               SI */
880    COSTS_N_INSNS (7),                   /*                               DI */
881    COSTS_N_INSNS (7)},                  /*                            other */
882   0,                                    /* cost of multiply per each bit set */
883   {COSTS_N_INSNS (15),                  /* cost of a divide/mod for QI */
884    COSTS_N_INSNS (23),                  /*                          HI */
885    COSTS_N_INSNS (39),                  /*                          SI */
886    COSTS_N_INSNS (39),                  /*                          DI */
887    COSTS_N_INSNS (39)},                 /*                          other */
888   COSTS_N_INSNS (1),                    /* cost of movsx */
889   COSTS_N_INSNS (1),                    /* cost of movzx */
890   8,                                    /* "large" insn */
891   4,                                    /* MOVE_RATIO */
892   1,                                 /* cost for loading QImode using movzbl */
893   {1, 1, 1},                            /* cost of loading integer registers
894                                            in QImode, HImode and SImode.
895                                            Relative to reg-reg move (2).  */
896   {1, 1, 1},                            /* cost of storing integer registers */
897   1,                                    /* cost of reg,reg fld/fst */
898   {1, 1, 1},                            /* cost of loading fp registers
899                                            in SFmode, DFmode and XFmode */
900   {4, 6, 6},                            /* cost of storing fp registers
901                                            in SFmode, DFmode and XFmode */
902
903   1,                                    /* cost of moving MMX register */
904   {1, 1},                               /* cost of loading MMX registers
905                                            in SImode and DImode */
906   {1, 1},                               /* cost of storing MMX registers
907                                            in SImode and DImode */
908   1,                                    /* cost of moving SSE register */
909   {1, 1, 1},                            /* cost of loading SSE registers
910                                            in SImode, DImode and TImode */
911   {1, 1, 1},                            /* cost of storing SSE registers
912                                            in SImode, DImode and TImode */
913   1,                                    /* MMX or SSE register to integer */
914   64,                                   /* size of l1 cache.  */
915   128,                                  /* size of l2 cache.  */
916   32,                                   /* size of prefetch block */
917   1,                                    /* number of parallel prefetches */
918   1,                                    /* Branch cost */
919   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
920   COSTS_N_INSNS (11),                   /* cost of FMUL instruction.  */
921   COSTS_N_INSNS (47),                   /* cost of FDIV instruction.  */
922   COSTS_N_INSNS (1),                    /* cost of FABS instruction.  */
923   COSTS_N_INSNS (1),                    /* cost of FCHS instruction.  */
924   COSTS_N_INSNS (54),                   /* cost of FSQRT instruction.  */
925   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
926    DUMMY_STRINGOP_ALGS},
927   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
928    DUMMY_STRINGOP_ALGS},
929   1,                                    /* scalar_stmt_cost.  */
930   1,                                    /* scalar load_cost.  */
931   1,                                    /* scalar_store_cost.  */
932   1,                                    /* vec_stmt_cost.  */
933   1,                                    /* vec_to_scalar_cost.  */
934   1,                                    /* scalar_to_vec_cost.  */
935   1,                                    /* vec_align_load_cost.  */
936   2,                                    /* vec_unalign_load_cost.  */
937   1,                                    /* vec_store_cost.  */
938   3,                                    /* cond_taken_branch_cost.  */
939   1,                                    /* cond_not_taken_branch_cost.  */
940 };
941
942 static const
943 struct processor_costs k6_cost = {
944   COSTS_N_INSNS (1),                    /* cost of an add instruction */
945   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
946   COSTS_N_INSNS (1),                    /* variable shift costs */
947   COSTS_N_INSNS (1),                    /* constant shift costs */
948   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
949    COSTS_N_INSNS (3),                   /*                               HI */
950    COSTS_N_INSNS (3),                   /*                               SI */
951    COSTS_N_INSNS (3),                   /*                               DI */
952    COSTS_N_INSNS (3)},                  /*                            other */
953   0,                                    /* cost of multiply per each bit set */
954   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
955    COSTS_N_INSNS (18),                  /*                          HI */
956    COSTS_N_INSNS (18),                  /*                          SI */
957    COSTS_N_INSNS (18),                  /*                          DI */
958    COSTS_N_INSNS (18)},                 /*                          other */
959   COSTS_N_INSNS (2),                    /* cost of movsx */
960   COSTS_N_INSNS (2),                    /* cost of movzx */
961   8,                                    /* "large" insn */
962   4,                                    /* MOVE_RATIO */
963   3,                                 /* cost for loading QImode using movzbl */
964   {4, 5, 4},                            /* cost of loading integer registers
965                                            in QImode, HImode and SImode.
966                                            Relative to reg-reg move (2).  */
967   {2, 3, 2},                            /* cost of storing integer registers */
968   4,                                    /* cost of reg,reg fld/fst */
969   {6, 6, 6},                            /* cost of loading fp registers
970                                            in SFmode, DFmode and XFmode */
971   {4, 4, 4},                            /* cost of storing fp registers
972                                            in SFmode, DFmode and XFmode */
973   2,                                    /* cost of moving MMX register */
974   {2, 2},                               /* cost of loading MMX registers
975                                            in SImode and DImode */
976   {2, 2},                               /* cost of storing MMX registers
977                                            in SImode and DImode */
978   2,                                    /* cost of moving SSE register */
979   {2, 2, 8},                            /* cost of loading SSE registers
980                                            in SImode, DImode and TImode */
981   {2, 2, 8},                            /* cost of storing SSE registers
982                                            in SImode, DImode and TImode */
983   6,                                    /* MMX or SSE register to integer */
984   32,                                   /* size of l1 cache.  */
985   32,                                   /* size of l2 cache.  Some models
986                                            have integrated l2 cache, but
987                                            optimizing for k6 is not important
988                                            enough to worry about that.  */
989   32,                                   /* size of prefetch block */
990   1,                                    /* number of parallel prefetches */
991   1,                                    /* Branch cost */
992   COSTS_N_INSNS (2),                    /* cost of FADD and FSUB insns.  */
993   COSTS_N_INSNS (2),                    /* cost of FMUL instruction.  */
994   COSTS_N_INSNS (56),                   /* cost of FDIV instruction.  */
995   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
996   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
997   COSTS_N_INSNS (56),                   /* cost of FSQRT instruction.  */
998   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
999    DUMMY_STRINGOP_ALGS},
1000   {{libcall, {{256, rep_prefix_4_byte}, {-1, libcall}}},
1001    DUMMY_STRINGOP_ALGS},
1002   1,                                    /* scalar_stmt_cost.  */
1003   1,                                    /* scalar load_cost.  */
1004   1,                                    /* scalar_store_cost.  */
1005   1,                                    /* vec_stmt_cost.  */
1006   1,                                    /* vec_to_scalar_cost.  */
1007   1,                                    /* scalar_to_vec_cost.  */
1008   1,                                    /* vec_align_load_cost.  */
1009   2,                                    /* vec_unalign_load_cost.  */
1010   1,                                    /* vec_store_cost.  */
1011   3,                                    /* cond_taken_branch_cost.  */
1012   1,                                    /* cond_not_taken_branch_cost.  */
1013 };
1014
1015 static const
1016 struct processor_costs athlon_cost = {
1017   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1018   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1019   COSTS_N_INSNS (1),                    /* variable shift costs */
1020   COSTS_N_INSNS (1),                    /* constant shift costs */
1021   {COSTS_N_INSNS (5),                   /* cost of starting multiply for QI */
1022    COSTS_N_INSNS (5),                   /*                               HI */
1023    COSTS_N_INSNS (5),                   /*                               SI */
1024    COSTS_N_INSNS (5),                   /*                               DI */
1025    COSTS_N_INSNS (5)},                  /*                            other */
1026   0,                                    /* cost of multiply per each bit set */
1027   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1028    COSTS_N_INSNS (26),                  /*                          HI */
1029    COSTS_N_INSNS (42),                  /*                          SI */
1030    COSTS_N_INSNS (74),                  /*                          DI */
1031    COSTS_N_INSNS (74)},                 /*                          other */
1032   COSTS_N_INSNS (1),                    /* cost of movsx */
1033   COSTS_N_INSNS (1),                    /* cost of movzx */
1034   8,                                    /* "large" insn */
1035   9,                                    /* MOVE_RATIO */
1036   4,                                 /* cost for loading QImode using movzbl */
1037   {3, 4, 3},                            /* cost of loading integer registers
1038                                            in QImode, HImode and SImode.
1039                                            Relative to reg-reg move (2).  */
1040   {3, 4, 3},                            /* cost of storing integer registers */
1041   4,                                    /* cost of reg,reg fld/fst */
1042   {4, 4, 12},                           /* cost of loading fp registers
1043                                            in SFmode, DFmode and XFmode */
1044   {6, 6, 8},                            /* cost of storing fp registers
1045                                            in SFmode, DFmode and XFmode */
1046   2,                                    /* cost of moving MMX register */
1047   {4, 4},                               /* cost of loading MMX registers
1048                                            in SImode and DImode */
1049   {4, 4},                               /* cost of storing MMX registers
1050                                            in SImode and DImode */
1051   2,                                    /* cost of moving SSE register */
1052   {4, 4, 6},                            /* cost of loading SSE registers
1053                                            in SImode, DImode and TImode */
1054   {4, 4, 5},                            /* cost of storing SSE registers
1055                                            in SImode, DImode and TImode */
1056   5,                                    /* MMX or SSE register to integer */
1057   64,                                   /* size of l1 cache.  */
1058   256,                                  /* size of l2 cache.  */
1059   64,                                   /* size of prefetch block */
1060   6,                                    /* number of parallel prefetches */
1061   5,                                    /* Branch cost */
1062   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1063   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1064   COSTS_N_INSNS (24),                   /* cost of FDIV instruction.  */
1065   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1066   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1067   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1068   /* For some reason, Athlon deals better with REP prefix (relative to loops)
1069      compared to K8. Alignment becomes important after 8 bytes for memcpy and
1070      128 bytes for memset.  */
1071   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1072    DUMMY_STRINGOP_ALGS},
1073   {{libcall, {{2048, rep_prefix_4_byte}, {-1, libcall}}},
1074    DUMMY_STRINGOP_ALGS},
1075   1,                                    /* scalar_stmt_cost.  */
1076   1,                                    /* scalar load_cost.  */
1077   1,                                    /* scalar_store_cost.  */
1078   1,                                    /* vec_stmt_cost.  */
1079   1,                                    /* vec_to_scalar_cost.  */
1080   1,                                    /* scalar_to_vec_cost.  */
1081   1,                                    /* vec_align_load_cost.  */
1082   2,                                    /* vec_unalign_load_cost.  */
1083   1,                                    /* vec_store_cost.  */
1084   3,                                    /* cond_taken_branch_cost.  */
1085   1,                                    /* cond_not_taken_branch_cost.  */
1086 };
1087
1088 static const
1089 struct processor_costs k8_cost = {
1090   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1091   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1092   COSTS_N_INSNS (1),                    /* variable shift costs */
1093   COSTS_N_INSNS (1),                    /* constant shift costs */
1094   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1095    COSTS_N_INSNS (4),                   /*                               HI */
1096    COSTS_N_INSNS (3),                   /*                               SI */
1097    COSTS_N_INSNS (4),                   /*                               DI */
1098    COSTS_N_INSNS (5)},                  /*                            other */
1099   0,                                    /* cost of multiply per each bit set */
1100   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1101    COSTS_N_INSNS (26),                  /*                          HI */
1102    COSTS_N_INSNS (42),                  /*                          SI */
1103    COSTS_N_INSNS (74),                  /*                          DI */
1104    COSTS_N_INSNS (74)},                 /*                          other */
1105   COSTS_N_INSNS (1),                    /* cost of movsx */
1106   COSTS_N_INSNS (1),                    /* cost of movzx */
1107   8,                                    /* "large" insn */
1108   9,                                    /* MOVE_RATIO */
1109   4,                                 /* cost for loading QImode using movzbl */
1110   {3, 4, 3},                            /* cost of loading integer registers
1111                                            in QImode, HImode and SImode.
1112                                            Relative to reg-reg move (2).  */
1113   {3, 4, 3},                            /* cost of storing integer registers */
1114   4,                                    /* cost of reg,reg fld/fst */
1115   {4, 4, 12},                           /* cost of loading fp registers
1116                                            in SFmode, DFmode and XFmode */
1117   {6, 6, 8},                            /* cost of storing fp registers
1118                                            in SFmode, DFmode and XFmode */
1119   2,                                    /* cost of moving MMX register */
1120   {3, 3},                               /* cost of loading MMX registers
1121                                            in SImode and DImode */
1122   {4, 4},                               /* cost of storing MMX registers
1123                                            in SImode and DImode */
1124   2,                                    /* cost of moving SSE register */
1125   {4, 3, 6},                            /* cost of loading SSE registers
1126                                            in SImode, DImode and TImode */
1127   {4, 4, 5},                            /* cost of storing SSE registers
1128                                            in SImode, DImode and TImode */
1129   5,                                    /* MMX or SSE register to integer */
1130   64,                                   /* size of l1 cache.  */
1131   512,                                  /* size of l2 cache.  */
1132   64,                                   /* size of prefetch block */
1133   /* New AMD processors never drop prefetches; if they cannot be performed
1134      immediately, they are queued.  We set number of simultaneous prefetches
1135      to a large constant to reflect this (it probably is not a good idea not
1136      to limit number of prefetches at all, as their execution also takes some
1137      time).  */
1138   100,                                  /* number of parallel prefetches */
1139   3,                                    /* Branch cost */
1140   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1141   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1142   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1143   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1144   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1145   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1146   /* K8 has optimized REP instruction for medium sized blocks, but for very
1147      small blocks it is better to use loop. For large blocks, libcall can
1148      do nontemporary accesses and beat inline considerably.  */
1149   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1150    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1151   {{libcall, {{8, loop}, {24, unrolled_loop},
1152               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1153    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1154   4,                                    /* scalar_stmt_cost.  */
1155   2,                                    /* scalar load_cost.  */
1156   2,                                    /* scalar_store_cost.  */
1157   5,                                    /* vec_stmt_cost.  */
1158   0,                                    /* vec_to_scalar_cost.  */
1159   2,                                    /* scalar_to_vec_cost.  */
1160   2,                                    /* vec_align_load_cost.  */
1161   3,                                    /* vec_unalign_load_cost.  */
1162   3,                                    /* vec_store_cost.  */
1163   3,                                    /* cond_taken_branch_cost.  */
1164   2,                                    /* cond_not_taken_branch_cost.  */
1165 };
1166
1167 struct processor_costs amdfam10_cost = {
1168   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1169   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1170   COSTS_N_INSNS (1),                    /* variable shift costs */
1171   COSTS_N_INSNS (1),                    /* constant shift costs */
1172   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1173    COSTS_N_INSNS (4),                   /*                               HI */
1174    COSTS_N_INSNS (3),                   /*                               SI */
1175    COSTS_N_INSNS (4),                   /*                               DI */
1176    COSTS_N_INSNS (5)},                  /*                            other */
1177   0,                                    /* cost of multiply per each bit set */
1178   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1179    COSTS_N_INSNS (35),                  /*                          HI */
1180    COSTS_N_INSNS (51),                  /*                          SI */
1181    COSTS_N_INSNS (83),                  /*                          DI */
1182    COSTS_N_INSNS (83)},                 /*                          other */
1183   COSTS_N_INSNS (1),                    /* cost of movsx */
1184   COSTS_N_INSNS (1),                    /* cost of movzx */
1185   8,                                    /* "large" insn */
1186   9,                                    /* MOVE_RATIO */
1187   4,                                 /* cost for loading QImode using movzbl */
1188   {3, 4, 3},                            /* cost of loading integer registers
1189                                            in QImode, HImode and SImode.
1190                                            Relative to reg-reg move (2).  */
1191   {3, 4, 3},                            /* cost of storing integer registers */
1192   4,                                    /* cost of reg,reg fld/fst */
1193   {4, 4, 12},                           /* cost of loading fp registers
1194                                            in SFmode, DFmode and XFmode */
1195   {6, 6, 8},                            /* cost of storing fp registers
1196                                            in SFmode, DFmode and XFmode */
1197   2,                                    /* cost of moving MMX register */
1198   {3, 3},                               /* cost of loading MMX registers
1199                                            in SImode and DImode */
1200   {4, 4},                               /* cost of storing MMX registers
1201                                            in SImode and DImode */
1202   2,                                    /* cost of moving SSE register */
1203   {4, 4, 3},                            /* cost of loading SSE registers
1204                                            in SImode, DImode and TImode */
1205   {4, 4, 5},                            /* cost of storing SSE registers
1206                                            in SImode, DImode and TImode */
1207   3,                                    /* MMX or SSE register to integer */
1208                                         /* On K8:
1209                                             MOVD reg64, xmmreg Double FSTORE 4
1210                                             MOVD reg32, xmmreg Double FSTORE 4
1211                                            On AMDFAM10:
1212                                             MOVD reg64, xmmreg Double FADD 3
1213                                                                1/1  1/1
1214                                             MOVD reg32, xmmreg Double FADD 3
1215                                                                1/1  1/1 */
1216   64,                                   /* size of l1 cache.  */
1217   512,                                  /* size of l2 cache.  */
1218   64,                                   /* size of prefetch block */
1219   /* New AMD processors never drop prefetches; if they cannot be performed
1220      immediately, they are queued.  We set number of simultaneous prefetches
1221      to a large constant to reflect this (it probably is not a good idea not
1222      to limit number of prefetches at all, as their execution also takes some
1223      time).  */
1224   100,                                  /* number of parallel prefetches */
1225   2,                                    /* Branch cost */
1226   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1227   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1228   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1229   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1230   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1231   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1232
1233   /* AMDFAM10 has optimized REP instruction for medium sized blocks, but for
1234      very small blocks it is better to use loop. For large blocks, libcall can
1235      do nontemporary accesses and beat inline considerably.  */
1236   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1237    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1238   {{libcall, {{8, loop}, {24, unrolled_loop},
1239               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1240    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1241   4,                                    /* scalar_stmt_cost.  */
1242   2,                                    /* scalar load_cost.  */
1243   2,                                    /* scalar_store_cost.  */
1244   6,                                    /* vec_stmt_cost.  */
1245   0,                                    /* vec_to_scalar_cost.  */
1246   2,                                    /* scalar_to_vec_cost.  */
1247   2,                                    /* vec_align_load_cost.  */
1248   2,                                    /* vec_unalign_load_cost.  */
1249   2,                                    /* vec_store_cost.  */
1250   2,                                    /* cond_taken_branch_cost.  */
1251   1,                                    /* cond_not_taken_branch_cost.  */
1252 };
1253
1254 struct processor_costs bdver1_cost = {
1255   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1256   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1257   COSTS_N_INSNS (1),                    /* variable shift costs */
1258   COSTS_N_INSNS (1),                    /* constant shift costs */
1259   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1260    COSTS_N_INSNS (4),                   /*                               HI */
1261    COSTS_N_INSNS (4),                   /*                               SI */
1262    COSTS_N_INSNS (6),                   /*                               DI */
1263    COSTS_N_INSNS (6)},                  /*                            other */
1264   0,                                    /* cost of multiply per each bit set */
1265   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1266    COSTS_N_INSNS (35),                  /*                          HI */
1267    COSTS_N_INSNS (51),                  /*                          SI */
1268    COSTS_N_INSNS (83),                  /*                          DI */
1269    COSTS_N_INSNS (83)},                 /*                          other */
1270   COSTS_N_INSNS (1),                    /* cost of movsx */
1271   COSTS_N_INSNS (1),                    /* cost of movzx */
1272   8,                                    /* "large" insn */
1273   9,                                    /* MOVE_RATIO */
1274   4,                                 /* cost for loading QImode using movzbl */
1275   {5, 5, 4},                            /* cost of loading integer registers
1276                                            in QImode, HImode and SImode.
1277                                            Relative to reg-reg move (2).  */
1278   {4, 4, 4},                            /* cost of storing integer registers */
1279   2,                                    /* cost of reg,reg fld/fst */
1280   {5, 5, 12},                           /* cost of loading fp registers
1281                                            in SFmode, DFmode and XFmode */
1282   {4, 4, 8},                            /* cost of storing fp registers
1283                                            in SFmode, DFmode and XFmode */
1284   2,                                    /* cost of moving MMX register */
1285   {4, 4},                               /* cost of loading MMX registers
1286                                            in SImode and DImode */
1287   {4, 4},                               /* cost of storing MMX registers
1288                                            in SImode and DImode */
1289   2,                                    /* cost of moving SSE register */
1290   {4, 4, 4},                            /* cost of loading SSE registers
1291                                            in SImode, DImode and TImode */
1292   {4, 4, 4},                            /* cost of storing SSE registers
1293                                            in SImode, DImode and TImode */
1294   2,                                    /* MMX or SSE register to integer */
1295                                         /* On K8:
1296                                             MOVD reg64, xmmreg Double FSTORE 4
1297                                             MOVD reg32, xmmreg Double FSTORE 4
1298                                            On AMDFAM10:
1299                                             MOVD reg64, xmmreg Double FADD 3
1300                                                                1/1  1/1
1301                                             MOVD reg32, xmmreg Double FADD 3
1302                                                                1/1  1/1 */
1303   16,                                   /* size of l1 cache.  */
1304   2048,                                 /* size of l2 cache.  */
1305   64,                                   /* size of prefetch block */
1306   /* New AMD processors never drop prefetches; if they cannot be performed
1307      immediately, they are queued.  We set number of simultaneous prefetches
1308      to a large constant to reflect this (it probably is not a good idea not
1309      to limit number of prefetches at all, as their execution also takes some
1310      time).  */
1311   100,                                  /* number of parallel prefetches */
1312   2,                                    /* Branch cost */
1313   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1314   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1315   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1316   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1317   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1318   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1319
1320   /*  BDVER1 has optimized REP instruction for medium sized blocks, but for
1321       very small blocks it is better to use loop. For large blocks, libcall
1322       can do nontemporary accesses and beat inline considerably.  */
1323   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1324    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1325   {{libcall, {{8, loop}, {24, unrolled_loop},
1326               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1327    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1328   6,                                    /* scalar_stmt_cost.  */
1329   4,                                    /* scalar load_cost.  */
1330   4,                                    /* scalar_store_cost.  */
1331   6,                                    /* vec_stmt_cost.  */
1332   0,                                    /* vec_to_scalar_cost.  */
1333   2,                                    /* scalar_to_vec_cost.  */
1334   4,                                    /* vec_align_load_cost.  */
1335   4,                                    /* vec_unalign_load_cost.  */
1336   4,                                    /* vec_store_cost.  */
1337   2,                                    /* cond_taken_branch_cost.  */
1338   1,                                    /* cond_not_taken_branch_cost.  */
1339 };
1340
1341 struct processor_costs bdver2_cost = {
1342   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1343   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1344   COSTS_N_INSNS (1),                    /* variable shift costs */
1345   COSTS_N_INSNS (1),                    /* constant shift costs */
1346   {COSTS_N_INSNS (4),                   /* cost of starting multiply for QI */
1347    COSTS_N_INSNS (4),                   /*                               HI */
1348    COSTS_N_INSNS (4),                   /*                               SI */
1349    COSTS_N_INSNS (6),                   /*                               DI */
1350    COSTS_N_INSNS (6)},                  /*                            other */
1351   0,                                    /* cost of multiply per each bit set */
1352   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1353    COSTS_N_INSNS (35),                  /*                          HI */
1354    COSTS_N_INSNS (51),                  /*                          SI */
1355    COSTS_N_INSNS (83),                  /*                          DI */
1356    COSTS_N_INSNS (83)},                 /*                          other */
1357   COSTS_N_INSNS (1),                    /* cost of movsx */
1358   COSTS_N_INSNS (1),                    /* cost of movzx */
1359   8,                                    /* "large" insn */
1360   9,                                    /* MOVE_RATIO */
1361   4,                                 /* cost for loading QImode using movzbl */
1362   {5, 5, 4},                            /* cost of loading integer registers
1363                                            in QImode, HImode and SImode.
1364                                            Relative to reg-reg move (2).  */
1365   {4, 4, 4},                            /* cost of storing integer registers */
1366   2,                                    /* cost of reg,reg fld/fst */
1367   {5, 5, 12},                           /* cost of loading fp registers
1368                                            in SFmode, DFmode and XFmode */
1369   {4, 4, 8},                            /* cost of storing fp registers
1370                                            in SFmode, DFmode and XFmode */
1371   2,                                    /* cost of moving MMX register */
1372   {4, 4},                               /* cost of loading MMX registers
1373                                            in SImode and DImode */
1374   {4, 4},                               /* cost of storing MMX registers
1375                                            in SImode and DImode */
1376   2,                                    /* cost of moving SSE register */
1377   {4, 4, 4},                            /* cost of loading SSE registers
1378                                            in SImode, DImode and TImode */
1379   {4, 4, 4},                            /* cost of storing SSE registers
1380                                            in SImode, DImode and TImode */
1381   2,                                    /* MMX or SSE register to integer */
1382                                         /* On K8:
1383                                             MOVD reg64, xmmreg Double FSTORE 4
1384                                             MOVD reg32, xmmreg Double FSTORE 4
1385                                            On AMDFAM10:
1386                                             MOVD reg64, xmmreg Double FADD 3
1387                                                                1/1  1/1
1388                                             MOVD reg32, xmmreg Double FADD 3
1389                                                                1/1  1/1 */
1390   16,                                   /* size of l1 cache.  */
1391   2048,                                 /* size of l2 cache.  */
1392   64,                                   /* size of prefetch block */
1393   /* New AMD processors never drop prefetches; if they cannot be performed
1394      immediately, they are queued.  We set number of simultaneous prefetches
1395      to a large constant to reflect this (it probably is not a good idea not
1396      to limit number of prefetches at all, as their execution also takes some
1397      time).  */
1398   100,                                  /* number of parallel prefetches */
1399   2,                                    /* Branch cost */
1400   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1401   COSTS_N_INSNS (6),                    /* cost of FMUL instruction.  */
1402   COSTS_N_INSNS (42),                   /* cost of FDIV instruction.  */
1403   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1404   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1405   COSTS_N_INSNS (52),                   /* cost of FSQRT instruction.  */
1406
1407   /*  BDVER2 has optimized REP instruction for medium sized blocks, but for
1408       very small blocks it is better to use loop. For large blocks, libcall
1409       can do nontemporary accesses and beat inline considerably.  */
1410   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1411    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1412   {{libcall, {{8, loop}, {24, unrolled_loop},
1413               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1414    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1415   6,                                    /* scalar_stmt_cost.  */
1416   4,                                    /* scalar load_cost.  */
1417   4,                                    /* scalar_store_cost.  */
1418   6,                                    /* vec_stmt_cost.  */
1419   0,                                    /* vec_to_scalar_cost.  */
1420   2,                                    /* scalar_to_vec_cost.  */
1421   4,                                    /* vec_align_load_cost.  */
1422   4,                                    /* vec_unalign_load_cost.  */
1423   4,                                    /* vec_store_cost.  */
1424   2,                                    /* cond_taken_branch_cost.  */
1425   1,                                    /* cond_not_taken_branch_cost.  */
1426 };
1427
1428 struct processor_costs btver1_cost = {
1429   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1430   COSTS_N_INSNS (2),                    /* cost of a lea instruction */
1431   COSTS_N_INSNS (1),                    /* variable shift costs */
1432   COSTS_N_INSNS (1),                    /* constant shift costs */
1433   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1434    COSTS_N_INSNS (4),                   /*                               HI */
1435    COSTS_N_INSNS (3),                   /*                               SI */
1436    COSTS_N_INSNS (4),                   /*                               DI */
1437    COSTS_N_INSNS (5)},                  /*                            other */
1438   0,                                    /* cost of multiply per each bit set */
1439   {COSTS_N_INSNS (19),                  /* cost of a divide/mod for QI */
1440    COSTS_N_INSNS (35),                  /*                          HI */
1441    COSTS_N_INSNS (51),                  /*                          SI */
1442    COSTS_N_INSNS (83),                  /*                          DI */
1443    COSTS_N_INSNS (83)},                 /*                          other */
1444   COSTS_N_INSNS (1),                    /* cost of movsx */
1445   COSTS_N_INSNS (1),                    /* cost of movzx */
1446   8,                                    /* "large" insn */
1447   9,                                    /* MOVE_RATIO */
1448   4,                                 /* cost for loading QImode using movzbl */
1449   {3, 4, 3},                            /* cost of loading integer registers
1450                                            in QImode, HImode and SImode.
1451                                            Relative to reg-reg move (2).  */
1452   {3, 4, 3},                            /* cost of storing integer registers */
1453   4,                                    /* cost of reg,reg fld/fst */
1454   {4, 4, 12},                           /* cost of loading fp registers
1455                                            in SFmode, DFmode and XFmode */
1456   {6, 6, 8},                            /* cost of storing fp registers
1457                                            in SFmode, DFmode and XFmode */
1458   2,                                    /* cost of moving MMX register */
1459   {3, 3},                               /* cost of loading MMX registers
1460                                            in SImode and DImode */
1461   {4, 4},                               /* cost of storing MMX registers
1462                                            in SImode and DImode */
1463   2,                                    /* cost of moving SSE register */
1464   {4, 4, 3},                            /* cost of loading SSE registers
1465                                            in SImode, DImode and TImode */
1466   {4, 4, 5},                            /* cost of storing SSE registers
1467                                            in SImode, DImode and TImode */
1468   3,                                    /* MMX or SSE register to integer */
1469                                         /* On K8:
1470                                            MOVD reg64, xmmreg Double FSTORE 4
1471                                            MOVD reg32, xmmreg Double FSTORE 4
1472                                            On AMDFAM10:
1473                                            MOVD reg64, xmmreg Double FADD 3
1474                                                                1/1  1/1
1475                                             MOVD reg32, xmmreg Double FADD 3
1476                                                                1/1  1/1 */
1477   32,                                   /* size of l1 cache.  */
1478   512,                                  /* size of l2 cache.  */
1479   64,                                   /* size of prefetch block */
1480   100,                                  /* number of parallel prefetches */
1481   2,                                    /* Branch cost */
1482   COSTS_N_INSNS (4),                    /* cost of FADD and FSUB insns.  */
1483   COSTS_N_INSNS (4),                    /* cost of FMUL instruction.  */
1484   COSTS_N_INSNS (19),                   /* cost of FDIV instruction.  */
1485   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1486   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1487   COSTS_N_INSNS (35),                   /* cost of FSQRT instruction.  */
1488
1489   /* BTVER1 has optimized REP instruction for medium sized blocks, but for
1490      very small blocks it is better to use loop. For large blocks, libcall can
1491      do nontemporary accesses and beat inline considerably.  */
1492   {{libcall, {{6, loop}, {14, unrolled_loop}, {-1, rep_prefix_4_byte}}},
1493    {libcall, {{16, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1494   {{libcall, {{8, loop}, {24, unrolled_loop},
1495               {2048, rep_prefix_4_byte}, {-1, libcall}}},
1496    {libcall, {{48, unrolled_loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1497   4,                                    /* scalar_stmt_cost.  */
1498   2,                                    /* scalar load_cost.  */
1499   2,                                    /* scalar_store_cost.  */
1500   6,                                    /* vec_stmt_cost.  */
1501   0,                                    /* vec_to_scalar_cost.  */
1502   2,                                    /* scalar_to_vec_cost.  */
1503   2,                                    /* vec_align_load_cost.  */
1504   2,                                    /* vec_unalign_load_cost.  */
1505   2,                                    /* vec_store_cost.  */
1506   2,                                    /* cond_taken_branch_cost.  */
1507   1,                                    /* cond_not_taken_branch_cost.  */
1508 };
1509
1510 static const
1511 struct processor_costs pentium4_cost = {
1512   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1513   COSTS_N_INSNS (3),                    /* cost of a lea instruction */
1514   COSTS_N_INSNS (4),                    /* variable shift costs */
1515   COSTS_N_INSNS (4),                    /* constant shift costs */
1516   {COSTS_N_INSNS (15),                  /* cost of starting multiply for QI */
1517    COSTS_N_INSNS (15),                  /*                               HI */
1518    COSTS_N_INSNS (15),                  /*                               SI */
1519    COSTS_N_INSNS (15),                  /*                               DI */
1520    COSTS_N_INSNS (15)},                 /*                            other */
1521   0,                                    /* cost of multiply per each bit set */
1522   {COSTS_N_INSNS (56),                  /* cost of a divide/mod for QI */
1523    COSTS_N_INSNS (56),                  /*                          HI */
1524    COSTS_N_INSNS (56),                  /*                          SI */
1525    COSTS_N_INSNS (56),                  /*                          DI */
1526    COSTS_N_INSNS (56)},                 /*                          other */
1527   COSTS_N_INSNS (1),                    /* cost of movsx */
1528   COSTS_N_INSNS (1),                    /* cost of movzx */
1529   16,                                   /* "large" insn */
1530   6,                                    /* MOVE_RATIO */
1531   2,                                 /* cost for loading QImode using movzbl */
1532   {4, 5, 4},                            /* cost of loading integer registers
1533                                            in QImode, HImode and SImode.
1534                                            Relative to reg-reg move (2).  */
1535   {2, 3, 2},                            /* cost of storing integer registers */
1536   2,                                    /* cost of reg,reg fld/fst */
1537   {2, 2, 6},                            /* cost of loading fp registers
1538                                            in SFmode, DFmode and XFmode */
1539   {4, 4, 6},                            /* cost of storing fp registers
1540                                            in SFmode, DFmode and XFmode */
1541   2,                                    /* cost of moving MMX register */
1542   {2, 2},                               /* cost of loading MMX registers
1543                                            in SImode and DImode */
1544   {2, 2},                               /* cost of storing MMX registers
1545                                            in SImode and DImode */
1546   12,                                   /* cost of moving SSE register */
1547   {12, 12, 12},                         /* cost of loading SSE registers
1548                                            in SImode, DImode and TImode */
1549   {2, 2, 8},                            /* cost of storing SSE registers
1550                                            in SImode, DImode and TImode */
1551   10,                                   /* MMX or SSE register to integer */
1552   8,                                    /* size of l1 cache.  */
1553   256,                                  /* size of l2 cache.  */
1554   64,                                   /* size of prefetch block */
1555   6,                                    /* number of parallel prefetches */
1556   2,                                    /* Branch cost */
1557   COSTS_N_INSNS (5),                    /* cost of FADD and FSUB insns.  */
1558   COSTS_N_INSNS (7),                    /* cost of FMUL instruction.  */
1559   COSTS_N_INSNS (43),                   /* cost of FDIV instruction.  */
1560   COSTS_N_INSNS (2),                    /* cost of FABS instruction.  */
1561   COSTS_N_INSNS (2),                    /* cost of FCHS instruction.  */
1562   COSTS_N_INSNS (43),                   /* cost of FSQRT instruction.  */
1563   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1564    DUMMY_STRINGOP_ALGS},
1565   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1566    {-1, libcall}}},
1567    DUMMY_STRINGOP_ALGS},
1568   1,                                    /* scalar_stmt_cost.  */
1569   1,                                    /* scalar load_cost.  */
1570   1,                                    /* scalar_store_cost.  */
1571   1,                                    /* vec_stmt_cost.  */
1572   1,                                    /* vec_to_scalar_cost.  */
1573   1,                                    /* scalar_to_vec_cost.  */
1574   1,                                    /* vec_align_load_cost.  */
1575   2,                                    /* vec_unalign_load_cost.  */
1576   1,                                    /* vec_store_cost.  */
1577   3,                                    /* cond_taken_branch_cost.  */
1578   1,                                    /* cond_not_taken_branch_cost.  */
1579 };
1580
1581 static const
1582 struct processor_costs nocona_cost = {
1583   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1584   COSTS_N_INSNS (1),                    /* cost of a lea instruction */
1585   COSTS_N_INSNS (1),                    /* variable shift costs */
1586   COSTS_N_INSNS (1),                    /* constant shift costs */
1587   {COSTS_N_INSNS (10),                  /* cost of starting multiply for QI */
1588    COSTS_N_INSNS (10),                  /*                               HI */
1589    COSTS_N_INSNS (10),                  /*                               SI */
1590    COSTS_N_INSNS (10),                  /*                               DI */
1591    COSTS_N_INSNS (10)},                 /*                            other */
1592   0,                                    /* cost of multiply per each bit set */
1593   {COSTS_N_INSNS (66),                  /* cost of a divide/mod for QI */
1594    COSTS_N_INSNS (66),                  /*                          HI */
1595    COSTS_N_INSNS (66),                  /*                          SI */
1596    COSTS_N_INSNS (66),                  /*                          DI */
1597    COSTS_N_INSNS (66)},                 /*                          other */
1598   COSTS_N_INSNS (1),                    /* cost of movsx */
1599   COSTS_N_INSNS (1),                    /* cost of movzx */
1600   16,                                   /* "large" insn */
1601   17,                                   /* MOVE_RATIO */
1602   4,                                 /* cost for loading QImode using movzbl */
1603   {4, 4, 4},                            /* cost of loading integer registers
1604                                            in QImode, HImode and SImode.
1605                                            Relative to reg-reg move (2).  */
1606   {4, 4, 4},                            /* cost of storing integer registers */
1607   3,                                    /* cost of reg,reg fld/fst */
1608   {12, 12, 12},                         /* cost of loading fp registers
1609                                            in SFmode, DFmode and XFmode */
1610   {4, 4, 4},                            /* cost of storing fp registers
1611                                            in SFmode, DFmode and XFmode */
1612   6,                                    /* cost of moving MMX register */
1613   {12, 12},                             /* cost of loading MMX registers
1614                                            in SImode and DImode */
1615   {12, 12},                             /* cost of storing MMX registers
1616                                            in SImode and DImode */
1617   6,                                    /* cost of moving SSE register */
1618   {12, 12, 12},                         /* cost of loading SSE registers
1619                                            in SImode, DImode and TImode */
1620   {12, 12, 12},                         /* cost of storing SSE registers
1621                                            in SImode, DImode and TImode */
1622   8,                                    /* MMX or SSE register to integer */
1623   8,                                    /* size of l1 cache.  */
1624   1024,                                 /* size of l2 cache.  */
1625   128,                                  /* size of prefetch block */
1626   8,                                    /* number of parallel prefetches */
1627   1,                                    /* Branch cost */
1628   COSTS_N_INSNS (6),                    /* cost of FADD and FSUB insns.  */
1629   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1630   COSTS_N_INSNS (40),                   /* cost of FDIV instruction.  */
1631   COSTS_N_INSNS (3),                    /* cost of FABS instruction.  */
1632   COSTS_N_INSNS (3),                    /* cost of FCHS instruction.  */
1633   COSTS_N_INSNS (44),                   /* cost of FSQRT instruction.  */
1634   {{libcall, {{12, loop_1_byte}, {-1, rep_prefix_4_byte}}},
1635    {libcall, {{32, loop}, {20000, rep_prefix_8_byte},
1636               {100000, unrolled_loop}, {-1, libcall}}}},
1637   {{libcall, {{6, loop_1_byte}, {48, loop}, {20480, rep_prefix_4_byte},
1638    {-1, libcall}}},
1639    {libcall, {{24, loop}, {64, unrolled_loop},
1640               {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1641   1,                                    /* scalar_stmt_cost.  */
1642   1,                                    /* scalar load_cost.  */
1643   1,                                    /* scalar_store_cost.  */
1644   1,                                    /* vec_stmt_cost.  */
1645   1,                                    /* vec_to_scalar_cost.  */
1646   1,                                    /* scalar_to_vec_cost.  */
1647   1,                                    /* vec_align_load_cost.  */
1648   2,                                    /* vec_unalign_load_cost.  */
1649   1,                                    /* vec_store_cost.  */
1650   3,                                    /* cond_taken_branch_cost.  */
1651   1,                                    /* cond_not_taken_branch_cost.  */
1652 };
1653
1654 static const
1655 struct processor_costs atom_cost = {
1656   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1657   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1658   COSTS_N_INSNS (1),                    /* variable shift costs */
1659   COSTS_N_INSNS (1),                    /* constant shift costs */
1660   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1661    COSTS_N_INSNS (4),                   /*                               HI */
1662    COSTS_N_INSNS (3),                   /*                               SI */
1663    COSTS_N_INSNS (4),                   /*                               DI */
1664    COSTS_N_INSNS (2)},                  /*                            other */
1665   0,                                    /* cost of multiply per each bit set */
1666   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1667    COSTS_N_INSNS (26),                  /*                          HI */
1668    COSTS_N_INSNS (42),                  /*                          SI */
1669    COSTS_N_INSNS (74),                  /*                          DI */
1670    COSTS_N_INSNS (74)},                 /*                          other */
1671   COSTS_N_INSNS (1),                    /* cost of movsx */
1672   COSTS_N_INSNS (1),                    /* cost of movzx */
1673   8,                                    /* "large" insn */
1674   17,                                   /* MOVE_RATIO */
1675   2,                                 /* cost for loading QImode using movzbl */
1676   {4, 4, 4},                            /* cost of loading integer registers
1677                                            in QImode, HImode and SImode.
1678                                            Relative to reg-reg move (2).  */
1679   {4, 4, 4},                            /* cost of storing integer registers */
1680   4,                                    /* cost of reg,reg fld/fst */
1681   {12, 12, 12},                         /* cost of loading fp registers
1682                                            in SFmode, DFmode and XFmode */
1683   {6, 6, 8},                            /* cost of storing fp registers
1684                                            in SFmode, DFmode and XFmode */
1685   2,                                    /* cost of moving MMX register */
1686   {8, 8},                               /* cost of loading MMX registers
1687                                            in SImode and DImode */
1688   {8, 8},                               /* cost of storing MMX registers
1689                                            in SImode and DImode */
1690   2,                                    /* cost of moving SSE register */
1691   {8, 8, 8},                            /* cost of loading SSE registers
1692                                            in SImode, DImode and TImode */
1693   {8, 8, 8},                            /* cost of storing SSE registers
1694                                            in SImode, DImode and TImode */
1695   5,                                    /* MMX or SSE register to integer */
1696   32,                                   /* size of l1 cache.  */
1697   256,                                  /* size of l2 cache.  */
1698   64,                                   /* size of prefetch block */
1699   6,                                    /* number of parallel prefetches */
1700   3,                                    /* Branch cost */
1701   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1702   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1703   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1704   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1705   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1706   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1707   {{libcall, {{11, loop}, {-1, rep_prefix_4_byte}}},
1708    {libcall, {{32, loop}, {64, rep_prefix_4_byte},
1709           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1710   {{libcall, {{8, loop}, {15, unrolled_loop},
1711           {2048, rep_prefix_4_byte}, {-1, libcall}}},
1712    {libcall, {{24, loop}, {32, unrolled_loop},
1713           {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1714   1,                                    /* scalar_stmt_cost.  */
1715   1,                                    /* scalar load_cost.  */
1716   1,                                    /* scalar_store_cost.  */
1717   1,                                    /* vec_stmt_cost.  */
1718   1,                                    /* vec_to_scalar_cost.  */
1719   1,                                    /* scalar_to_vec_cost.  */
1720   1,                                    /* vec_align_load_cost.  */
1721   2,                                    /* vec_unalign_load_cost.  */
1722   1,                                    /* vec_store_cost.  */
1723   3,                                    /* cond_taken_branch_cost.  */
1724   1,                                    /* cond_not_taken_branch_cost.  */
1725 };
1726
1727 /* Generic64 should produce code tuned for Nocona and K8.  */
1728 static const
1729 struct processor_costs generic64_cost = {
1730   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1731   /* On all chips taken into consideration lea is 2 cycles and more.  With
1732      this cost however our current implementation of synth_mult results in
1733      use of unnecessary temporary registers causing regression on several
1734      SPECfp benchmarks.  */
1735   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1736   COSTS_N_INSNS (1),                    /* variable shift costs */
1737   COSTS_N_INSNS (1),                    /* constant shift costs */
1738   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1739    COSTS_N_INSNS (4),                   /*                               HI */
1740    COSTS_N_INSNS (3),                   /*                               SI */
1741    COSTS_N_INSNS (4),                   /*                               DI */
1742    COSTS_N_INSNS (2)},                  /*                            other */
1743   0,                                    /* cost of multiply per each bit set */
1744   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1745    COSTS_N_INSNS (26),                  /*                          HI */
1746    COSTS_N_INSNS (42),                  /*                          SI */
1747    COSTS_N_INSNS (74),                  /*                          DI */
1748    COSTS_N_INSNS (74)},                 /*                          other */
1749   COSTS_N_INSNS (1),                    /* cost of movsx */
1750   COSTS_N_INSNS (1),                    /* cost of movzx */
1751   8,                                    /* "large" insn */
1752   17,                                   /* MOVE_RATIO */
1753   4,                                 /* cost for loading QImode using movzbl */
1754   {4, 4, 4},                            /* cost of loading integer registers
1755                                            in QImode, HImode and SImode.
1756                                            Relative to reg-reg move (2).  */
1757   {4, 4, 4},                            /* cost of storing integer registers */
1758   4,                                    /* cost of reg,reg fld/fst */
1759   {12, 12, 12},                         /* cost of loading fp registers
1760                                            in SFmode, DFmode and XFmode */
1761   {6, 6, 8},                            /* cost of storing fp registers
1762                                            in SFmode, DFmode and XFmode */
1763   2,                                    /* cost of moving MMX register */
1764   {8, 8},                               /* cost of loading MMX registers
1765                                            in SImode and DImode */
1766   {8, 8},                               /* cost of storing MMX registers
1767                                            in SImode and DImode */
1768   2,                                    /* cost of moving SSE register */
1769   {8, 8, 8},                            /* cost of loading SSE registers
1770                                            in SImode, DImode and TImode */
1771   {8, 8, 8},                            /* cost of storing SSE registers
1772                                            in SImode, DImode and TImode */
1773   5,                                    /* MMX or SSE register to integer */
1774   32,                                   /* size of l1 cache.  */
1775   512,                                  /* size of l2 cache.  */
1776   64,                                   /* size of prefetch block */
1777   6,                                    /* number of parallel prefetches */
1778   /* Benchmarks shows large regressions on K8 sixtrack benchmark when this
1779      value is increased to perhaps more appropriate value of 5.  */
1780   3,                                    /* Branch cost */
1781   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1782   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1783   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1784   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1785   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1786   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1787   {DUMMY_STRINGOP_ALGS,
1788    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1789   {DUMMY_STRINGOP_ALGS,
1790    {libcall, {{32, loop}, {8192, rep_prefix_8_byte}, {-1, libcall}}}},
1791   1,                                    /* scalar_stmt_cost.  */
1792   1,                                    /* scalar load_cost.  */
1793   1,                                    /* scalar_store_cost.  */
1794   1,                                    /* vec_stmt_cost.  */
1795   1,                                    /* vec_to_scalar_cost.  */
1796   1,                                    /* scalar_to_vec_cost.  */
1797   1,                                    /* vec_align_load_cost.  */
1798   2,                                    /* vec_unalign_load_cost.  */
1799   1,                                    /* vec_store_cost.  */
1800   3,                                    /* cond_taken_branch_cost.  */
1801   1,                                    /* cond_not_taken_branch_cost.  */
1802 };
1803
1804 /* Generic32 should produce code tuned for PPro, Pentium4, Nocona,
1805    Athlon and K8.  */
1806 static const
1807 struct processor_costs generic32_cost = {
1808   COSTS_N_INSNS (1),                    /* cost of an add instruction */
1809   COSTS_N_INSNS (1) + 1,                /* cost of a lea instruction */
1810   COSTS_N_INSNS (1),                    /* variable shift costs */
1811   COSTS_N_INSNS (1),                    /* constant shift costs */
1812   {COSTS_N_INSNS (3),                   /* cost of starting multiply for QI */
1813    COSTS_N_INSNS (4),                   /*                               HI */
1814    COSTS_N_INSNS (3),                   /*                               SI */
1815    COSTS_N_INSNS (4),                   /*                               DI */
1816    COSTS_N_INSNS (2)},                  /*                            other */
1817   0,                                    /* cost of multiply per each bit set */
1818   {COSTS_N_INSNS (18),                  /* cost of a divide/mod for QI */
1819    COSTS_N_INSNS (26),                  /*                          HI */
1820    COSTS_N_INSNS (42),                  /*                          SI */
1821    COSTS_N_INSNS (74),                  /*                          DI */
1822    COSTS_N_INSNS (74)},                 /*                          other */
1823   COSTS_N_INSNS (1),                    /* cost of movsx */
1824   COSTS_N_INSNS (1),                    /* cost of movzx */
1825   8,                                    /* "large" insn */
1826   17,                                   /* MOVE_RATIO */
1827   4,                                 /* cost for loading QImode using movzbl */
1828   {4, 4, 4},                            /* cost of loading integer registers
1829                                            in QImode, HImode and SImode.
1830                                            Relative to reg-reg move (2).  */
1831   {4, 4, 4},                            /* cost of storing integer registers */
1832   4,                                    /* cost of reg,reg fld/fst */
1833   {12, 12, 12},                         /* cost of loading fp registers
1834                                            in SFmode, DFmode and XFmode */
1835   {6, 6, 8},                            /* cost of storing fp registers
1836                                            in SFmode, DFmode and XFmode */
1837   2,                                    /* cost of moving MMX register */
1838   {8, 8},                               /* cost of loading MMX registers
1839                                            in SImode and DImode */
1840   {8, 8},                               /* cost of storing MMX registers
1841                                            in SImode and DImode */
1842   2,                                    /* cost of moving SSE register */
1843   {8, 8, 8},                            /* cost of loading SSE registers
1844                                            in SImode, DImode and TImode */
1845   {8, 8, 8},                            /* cost of storing SSE registers
1846                                            in SImode, DImode and TImode */
1847   5,                                    /* MMX or SSE register to integer */
1848   32,                                   /* size of l1 cache.  */
1849   256,                                  /* size of l2 cache.  */
1850   64,                                   /* size of prefetch block */
1851   6,                                    /* number of parallel prefetches */
1852   3,                                    /* Branch cost */
1853   COSTS_N_INSNS (8),                    /* cost of FADD and FSUB insns.  */
1854   COSTS_N_INSNS (8),                    /* cost of FMUL instruction.  */
1855   COSTS_N_INSNS (20),                   /* cost of FDIV instruction.  */
1856   COSTS_N_INSNS (8),                    /* cost of FABS instruction.  */
1857   COSTS_N_INSNS (8),                    /* cost of FCHS instruction.  */
1858   COSTS_N_INSNS (40),                   /* cost of FSQRT instruction.  */
1859   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1860    DUMMY_STRINGOP_ALGS},
1861   {{libcall, {{32, loop}, {8192, rep_prefix_4_byte}, {-1, libcall}}},
1862    DUMMY_STRINGOP_ALGS},
1863   1,                                    /* scalar_stmt_cost.  */
1864   1,                                    /* scalar load_cost.  */
1865   1,                                    /* scalar_store_cost.  */
1866   1,                                    /* vec_stmt_cost.  */
1867   1,                                    /* vec_to_scalar_cost.  */
1868   1,                                    /* scalar_to_vec_cost.  */
1869   1,                                    /* vec_align_load_cost.  */
1870   2,                                    /* vec_unalign_load_cost.  */
1871   1,                                    /* vec_store_cost.  */
1872   3,                                    /* cond_taken_branch_cost.  */
1873   1,                                    /* cond_not_taken_branch_cost.  */
1874 };
1875
1876 const struct processor_costs *ix86_cost = &pentium_cost;
1877
1878 /* Processor feature/optimization bitmasks.  */
1879 #define m_386 (1<<PROCESSOR_I386)
1880 #define m_486 (1<<PROCESSOR_I486)
1881 #define m_PENT (1<<PROCESSOR_PENTIUM)
1882 #define m_PPRO (1<<PROCESSOR_PENTIUMPRO)
1883 #define m_PENT4 (1<<PROCESSOR_PENTIUM4)
1884 #define m_NOCONA (1<<PROCESSOR_NOCONA)
1885 #define m_P4_NOCONA (m_PENT4 | m_NOCONA)
1886 #define m_CORE2_32 (1<<PROCESSOR_CORE2_32)
1887 #define m_CORE2_64 (1<<PROCESSOR_CORE2_64)
1888 #define m_COREI7_32 (1<<PROCESSOR_COREI7_32)
1889 #define m_COREI7_64 (1<<PROCESSOR_COREI7_64)
1890 #define m_COREI7 (m_COREI7_32 | m_COREI7_64)
1891 #define m_CORE2I7_32 (m_CORE2_32 | m_COREI7_32)
1892 #define m_CORE2I7_64 (m_CORE2_64 | m_COREI7_64)
1893 #define m_CORE2I7 (m_CORE2I7_32 | m_CORE2I7_64)
1894 #define m_ATOM (1<<PROCESSOR_ATOM)
1895
1896 #define m_GEODE (1<<PROCESSOR_GEODE)
1897 #define m_K6 (1<<PROCESSOR_K6)
1898 #define m_K6_GEODE (m_K6 | m_GEODE)
1899 #define m_K8 (1<<PROCESSOR_K8)
1900 #define m_ATHLON (1<<PROCESSOR_ATHLON)
1901 #define m_ATHLON_K8 (m_K8 | m_ATHLON)
1902 #define m_AMDFAM10 (1<<PROCESSOR_AMDFAM10)
1903 #define m_BDVER1 (1<<PROCESSOR_BDVER1)
1904 #define m_BDVER2 (1<<PROCESSOR_BDVER2)
1905 #define m_BDVER (m_BDVER1 | m_BDVER2)
1906 #define m_BTVER1 (1<<PROCESSOR_BTVER1)
1907 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1)
1908
1909 #define m_GENERIC32 (1<<PROCESSOR_GENERIC32)
1910 #define m_GENERIC64 (1<<PROCESSOR_GENERIC64)
1911
1912 /* Generic instruction choice should be common subset of supported CPUs
1913    (PPro/PENT4/NOCONA/CORE2/Athlon/K8).  */
1914 #define m_GENERIC (m_GENERIC32 | m_GENERIC64)
1915
1916 /* Feature tests against the various tunings.  */
1917 unsigned char ix86_tune_features[X86_TUNE_LAST];
1918
1919 /* Feature tests against the various tunings used to create ix86_tune_features
1920    based on the processor mask.  */
1921 static unsigned int initial_ix86_tune_features[X86_TUNE_LAST] = {
1922   /* X86_TUNE_USE_LEAVE: Leave does not affect Nocona SPEC2000 results
1923      negatively, so enabling for Generic64 seems like good code size
1924      tradeoff.  We can't enable it for 32bit generic because it does not
1925      work well with PPro base chips.  */
1926   m_386 | m_CORE2I7_64 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC64,
1927
1928   /* X86_TUNE_PUSH_MEMORY */
1929   m_386 | m_P4_NOCONA | m_CORE2I7 | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1930
1931   /* X86_TUNE_ZERO_EXTEND_WITH_AND */
1932   m_486 | m_PENT,
1933
1934   /* X86_TUNE_UNROLL_STRLEN */
1935   m_486 | m_PENT | m_PPRO | m_ATOM | m_CORE2I7 | m_K6 | m_AMD_MULTIPLE | m_GENERIC,
1936
1937   /* X86_TUNE_BRANCH_PREDICTION_HINTS: Branch hints were put in P4 based
1938      on simulation result. But after P4 was made, no performance benefit
1939      was observed with branch hints.  It also increases the code size.
1940      As a result, icc never generates branch hints.  */
1941   0,
1942
1943   /* X86_TUNE_DOUBLE_WITH_ADD */
1944   ~m_386,
1945
1946   /* X86_TUNE_USE_SAHF */
1947   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC,
1948
1949   /* X86_TUNE_MOVX: Enable to zero extend integer registers to avoid
1950      partial dependencies.  */
1951   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE  | m_GENERIC,
1952
1953   /* X86_TUNE_PARTIAL_REG_STALL: We probably ought to watch for partial
1954      register stalls on Generic32 compilation setting as well.  However
1955      in current implementation the partial register stalls are not eliminated
1956      very well - they can be introduced via subregs synthesized by combine
1957      and can happen in caller/callee saving sequences.  Because this option
1958      pays back little on PPro based chips and is in conflict with partial reg
1959      dependencies used by Athlon/P4 based chips, it is better to leave it off
1960      for generic32 for now.  */
1961   m_PPRO,
1962
1963   /* X86_TUNE_PARTIAL_FLAG_REG_STALL */
1964   m_CORE2I7 | m_GENERIC,
1965
1966   /* X86_TUNE_USE_HIMODE_FIOP */
1967   m_386 | m_486 | m_K6_GEODE,
1968
1969   /* X86_TUNE_USE_SIMODE_FIOP */
1970   ~(m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC),
1971
1972   /* X86_TUNE_USE_MOV0 */
1973   m_K6,
1974
1975   /* X86_TUNE_USE_CLTD */
1976   ~(m_PENT | m_CORE2I7 | m_ATOM | m_K6 | m_GENERIC),
1977
1978   /* X86_TUNE_USE_XCHGB: Use xchgb %rh,%rl instead of rolw/rorw $8,rx.  */
1979   m_PENT4,
1980
1981   /* X86_TUNE_SPLIT_LONG_MOVES */
1982   m_PPRO,
1983
1984   /* X86_TUNE_READ_MODIFY_WRITE */
1985   ~m_PENT,
1986
1987   /* X86_TUNE_READ_MODIFY */
1988   ~(m_PENT | m_PPRO),
1989
1990   /* X86_TUNE_PROMOTE_QIMODE */
1991   m_386 | m_486 | m_PENT | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
1992
1993   /* X86_TUNE_FAST_PREFIX */
1994   ~(m_386 | m_486 | m_PENT),
1995
1996   /* X86_TUNE_SINGLE_STRINGOP */
1997   m_386 | m_P4_NOCONA,
1998
1999   /* X86_TUNE_QIMODE_MATH */
2000   ~0,
2001
2002   /* X86_TUNE_HIMODE_MATH: On PPro this flag is meant to avoid partial
2003      register stalls.  Just like X86_TUNE_PARTIAL_REG_STALL this option
2004      might be considered for Generic32 if our scheme for avoiding partial
2005      stalls was more effective.  */
2006   ~m_PPRO,
2007
2008   /* X86_TUNE_PROMOTE_QI_REGS */
2009   0,
2010
2011   /* X86_TUNE_PROMOTE_HI_REGS */
2012   m_PPRO,
2013
2014   /* X86_TUNE_SINGLE_POP: Enable if single pop insn is preferred
2015      over esp addition.  */
2016   m_386 | m_486 | m_PENT | m_PPRO,
2017
2018   /* X86_TUNE_DOUBLE_POP: Enable if double pop insn is preferred
2019      over esp addition.  */
2020   m_PENT,
2021
2022   /* X86_TUNE_SINGLE_PUSH: Enable if single push insn is preferred
2023      over esp subtraction.  */
2024   m_386 | m_486 | m_PENT | m_K6_GEODE,
2025
2026   /* X86_TUNE_DOUBLE_PUSH. Enable if double push insn is preferred
2027      over esp subtraction.  */
2028   m_PENT | m_K6_GEODE,
2029
2030   /* X86_TUNE_INTEGER_DFMODE_MOVES: Enable if integer moves are preferred
2031      for DFmode copies */
2032   ~(m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GEODE | m_AMD_MULTIPLE | m_ATOM | m_GENERIC),
2033
2034   /* X86_TUNE_PARTIAL_REG_DEPENDENCY */
2035   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2036
2037   /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: In the Generic model we have a
2038      conflict here in between PPro/Pentium4 based chips that thread 128bit
2039      SSE registers as single units versus K8 based chips that divide SSE
2040      registers to two 64bit halves.  This knob promotes all store destinations
2041      to be 128bit to allow register renaming on 128bit SSE units, but usually
2042      results in one extra microop on 64bit SSE units.  Experimental results
2043      shows that disabling this option on P4 brings over 20% SPECfp regression,
2044      while enabling it on K8 brings roughly 2.4% regression that can be partly
2045      masked by careful scheduling of moves.  */
2046   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM  | m_AMDFAM10 | m_BDVER | m_GENERIC,
2047
2048   /* X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL */
2049   m_COREI7 | m_AMDFAM10 | m_BDVER | m_BTVER1,
2050
2051   /* X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL */
2052   m_COREI7 | m_BDVER,
2053
2054   /* X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL */
2055   m_BDVER ,
2056
2057   /* X86_TUNE_SSE_SPLIT_REGS: Set for machines where the type and dependencies
2058      are resolved on SSE register parts instead of whole registers, so we may
2059      maintain just lower part of scalar values in proper format leaving the
2060      upper part undefined.  */
2061   m_ATHLON_K8,
2062
2063   /* X86_TUNE_SSE_TYPELESS_STORES */
2064   m_AMD_MULTIPLE,
2065
2066   /* X86_TUNE_SSE_LOAD0_BY_PXOR */
2067   m_PPRO | m_P4_NOCONA,
2068
2069   /* X86_TUNE_MEMORY_MISMATCH_STALL */
2070   m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2071
2072   /* X86_TUNE_PROLOGUE_USING_MOVE */
2073   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2074
2075   /* X86_TUNE_EPILOGUE_USING_MOVE */
2076   m_PPRO | m_CORE2I7 | m_ATOM | m_ATHLON_K8 | m_GENERIC,
2077
2078   /* X86_TUNE_SHIFT1 */
2079   ~m_486,
2080
2081   /* X86_TUNE_USE_FFREEP */
2082   m_AMD_MULTIPLE,
2083
2084   /* X86_TUNE_INTER_UNIT_MOVES */
2085   ~(m_AMD_MULTIPLE | m_GENERIC),
2086
2087   /* X86_TUNE_INTER_UNIT_CONVERSIONS */
2088   ~(m_AMDFAM10 | m_BDVER ),
2089
2090   /* X86_TUNE_FOUR_JUMP_LIMIT: Some CPU cores are not able to predict more
2091      than 4 branch instructions in the 16 byte window.  */
2092   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2093
2094   /* X86_TUNE_SCHEDULE */
2095   m_PENT | m_PPRO | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC,
2096
2097   /* X86_TUNE_USE_BT */
2098   m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC,
2099
2100   /* X86_TUNE_USE_INCDEC */
2101   ~(m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_GENERIC),
2102
2103   /* X86_TUNE_PAD_RETURNS */
2104   m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC,
2105
2106   /* X86_TUNE_PAD_SHORT_FUNCTION: Pad short funtion.  */
2107   m_ATOM,
2108
2109   /* X86_TUNE_EXT_80387_CONSTANTS */
2110   m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_K6_GEODE | m_ATHLON_K8 | m_GENERIC,
2111
2112   /* X86_TUNE_SHORTEN_X87_SSE */
2113   ~m_K8,
2114
2115   /* X86_TUNE_AVOID_VECTOR_DECODE */
2116   m_CORE2I7_64 | m_K8 | m_GENERIC64,
2117
2118   /* X86_TUNE_PROMOTE_HIMODE_IMUL: Modern CPUs have same latency for HImode
2119      and SImode multiply, but 386 and 486 do HImode multiply faster.  */
2120   ~(m_386 | m_486),
2121
2122   /* X86_TUNE_SLOW_IMUL_IMM32_MEM: Imul of 32-bit constant and memory is
2123      vector path on AMD machines.  */
2124   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2125
2126   /* X86_TUNE_SLOW_IMUL_IMM8: Imul of 8-bit constant is vector path on AMD
2127      machines.  */
2128   m_CORE2I7_64 | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER1 | m_GENERIC64,
2129
2130   /* X86_TUNE_MOVE_M1_VIA_OR: On pentiums, it is faster to load -1 via OR
2131      than a MOV.  */
2132   m_PENT,
2133
2134   /* X86_TUNE_NOT_UNPAIRABLE: NOT is not pairable on Pentium, while XOR is,
2135      but one byte longer.  */
2136   m_PENT,
2137
2138   /* X86_TUNE_NOT_VECTORMODE: On AMD K6, NOT is vector decoded with memory
2139      operand that cannot be represented using a modRM byte.  The XOR
2140      replacement is long decoded, so this split helps here as well.  */
2141   m_K6,
2142
2143   /* X86_TUNE_USE_VECTOR_FP_CONVERTS: Prefer vector packed SSE conversion
2144      from FP to FP. */
2145   m_CORE2I7 | m_AMDFAM10 | m_GENERIC,
2146
2147   /* X86_TUNE_USE_VECTOR_CONVERTS: Prefer vector packed SSE conversion
2148      from integer to FP. */
2149   m_AMDFAM10,
2150
2151   /* X86_TUNE_FUSE_CMP_AND_BRANCH: Fuse a compare or test instruction
2152      with a subsequent conditional jump instruction into a single
2153      compare-and-branch uop.  */
2154   m_BDVER,
2155
2156   /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
2157      will impact LEA instruction selection. */
2158   m_ATOM,
2159
2160   /* X86_TUNE_VECTORIZE_DOUBLE: Enable double precision vector
2161      instructions.  */
2162   ~m_ATOM,
2163
2164   /* X86_SOFTARE_PREFETCHING_BENEFICIAL: Enable software prefetching
2165      at -O3.  For the moment, the prefetching seems badly tuned for Intel
2166      chips.  */
2167   m_K6_GEODE | m_AMD_MULTIPLE,
2168
2169   /* X86_TUNE_AVX128_OPTIMAL: Enable 128-bit AVX instruction generation for
2170      the auto-vectorizer.  */
2171   m_BDVER
2172 };
2173
2174 /* Feature tests against the various architecture variations.  */
2175 unsigned char ix86_arch_features[X86_ARCH_LAST];
2176
2177 /* Feature tests against the various architecture variations, used to create
2178    ix86_arch_features based on the processor mask.  */
2179 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
2180   /* X86_ARCH_CMOVE: Conditional move was added for pentiumpro.  */
2181   ~(m_386 | m_486 | m_PENT | m_K6),
2182
2183   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
2184   ~m_386,
2185
2186   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
2187   ~(m_386 | m_486),
2188
2189   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
2190   ~m_386,
2191
2192   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
2193   ~m_386,
2194 };
2195
2196 static const unsigned int x86_accumulate_outgoing_args
2197   = m_PPRO | m_P4_NOCONA | m_ATOM | m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC;
2198
2199 static const unsigned int x86_arch_always_fancy_math_387
2200   = m_PENT | m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC;
2201
2202 static const unsigned int x86_avx256_split_unaligned_load
2203   = m_COREI7 | m_GENERIC;
2204
2205 static const unsigned int x86_avx256_split_unaligned_store
2206   = m_COREI7 | m_BDVER | m_GENERIC;
2207
2208 /* In case the average insn count for single function invocation is
2209    lower than this constant, emit fast (but longer) prologue and
2210    epilogue code.  */
2211 #define FAST_PROLOGUE_INSN_COUNT 20
2212
2213 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
2214 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
2215 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
2216 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
2217
2218 /* Array of the smallest class containing reg number REGNO, indexed by
2219    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
2220
2221 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
2222 {
2223   /* ax, dx, cx, bx */
2224   AREG, DREG, CREG, BREG,
2225   /* si, di, bp, sp */
2226   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
2227   /* FP registers */
2228   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
2229   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
2230   /* arg pointer */
2231   NON_Q_REGS,
2232   /* flags, fpsr, fpcr, frame */
2233   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
2234   /* SSE registers */
2235   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2236   SSE_REGS, SSE_REGS,
2237   /* MMX registers */
2238   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
2239   MMX_REGS, MMX_REGS,
2240   /* REX registers */
2241   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2242   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2243   /* SSE REX registers */
2244   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2245   SSE_REGS, SSE_REGS,
2246 };
2247
2248 /* The "default" register map used in 32bit mode.  */
2249
2250 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
2251 {
2252   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
2253   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
2254   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2255   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
2256   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
2257   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2258   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2259 };
2260
2261 /* The "default" register map used in 64bit mode.  */
2262
2263 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
2264 {
2265   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
2266   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
2267   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2268   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
2269   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
2270   8,9,10,11,12,13,14,15,                /* extended integer registers */
2271   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
2272 };
2273
2274 /* Define the register numbers to be used in Dwarf debugging information.
2275    The SVR4 reference port C compiler uses the following register numbers
2276    in its Dwarf output code:
2277         0 for %eax (gcc regno = 0)
2278         1 for %ecx (gcc regno = 2)
2279         2 for %edx (gcc regno = 1)
2280         3 for %ebx (gcc regno = 3)
2281         4 for %esp (gcc regno = 7)
2282         5 for %ebp (gcc regno = 6)
2283         6 for %esi (gcc regno = 4)
2284         7 for %edi (gcc regno = 5)
2285    The following three DWARF register numbers are never generated by
2286    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
2287    believes these numbers have these meanings.
2288         8  for %eip    (no gcc equivalent)
2289         9  for %eflags (gcc regno = 17)
2290         10 for %trapno (no gcc equivalent)
2291    It is not at all clear how we should number the FP stack registers
2292    for the x86 architecture.  If the version of SDB on x86/svr4 were
2293    a bit less brain dead with respect to floating-point then we would
2294    have a precedent to follow with respect to DWARF register numbers
2295    for x86 FP registers, but the SDB on x86/svr4 is so completely
2296    broken with respect to FP registers that it is hardly worth thinking
2297    of it as something to strive for compatibility with.
2298    The version of x86/svr4 SDB I have at the moment does (partially)
2299    seem to believe that DWARF register number 11 is associated with
2300    the x86 register %st(0), but that's about all.  Higher DWARF
2301    register numbers don't seem to be associated with anything in
2302    particular, and even for DWARF regno 11, SDB only seems to under-
2303    stand that it should say that a variable lives in %st(0) (when
2304    asked via an `=' command) if we said it was in DWARF regno 11,
2305    but SDB still prints garbage when asked for the value of the
2306    variable in question (via a `/' command).
2307    (Also note that the labels SDB prints for various FP stack regs
2308    when doing an `x' command are all wrong.)
2309    Note that these problems generally don't affect the native SVR4
2310    C compiler because it doesn't allow the use of -O with -g and
2311    because when it is *not* optimizing, it allocates a memory
2312    location for each floating-point variable, and the memory
2313    location is what gets described in the DWARF AT_location
2314    attribute for the variable in question.
2315    Regardless of the severe mental illness of the x86/svr4 SDB, we
2316    do something sensible here and we use the following DWARF
2317    register numbers.  Note that these are all stack-top-relative
2318    numbers.
2319         11 for %st(0) (gcc regno = 8)
2320         12 for %st(1) (gcc regno = 9)
2321         13 for %st(2) (gcc regno = 10)
2322         14 for %st(3) (gcc regno = 11)
2323         15 for %st(4) (gcc regno = 12)
2324         16 for %st(5) (gcc regno = 13)
2325         17 for %st(6) (gcc regno = 14)
2326         18 for %st(7) (gcc regno = 15)
2327 */
2328 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
2329 {
2330   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
2331   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
2332   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
2333   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
2334   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
2335   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2336   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2337 };
2338
2339 /* Define parameter passing and return registers.  */
2340
2341 static int const x86_64_int_parameter_registers[6] =
2342 {
2343   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
2344 };
2345
2346 static int const x86_64_ms_abi_int_parameter_registers[4] =
2347 {
2348   CX_REG, DX_REG, R8_REG, R9_REG
2349 };
2350
2351 static int const x86_64_int_return_registers[4] =
2352 {
2353   AX_REG, DX_REG, DI_REG, SI_REG
2354 };
2355
2356 /* Define the structure for the machine field in struct function.  */
2357
2358 struct GTY(()) stack_local_entry {
2359   unsigned short mode;
2360   unsigned short n;
2361   rtx rtl;
2362   struct stack_local_entry *next;
2363 };
2364
2365 /* Structure describing stack frame layout.
2366    Stack grows downward:
2367
2368    [arguments]
2369                                         <- ARG_POINTER
2370    saved pc
2371
2372    saved static chain                   if ix86_static_chain_on_stack
2373
2374    saved frame pointer                  if frame_pointer_needed
2375                                         <- HARD_FRAME_POINTER
2376    [saved regs]
2377                                         <- regs_save_offset
2378    [padding0]
2379
2380    [saved SSE regs]
2381                                         <- sse_regs_save_offset
2382    [padding1]          |
2383                        |                <- FRAME_POINTER
2384    [va_arg registers]  |
2385                        |
2386    [frame]             |
2387                        |
2388    [padding2]          | = to_allocate
2389                                         <- STACK_POINTER
2390   */
2391 struct ix86_frame
2392 {
2393   int nsseregs;
2394   int nregs;
2395   int va_arg_size;
2396   int red_zone_size;
2397   int outgoing_arguments_size;
2398   HOST_WIDE_INT frame;
2399
2400   /* The offsets relative to ARG_POINTER.  */
2401   HOST_WIDE_INT frame_pointer_offset;
2402   HOST_WIDE_INT hard_frame_pointer_offset;
2403   HOST_WIDE_INT stack_pointer_offset;
2404   HOST_WIDE_INT hfp_save_offset;
2405   HOST_WIDE_INT reg_save_offset;
2406   HOST_WIDE_INT sse_reg_save_offset;
2407
2408   /* When save_regs_using_mov is set, emit prologue using
2409      move instead of push instructions.  */
2410   bool save_regs_using_mov;
2411 };
2412
2413 /* Which cpu are we scheduling for.  */
2414 enum attr_cpu ix86_schedule;
2415
2416 /* Which cpu are we optimizing for.  */
2417 enum processor_type ix86_tune;
2418
2419 /* Which instruction set architecture to use.  */
2420 enum processor_type ix86_arch;
2421
2422 /* true if sse prefetch instruction is not NOOP.  */
2423 int x86_prefetch_sse;
2424
2425 /* -mstackrealign option */
2426 static const char ix86_force_align_arg_pointer_string[]
2427   = "force_align_arg_pointer";
2428
2429 static rtx (*ix86_gen_leave) (void);
2430 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
2431 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
2432 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
2433 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
2434 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
2435 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
2436 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
2437 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
2438 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
2439
2440 /* Preferred alignment for stack boundary in bits.  */
2441 unsigned int ix86_preferred_stack_boundary;
2442
2443 /* Alignment for incoming stack boundary in bits specified at
2444    command line.  */
2445 static unsigned int ix86_user_incoming_stack_boundary;
2446
2447 /* Default alignment for incoming stack boundary in bits.  */
2448 static unsigned int ix86_default_incoming_stack_boundary;
2449
2450 /* Alignment for incoming stack boundary in bits.  */
2451 unsigned int ix86_incoming_stack_boundary;
2452
2453 /* Calling abi specific va_list type nodes.  */
2454 static GTY(()) tree sysv_va_list_type_node;
2455 static GTY(()) tree ms_va_list_type_node;
2456
2457 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
2458 char internal_label_prefix[16];
2459 int internal_label_prefix_len;
2460
2461 /* Fence to use after loop using movnt.  */
2462 tree x86_mfence;
2463
2464 /* Register class used for passing given 64bit part of the argument.
2465    These represent classes as documented by the PS ABI, with the exception
2466    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
2467    use SF or DFmode move instead of DImode to avoid reformatting penalties.
2468
2469    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
2470    whenever possible (upper half does contain padding).  */
2471 enum x86_64_reg_class
2472   {
2473     X86_64_NO_CLASS,
2474     X86_64_INTEGER_CLASS,
2475     X86_64_INTEGERSI_CLASS,
2476     X86_64_SSE_CLASS,
2477     X86_64_SSESF_CLASS,
2478     X86_64_SSEDF_CLASS,
2479     X86_64_SSEUP_CLASS,
2480     X86_64_X87_CLASS,
2481     X86_64_X87UP_CLASS,
2482     X86_64_COMPLEX_X87_CLASS,
2483     X86_64_MEMORY_CLASS
2484   };
2485
2486 #define MAX_CLASSES 4
2487
2488 /* Table of constants used by fldpi, fldln2, etc....  */
2489 static REAL_VALUE_TYPE ext_80387_constants_table [5];
2490 static bool ext_80387_constants_init = 0;
2491
2492 \f
2493 static struct machine_function * ix86_init_machine_status (void);
2494 static rtx ix86_function_value (const_tree, const_tree, bool);
2495 static bool ix86_function_value_regno_p (const unsigned int);
2496 static unsigned int ix86_function_arg_boundary (enum machine_mode,
2497                                                 const_tree);
2498 static rtx ix86_static_chain (const_tree, bool);
2499 static int ix86_function_regparm (const_tree, const_tree);
2500 static void ix86_compute_frame_layout (struct ix86_frame *);
2501 static bool ix86_expand_vector_init_one_nonzero (bool, enum machine_mode,
2502                                                  rtx, rtx, int);
2503 static void ix86_add_new_builtins (HOST_WIDE_INT);
2504 static rtx ix86_expand_vec_perm_builtin (tree);
2505 static tree ix86_canonical_va_list_type (tree);
2506 static void predict_jump (int);
2507 static unsigned int split_stack_prologue_scratch_regno (void);
2508 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
2509
2510 enum ix86_function_specific_strings
2511 {
2512   IX86_FUNCTION_SPECIFIC_ARCH,
2513   IX86_FUNCTION_SPECIFIC_TUNE,
2514   IX86_FUNCTION_SPECIFIC_MAX
2515 };
2516
2517 static char *ix86_target_string (HOST_WIDE_INT, int, const char *,
2518                                  const char *, enum fpmath_unit, bool);
2519 static void ix86_debug_options (void) ATTRIBUTE_UNUSED;
2520 static void ix86_function_specific_save (struct cl_target_option *);
2521 static void ix86_function_specific_restore (struct cl_target_option *);
2522 static void ix86_function_specific_print (FILE *, int,
2523                                           struct cl_target_option *);
2524 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
2525 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
2526                                                  struct gcc_options *);
2527 static bool ix86_can_inline_p (tree, tree);
2528 static void ix86_set_current_function (tree);
2529 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
2530
2531 static enum calling_abi ix86_function_abi (const_tree);
2532
2533 \f
2534 #ifndef SUBTARGET32_DEFAULT_CPU
2535 #define SUBTARGET32_DEFAULT_CPU "i386"
2536 #endif
2537
2538 /* The svr4 ABI for the i386 says that records and unions are returned
2539    in memory.  */
2540 #ifndef DEFAULT_PCC_STRUCT_RETURN
2541 #define DEFAULT_PCC_STRUCT_RETURN 1
2542 #endif
2543
2544 /* Whether -mtune= or -march= were specified */
2545 static int ix86_tune_defaulted;
2546 static int ix86_arch_specified;
2547
2548 /* Vectorization library interface and handlers.  */
2549 static tree (*ix86_veclib_handler) (enum built_in_function, tree, tree);
2550
2551 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2552 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2553
2554 /* Processor target table, indexed by processor number */
2555 struct ptt
2556 {
2557   const struct processor_costs *cost;           /* Processor costs */
2558   const int align_loop;                         /* Default alignments.  */
2559   const int align_loop_max_skip;
2560   const int align_jump;
2561   const int align_jump_max_skip;
2562   const int align_func;
2563 };
2564
2565 static const struct ptt processor_target_table[PROCESSOR_max] =
2566 {
2567   {&i386_cost, 4, 3, 4, 3, 4},
2568   {&i486_cost, 16, 15, 16, 15, 16},
2569   {&pentium_cost, 16, 7, 16, 7, 16},
2570   {&pentiumpro_cost, 16, 15, 16, 10, 16},
2571   {&geode_cost, 0, 0, 0, 0, 0},
2572   {&k6_cost, 32, 7, 32, 7, 32},
2573   {&athlon_cost, 16, 7, 16, 7, 16},
2574   {&pentium4_cost, 0, 0, 0, 0, 0},
2575   {&k8_cost, 16, 7, 16, 7, 16},
2576   {&nocona_cost, 0, 0, 0, 0, 0},
2577   /* Core 2 32-bit.  */
2578   {&generic32_cost, 16, 10, 16, 10, 16},
2579   /* Core 2 64-bit.  */
2580   {&generic64_cost, 16, 10, 16, 10, 16},
2581   /* Core i7 32-bit.  */
2582   {&generic32_cost, 16, 10, 16, 10, 16},
2583   /* Core i7 64-bit.  */
2584   {&generic64_cost, 16, 10, 16, 10, 16},
2585   {&generic32_cost, 16, 7, 16, 7, 16},
2586   {&generic64_cost, 16, 10, 16, 10, 16},
2587   {&amdfam10_cost, 32, 24, 32, 7, 32},
2588   {&bdver1_cost, 32, 24, 32, 7, 32},
2589   {&bdver2_cost, 32, 24, 32, 7, 32},
2590   {&btver1_cost, 32, 24, 32, 7, 32},
2591   {&atom_cost, 16, 7, 16, 7, 16}
2592 };
2593
2594 static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2595 {
2596   "generic",
2597   "i386",
2598   "i486",
2599   "pentium",
2600   "pentium-mmx",
2601   "pentiumpro",
2602   "pentium2",
2603   "pentium3",
2604   "pentium4",
2605   "pentium-m",
2606   "prescott",
2607   "nocona",
2608   "core2",
2609   "corei7",
2610   "atom",
2611   "geode",
2612   "k6",
2613   "k6-2",
2614   "k6-3",
2615   "athlon",
2616   "athlon-4",
2617   "k8",
2618   "amdfam10",
2619   "bdver1",
2620   "bdver2",
2621   "btver1"
2622 };
2623 \f
2624 /* Return true if a red-zone is in use.  */
2625
2626 static inline bool
2627 ix86_using_red_zone (void)
2628 {
2629   return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;
2630 }
2631 \f
2632 /* Return a string that documents the current -m options.  The caller is
2633    responsible for freeing the string.  */
2634
2635 static char *
2636 ix86_target_string (HOST_WIDE_INT isa, int flags, const char *arch,
2637                     const char *tune, enum fpmath_unit fpmath,
2638                     bool add_nl_p)
2639 {
2640   struct ix86_target_opts
2641   {
2642     const char *option;         /* option string */
2643     HOST_WIDE_INT mask;         /* isa mask options */
2644   };
2645
2646   /* This table is ordered so that options like -msse4.2 that imply
2647      preceding options while match those first.  */
2648   static struct ix86_target_opts isa_opts[] =
2649   {
2650     { "-m64",           OPTION_MASK_ISA_64BIT },
2651     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2652     { "-mfma",          OPTION_MASK_ISA_FMA },
2653     { "-mxop",          OPTION_MASK_ISA_XOP },
2654     { "-mlwp",          OPTION_MASK_ISA_LWP },
2655     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2656     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2657     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2658     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2659     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2660     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2661     { "-msse",          OPTION_MASK_ISA_SSE },
2662     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2663     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2664     { "-mmmx",          OPTION_MASK_ISA_MMX },
2665     { "-mabm",          OPTION_MASK_ISA_ABM },
2666     { "-mbmi",          OPTION_MASK_ISA_BMI },
2667     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2668     { "-mtbm",          OPTION_MASK_ISA_TBM },
2669     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2670     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2671     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2672     { "-maes",          OPTION_MASK_ISA_AES },
2673     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2674     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2675     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2676     { "-mf16c",         OPTION_MASK_ISA_F16C },
2677   };
2678
2679   /* Flag options.  */
2680   static struct ix86_target_opts flag_opts[] =
2681   {
2682     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2683     { "-m80387",                        MASK_80387 },
2684     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2685     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2686     { "-mcld",                          MASK_CLD },
2687     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2688     { "-mieee-fp",                      MASK_IEEE_FP },
2689     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2690     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2691     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2692     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2693     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2694     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2695     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2696     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2697     { "-mrecip",                        MASK_RECIP },
2698     { "-mrtd",                          MASK_RTD },
2699     { "-msseregparm",                   MASK_SSEREGPARM },
2700     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2701     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2702     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2703     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2704     { "-mvzeroupper",                   MASK_VZEROUPPER },
2705     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2706     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2707     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2708   };
2709
2710   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2711
2712   char isa_other[40];
2713   char target_other[40];
2714   unsigned num = 0;
2715   unsigned i, j;
2716   char *ret;
2717   char *ptr;
2718   size_t len;
2719   size_t line_len;
2720   size_t sep_len;
2721
2722   memset (opts, '\0', sizeof (opts));
2723
2724   /* Add -march= option.  */
2725   if (arch)
2726     {
2727       opts[num][0] = "-march=";
2728       opts[num++][1] = arch;
2729     }
2730
2731   /* Add -mtune= option.  */
2732   if (tune)
2733     {
2734       opts[num][0] = "-mtune=";
2735       opts[num++][1] = tune;
2736     }
2737
2738   /* Pick out the options in isa options.  */
2739   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2740     {
2741       if ((isa & isa_opts[i].mask) != 0)
2742         {
2743           opts[num++][0] = isa_opts[i].option;
2744           isa &= ~ isa_opts[i].mask;
2745         }
2746     }
2747
2748   if (isa && add_nl_p)
2749     {
2750       opts[num++][0] = isa_other;
2751       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)",
2752                isa);
2753     }
2754
2755   /* Add flag options.  */
2756   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2757     {
2758       if ((flags & flag_opts[i].mask) != 0)
2759         {
2760           opts[num++][0] = flag_opts[i].option;
2761           flags &= ~ flag_opts[i].mask;
2762         }
2763     }
2764
2765   if (flags && add_nl_p)
2766     {
2767       opts[num++][0] = target_other;
2768       sprintf (target_other, "(other flags: %#x)", flags);
2769     }
2770
2771   /* Add -fpmath= option.  */
2772   if (fpmath)
2773     {
2774       opts[num][0] = "-mfpmath=";
2775       switch ((int) fpmath)
2776         {
2777         case FPMATH_387:
2778           opts[num++][1] = "387";
2779           break;
2780
2781         case FPMATH_SSE:
2782           opts[num++][1] = "sse";
2783           break;
2784
2785         case FPMATH_387 | FPMATH_SSE:
2786           opts[num++][1] = "sse+387";
2787           break;
2788
2789         default:
2790           gcc_unreachable ();
2791         }
2792     }
2793
2794   /* Any options?  */
2795   if (num == 0)
2796     return NULL;
2797
2798   gcc_assert (num < ARRAY_SIZE (opts));
2799
2800   /* Size the string.  */
2801   len = 0;
2802   sep_len = (add_nl_p) ? 3 : 1;
2803   for (i = 0; i < num; i++)
2804     {
2805       len += sep_len;
2806       for (j = 0; j < 2; j++)
2807         if (opts[i][j])
2808           len += strlen (opts[i][j]);
2809     }
2810
2811   /* Build the string.  */
2812   ret = ptr = (char *) xmalloc (len);
2813   line_len = 0;
2814
2815   for (i = 0; i < num; i++)
2816     {
2817       size_t len2[2];
2818
2819       for (j = 0; j < 2; j++)
2820         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2821
2822       if (i != 0)
2823         {
2824           *ptr++ = ' ';
2825           line_len++;
2826
2827           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2828             {
2829               *ptr++ = '\\';
2830               *ptr++ = '\n';
2831               line_len = 0;
2832             }
2833         }
2834
2835       for (j = 0; j < 2; j++)
2836         if (opts[i][j])
2837           {
2838             memcpy (ptr, opts[i][j], len2[j]);
2839             ptr += len2[j];
2840             line_len += len2[j];
2841           }
2842     }
2843
2844   *ptr = '\0';
2845   gcc_assert (ret + len >= ptr);
2846
2847   return ret;
2848 }
2849
2850 /* Return true, if profiling code should be emitted before
2851    prologue. Otherwise it returns false.
2852    Note: For x86 with "hotfix" it is sorried.  */
2853 static bool
2854 ix86_profile_before_prologue (void)
2855 {
2856   return flag_fentry != 0;
2857 }
2858
2859 /* Function that is callable from the debugger to print the current
2860    options.  */
2861 void
2862 ix86_debug_options (void)
2863 {
2864   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2865                                    ix86_arch_string, ix86_tune_string,
2866                                    ix86_fpmath, true);
2867
2868   if (opts)
2869     {
2870       fprintf (stderr, "%s\n\n", opts);
2871       free (opts);
2872     }
2873   else
2874     fputs ("<no options>\n\n", stderr);
2875
2876   return;
2877 }
2878 \f
2879 /* Override various settings based on options.  If MAIN_ARGS_P, the
2880    options are from the command line, otherwise they are from
2881    attributes.  */
2882
2883 static void
2884 ix86_option_override_internal (bool main_args_p)
2885 {
2886   int i;
2887   unsigned int ix86_arch_mask, ix86_tune_mask;
2888   const bool ix86_tune_specified = (ix86_tune_string != NULL);
2889   const char *prefix;
2890   const char *suffix;
2891   const char *sw;
2892
2893 #define PTA_3DNOW               (HOST_WIDE_INT_1 << 0)
2894 #define PTA_3DNOW_A             (HOST_WIDE_INT_1 << 1)
2895 #define PTA_64BIT               (HOST_WIDE_INT_1 << 2)
2896 #define PTA_ABM                 (HOST_WIDE_INT_1 << 3)
2897 #define PTA_AES                 (HOST_WIDE_INT_1 << 4)
2898 #define PTA_AVX                 (HOST_WIDE_INT_1 << 5)
2899 #define PTA_BMI                 (HOST_WIDE_INT_1 << 6)
2900 #define PTA_CX16                (HOST_WIDE_INT_1 << 7)
2901 #define PTA_F16C                (HOST_WIDE_INT_1 << 8)
2902 #define PTA_FMA                 (HOST_WIDE_INT_1 << 9)
2903 #define PTA_FMA4                (HOST_WIDE_INT_1 << 10)
2904 #define PTA_FSGSBASE            (HOST_WIDE_INT_1 << 11)
2905 #define PTA_LWP                 (HOST_WIDE_INT_1 << 12)
2906 #define PTA_LZCNT               (HOST_WIDE_INT_1 << 13)
2907 #define PTA_MMX                 (HOST_WIDE_INT_1 << 14)
2908 #define PTA_MOVBE               (HOST_WIDE_INT_1 << 15)
2909 #define PTA_NO_SAHF             (HOST_WIDE_INT_1 << 16)
2910 #define PTA_PCLMUL              (HOST_WIDE_INT_1 << 17)
2911 #define PTA_POPCNT              (HOST_WIDE_INT_1 << 18)
2912 #define PTA_PREFETCH_SSE        (HOST_WIDE_INT_1 << 19)
2913 #define PTA_RDRND               (HOST_WIDE_INT_1 << 20)
2914 #define PTA_SSE                 (HOST_WIDE_INT_1 << 21)
2915 #define PTA_SSE2                (HOST_WIDE_INT_1 << 22)
2916 #define PTA_SSE3                (HOST_WIDE_INT_1 << 23)
2917 #define PTA_SSE4_1              (HOST_WIDE_INT_1 << 24)
2918 #define PTA_SSE4_2              (HOST_WIDE_INT_1 << 25)
2919 #define PTA_SSE4A               (HOST_WIDE_INT_1 << 26)
2920 #define PTA_SSSE3               (HOST_WIDE_INT_1 << 27)
2921 #define PTA_TBM                 (HOST_WIDE_INT_1 << 28)
2922 #define PTA_XOP                 (HOST_WIDE_INT_1 << 29)
2923 /* if this reaches 64, need to widen struct pta flags below */
2924
2925   static struct pta
2926     {
2927       const char *const name;           /* processor name or nickname.  */
2928       const enum processor_type processor;
2929       const enum attr_cpu schedule;
2930       const unsigned HOST_WIDE_INT flags;
2931     }
2932   const processor_alias_table[] =
2933     {
2934       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2935       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2936       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2937       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2938       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2939       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2940       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2941       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2942       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2943       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2944       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2945       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2946       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2947         PTA_MMX | PTA_SSE},
2948       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2949         PTA_MMX | PTA_SSE},
2950       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2951         PTA_MMX | PTA_SSE | PTA_SSE2},
2952       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2953         PTA_MMX |PTA_SSE | PTA_SSE2},
2954       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2955         PTA_MMX | PTA_SSE | PTA_SSE2},
2956       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2957         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2958       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2959         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2960         | PTA_CX16 | PTA_NO_SAHF},
2961       {"core2", PROCESSOR_CORE2_64, CPU_CORE2,
2962         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2963         | PTA_SSSE3 | PTA_CX16},
2964       {"corei7", PROCESSOR_COREI7_64, CPU_COREI7,
2965         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2966         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_CX16},
2967       {"corei7-avx", PROCESSOR_COREI7_64, CPU_COREI7,
2968         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2969         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2970         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL},
2971       {"core-avx-i", PROCESSOR_COREI7_64, CPU_COREI7,
2972         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2973         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2974         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2975         | PTA_RDRND | PTA_F16C},
2976       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2977         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2978         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2979       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2980         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2981       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2982       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2983       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2984       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
2985         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2986       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
2987         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2988       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
2989         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2990       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
2991         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2992       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
2993         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2994       {"x86-64", PROCESSOR_K8, CPU_K8,
2995         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
2996       {"k8", PROCESSOR_K8, CPU_K8,
2997         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2998         | PTA_SSE2 | PTA_NO_SAHF},
2999       {"k8-sse3", PROCESSOR_K8, CPU_K8,
3000         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3001         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3002       {"opteron", PROCESSOR_K8, CPU_K8,
3003         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3004         | PTA_SSE2 | PTA_NO_SAHF},
3005       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3006         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3007         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3008       {"athlon64", PROCESSOR_K8, CPU_K8,
3009         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3010         | PTA_SSE2 | PTA_NO_SAHF},
3011       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3012         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3013         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3014       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3015         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3016         | PTA_SSE2 | PTA_NO_SAHF},
3017       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3018         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3019         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3020       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3021         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3022         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3023       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3024         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3025         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3026         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3027         | PTA_XOP | PTA_LWP},
3028       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3029         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3030         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3031         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3032         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3033         | PTA_FMA},
3034       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC64,
3035         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3036         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16},
3037       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
3038         0 /* flags are only used for -march switch.  */ },
3039       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
3040         PTA_64BIT /* flags are only used for -march switch.  */ },
3041     };
3042
3043   int const pta_size = ARRAY_SIZE (processor_alias_table);
3044
3045   /* Set up prefix/suffix so the error messages refer to either the command
3046      line argument, or the attribute(target).  */
3047   if (main_args_p)
3048     {
3049       prefix = "-m";
3050       suffix = "";
3051       sw = "switch";
3052     }
3053   else
3054     {
3055       prefix = "option(\"";
3056       suffix = "\")";
3057       sw = "attribute";
3058     }
3059
3060 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3061   SUBTARGET_OVERRIDE_OPTIONS;
3062 #endif
3063
3064 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3065   SUBSUBTARGET_OVERRIDE_OPTIONS;
3066 #endif
3067
3068   if (TARGET_X32)
3069     ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3070
3071   /* -fPIC is the default for x86_64.  */
3072   if (TARGET_MACHO && TARGET_64BIT)
3073     flag_pic = 2;
3074
3075   /* Need to check -mtune=generic first.  */
3076   if (ix86_tune_string)
3077     {
3078       if (!strcmp (ix86_tune_string, "generic")
3079           || !strcmp (ix86_tune_string, "i686")
3080           /* As special support for cross compilers we read -mtune=native
3081              as -mtune=generic.  With native compilers we won't see the
3082              -mtune=native, as it was changed by the driver.  */
3083           || !strcmp (ix86_tune_string, "native"))
3084         {
3085           if (TARGET_64BIT)
3086             ix86_tune_string = "generic64";
3087           else
3088             ix86_tune_string = "generic32";
3089         }
3090       /* If this call is for setting the option attribute, allow the
3091          generic32/generic64 that was previously set.  */
3092       else if (!main_args_p
3093                && (!strcmp (ix86_tune_string, "generic32")
3094                    || !strcmp (ix86_tune_string, "generic64")))
3095         ;
3096       else if (!strncmp (ix86_tune_string, "generic", 7))
3097         error ("bad value (%s) for %stune=%s %s",
3098                ix86_tune_string, prefix, suffix, sw);
3099       else if (!strcmp (ix86_tune_string, "x86-64"))
3100         warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated; use "
3101                  "%stune=k8%s or %stune=generic%s instead as appropriate",
3102                  prefix, suffix, prefix, suffix, prefix, suffix);
3103     }
3104   else
3105     {
3106       if (ix86_arch_string)
3107         ix86_tune_string = ix86_arch_string;
3108       if (!ix86_tune_string)
3109         {
3110           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
3111           ix86_tune_defaulted = 1;
3112         }
3113
3114       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
3115          need to use a sensible tune option.  */
3116       if (!strcmp (ix86_tune_string, "generic")
3117           || !strcmp (ix86_tune_string, "x86-64")
3118           || !strcmp (ix86_tune_string, "i686"))
3119         {
3120           if (TARGET_64BIT)
3121             ix86_tune_string = "generic64";
3122           else
3123             ix86_tune_string = "generic32";
3124         }
3125     }
3126
3127   if (ix86_stringop_alg == rep_prefix_8_byte && !TARGET_64BIT)
3128     {
3129       /* rep; movq isn't available in 32-bit code.  */
3130       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3131       ix86_stringop_alg = no_stringop;
3132     }
3133
3134   if (!ix86_arch_string)
3135     ix86_arch_string = TARGET_64BIT ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3136   else
3137     ix86_arch_specified = 1;
3138
3139   if (!global_options_set.x_ix86_abi)
3140     ix86_abi = DEFAULT_ABI;
3141
3142   if (global_options_set.x_ix86_cmodel)
3143     {
3144       switch (ix86_cmodel)
3145         {
3146         case CM_SMALL:
3147         case CM_SMALL_PIC:
3148           if (flag_pic)
3149             ix86_cmodel = CM_SMALL_PIC;
3150           if (!TARGET_64BIT)
3151             error ("code model %qs not supported in the %s bit mode",
3152                    "small", "32");
3153           break;
3154
3155         case CM_MEDIUM:
3156         case CM_MEDIUM_PIC:
3157           if (flag_pic)
3158             ix86_cmodel = CM_MEDIUM_PIC;
3159           if (!TARGET_64BIT)
3160             error ("code model %qs not supported in the %s bit mode",
3161                    "medium", "32");
3162           else if (TARGET_X32)
3163             error ("code model %qs not supported in x32 mode",
3164                    "medium");