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 (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 (int, int, const char *, const char *,
2518                                  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 (int isa, int flags, const char *arch, const char *tune,
2637                     enum fpmath_unit fpmath, bool add_nl_p)
2638 {
2639   struct ix86_target_opts
2640   {
2641     const char *option;         /* option string */
2642     int mask;                   /* isa mask options */
2643   };
2644
2645   /* This table is ordered so that options like -msse4.2 that imply
2646      preceding options while match those first.  */
2647   static struct ix86_target_opts isa_opts[] =
2648   {
2649     { "-m64",           OPTION_MASK_ISA_64BIT },
2650     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2651     { "-mfma",          OPTION_MASK_ISA_FMA },
2652     { "-mxop",          OPTION_MASK_ISA_XOP },
2653     { "-mlwp",          OPTION_MASK_ISA_LWP },
2654     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2655     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2656     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2657     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2658     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2659     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2660     { "-msse",          OPTION_MASK_ISA_SSE },
2661     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2662     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2663     { "-mmmx",          OPTION_MASK_ISA_MMX },
2664     { "-mabm",          OPTION_MASK_ISA_ABM },
2665     { "-mbmi",          OPTION_MASK_ISA_BMI },
2666     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2667     { "-mtbm",          OPTION_MASK_ISA_TBM },
2668     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2669     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2670     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2671     { "-maes",          OPTION_MASK_ISA_AES },
2672     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2673     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2674     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2675     { "-mf16c",         OPTION_MASK_ISA_F16C },
2676   };
2677
2678   /* Flag options.  */
2679   static struct ix86_target_opts flag_opts[] =
2680   {
2681     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2682     { "-m80387",                        MASK_80387 },
2683     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2684     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2685     { "-mcld",                          MASK_CLD },
2686     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2687     { "-mieee-fp",                      MASK_IEEE_FP },
2688     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2689     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2690     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2691     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2692     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2693     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2694     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2695     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2696     { "-mrecip",                        MASK_RECIP },
2697     { "-mrtd",                          MASK_RTD },
2698     { "-msseregparm",                   MASK_SSEREGPARM },
2699     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2700     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2701     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2702     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2703     { "-mvzeroupper",                   MASK_VZEROUPPER },
2704     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2705     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2706     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2707   };
2708
2709   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2710
2711   char isa_other[40];
2712   char target_other[40];
2713   unsigned num = 0;
2714   unsigned i, j;
2715   char *ret;
2716   char *ptr;
2717   size_t len;
2718   size_t line_len;
2719   size_t sep_len;
2720
2721   memset (opts, '\0', sizeof (opts));
2722
2723   /* Add -march= option.  */
2724   if (arch)
2725     {
2726       opts[num][0] = "-march=";
2727       opts[num++][1] = arch;
2728     }
2729
2730   /* Add -mtune= option.  */
2731   if (tune)
2732     {
2733       opts[num][0] = "-mtune=";
2734       opts[num++][1] = tune;
2735     }
2736
2737   /* Pick out the options in isa options.  */
2738   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2739     {
2740       if ((isa & isa_opts[i].mask) != 0)
2741         {
2742           opts[num++][0] = isa_opts[i].option;
2743           isa &= ~ isa_opts[i].mask;
2744         }
2745     }
2746
2747   if (isa && add_nl_p)
2748     {
2749       opts[num++][0] = isa_other;
2750       sprintf (isa_other, "(other isa: %#x)", isa);
2751     }
2752
2753   /* Add flag options.  */
2754   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2755     {
2756       if ((flags & flag_opts[i].mask) != 0)
2757         {
2758           opts[num++][0] = flag_opts[i].option;
2759           flags &= ~ flag_opts[i].mask;
2760         }
2761     }
2762
2763   if (flags && add_nl_p)
2764     {
2765       opts[num++][0] = target_other;
2766       sprintf (target_other, "(other flags: %#x)", flags);
2767     }
2768
2769   /* Add -fpmath= option.  */
2770   if (fpmath)
2771     {
2772       opts[num][0] = "-mfpmath=";
2773       switch ((int) fpmath)
2774         {
2775         case FPMATH_387:
2776           opts[num++][1] = "387";
2777           break;
2778
2779         case FPMATH_SSE:
2780           opts[num++][1] = "sse";
2781           break;
2782
2783         case FPMATH_387 | FPMATH_SSE:
2784           opts[num++][1] = "sse+387";
2785           break;
2786
2787         default:
2788           gcc_unreachable ();
2789         }
2790     }
2791
2792   /* Any options?  */
2793   if (num == 0)
2794     return NULL;
2795
2796   gcc_assert (num < ARRAY_SIZE (opts));
2797
2798   /* Size the string.  */
2799   len = 0;
2800   sep_len = (add_nl_p) ? 3 : 1;
2801   for (i = 0; i < num; i++)
2802     {
2803       len += sep_len;
2804       for (j = 0; j < 2; j++)
2805         if (opts[i][j])
2806           len += strlen (opts[i][j]);
2807     }
2808
2809   /* Build the string.  */
2810   ret = ptr = (char *) xmalloc (len);
2811   line_len = 0;
2812
2813   for (i = 0; i < num; i++)
2814     {
2815       size_t len2[2];
2816
2817       for (j = 0; j < 2; j++)
2818         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2819
2820       if (i != 0)
2821         {
2822           *ptr++ = ' ';
2823           line_len++;
2824
2825           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2826             {
2827               *ptr++ = '\\';
2828               *ptr++ = '\n';
2829               line_len = 0;
2830             }
2831         }
2832
2833       for (j = 0; j < 2; j++)
2834         if (opts[i][j])
2835           {
2836             memcpy (ptr, opts[i][j], len2[j]);
2837             ptr += len2[j];
2838             line_len += len2[j];
2839           }
2840     }
2841
2842   *ptr = '\0';
2843   gcc_assert (ret + len >= ptr);
2844
2845   return ret;
2846 }
2847
2848 /* Return true, if profiling code should be emitted before
2849    prologue. Otherwise it returns false.
2850    Note: For x86 with "hotfix" it is sorried.  */
2851 static bool
2852 ix86_profile_before_prologue (void)
2853 {
2854   return flag_fentry != 0;
2855 }
2856
2857 /* Function that is callable from the debugger to print the current
2858    options.  */
2859 void
2860 ix86_debug_options (void)
2861 {
2862   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2863                                    ix86_arch_string, ix86_tune_string,
2864                                    ix86_fpmath, true);
2865
2866   if (opts)
2867     {
2868       fprintf (stderr, "%s\n\n", opts);
2869       free (opts);
2870     }
2871   else
2872     fputs ("<no options>\n\n", stderr);
2873
2874   return;
2875 }
2876 \f
2877 /* Override various settings based on options.  If MAIN_ARGS_P, the
2878    options are from the command line, otherwise they are from
2879    attributes.  */
2880
2881 static void
2882 ix86_option_override_internal (bool main_args_p)
2883 {
2884   int i;
2885   unsigned int ix86_arch_mask, ix86_tune_mask;
2886   const bool ix86_tune_specified = (ix86_tune_string != NULL);
2887   const char *prefix;
2888   const char *suffix;
2889   const char *sw;
2890
2891   enum pta_flags
2892     {
2893       PTA_SSE = 1 << 0,
2894       PTA_SSE2 = 1 << 1,
2895       PTA_SSE3 = 1 << 2,
2896       PTA_MMX = 1 << 3,
2897       PTA_PREFETCH_SSE = 1 << 4,
2898       PTA_3DNOW = 1 << 5,
2899       PTA_3DNOW_A = 1 << 6,
2900       PTA_64BIT = 1 << 7,
2901       PTA_SSSE3 = 1 << 8,
2902       PTA_CX16 = 1 << 9,
2903       PTA_POPCNT = 1 << 10,
2904       PTA_ABM = 1 << 11,
2905       PTA_SSE4A = 1 << 12,
2906       PTA_NO_SAHF = 1 << 13,
2907       PTA_SSE4_1 = 1 << 14,
2908       PTA_SSE4_2 = 1 << 15,
2909       PTA_AES = 1 << 16,
2910       PTA_PCLMUL = 1 << 17,
2911       PTA_AVX = 1 << 18,
2912       PTA_FMA = 1 << 19,
2913       PTA_MOVBE = 1 << 20,
2914       PTA_FMA4 = 1 << 21,
2915       PTA_XOP = 1 << 22,
2916       PTA_LWP = 1 << 23,
2917       PTA_FSGSBASE = 1 << 24,
2918       PTA_RDRND = 1 << 25,
2919       PTA_F16C = 1 << 26,
2920       PTA_BMI = 1 << 27,
2921       PTA_TBM = 1 << 28,
2922       PTA_LZCNT = 1 << 29
2923       /* if this reaches 32, need to widen struct pta flags below */
2924     };
2925
2926   static struct pta
2927     {
2928       const char *const name;           /* processor name or nickname.  */
2929       const enum processor_type processor;
2930       const enum attr_cpu schedule;
2931       const unsigned /*enum pta_flags*/ flags;
2932     }
2933   const processor_alias_table[] =
2934     {
2935       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2936       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2937       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2938       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2939       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2940       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2941       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2942       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2943       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2944       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2945       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2946       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2947       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2948         PTA_MMX | PTA_SSE},
2949       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2950         PTA_MMX | PTA_SSE},
2951       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2952         PTA_MMX | PTA_SSE | PTA_SSE2},
2953       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2954         PTA_MMX |PTA_SSE | PTA_SSE2},
2955       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2956         PTA_MMX | PTA_SSE | PTA_SSE2},
2957       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2958         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2959       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2960         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2961         | PTA_CX16 | PTA_NO_SAHF},
2962       {"core2", PROCESSOR_CORE2_64, CPU_CORE2,
2963         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2964         | PTA_SSSE3 | PTA_CX16},
2965       {"corei7", PROCESSOR_COREI7_64, CPU_COREI7,
2966         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2967         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_CX16},
2968       {"corei7-avx", PROCESSOR_COREI7_64, CPU_COREI7,
2969         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2970         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2971         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL},
2972       {"core-avx-i", PROCESSOR_COREI7_64, CPU_COREI7,
2973         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2974         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2975         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2976         | PTA_RDRND | PTA_F16C},
2977       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2978         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2979         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2980       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2981         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2982       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2983       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2984       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2985       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
2986         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2987       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
2988         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
2989       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
2990         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2991       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
2992         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2993       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
2994         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
2995       {"x86-64", PROCESSOR_K8, CPU_K8,
2996         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
2997       {"k8", PROCESSOR_K8, CPU_K8,
2998         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
2999         | PTA_SSE2 | PTA_NO_SAHF},
3000       {"k8-sse3", PROCESSOR_K8, CPU_K8,
3001         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3002         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3003       {"opteron", PROCESSOR_K8, CPU_K8,
3004         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3005         | PTA_SSE2 | PTA_NO_SAHF},
3006       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3007         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3008         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3009       {"athlon64", PROCESSOR_K8, CPU_K8,
3010         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3011         | PTA_SSE2 | PTA_NO_SAHF},
3012       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3013         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3014         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3015       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3016         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3017         | PTA_SSE2 | PTA_NO_SAHF},
3018       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3019         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3020         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3021       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3022         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3023         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3024       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3025         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3026         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3027         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3028         | PTA_XOP | PTA_LWP},
3029       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3030         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3031         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3032         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3033         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3034         | PTA_FMA},
3035       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC64,
3036         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3037         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16},
3038       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
3039         0 /* flags are only used for -march switch.  */ },
3040       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
3041         PTA_64BIT /* flags are only used for -march switch.  */ },
3042     };
3043
3044   int const pta_size = ARRAY_SIZE (processor_alias_table);
3045
3046   /* Set up prefix/suffix so the error messages refer to either the command
3047      line argument, or the attribute(target).  */
3048   if (main_args_p)
3049     {
3050       prefix = "-m";
3051       suffix = "";
3052       sw = "switch";
3053     }
3054   else
3055     {
3056       prefix = "option(\"";
3057       suffix = "\")";
3058       sw = "attribute";
3059     }
3060
3061 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3062   SUBTARGET_OVERRIDE_OPTIONS;
3063 #endif
3064
3065 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3066   SUBSUBTARGET_OVERRIDE_OPTIONS;
3067 #endif
3068
3069   if (TARGET_X32)
3070     ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3071
3072   /* -fPIC is the default for x86_64.  */
3073   if (TARGET_MACHO && TARGET_64BIT)
3074     flag_pic = 2;
3075
3076   /* Need to check -mtune=generic first.  */
3077   if (ix86_tune_string)
3078     {
3079       if (!strcmp (ix86_tune_string, "generic")
3080           || !strcmp (ix86_tune_string, "i686")
3081           /* As special support for cross compilers we read -mtune=native
3082              as -mtune=generic.  With native compilers we won't see the
3083              -mtune=native, as it was changed by the driver.  */
3084           || !strcmp (ix86_tune_string, "native"))
3085         {
3086           if (TARGET_64BIT)
3087             ix86_tune_string = "generic64";
3088           else
3089             ix86_tune_string = "generic32";
3090         }
3091       /* If this call is for setting the option attribute, allow the
3092          generic32/generic64 that was previously set.  */
3093       else if (!main_args_p
3094                && (!strcmp (ix86_tune_string, "generic32")
3095                    || !strcmp (ix86_tune_string, "generic64")))
3096         ;
3097       else if (!strncmp (ix86_tune_string, "generic", 7))
3098         error ("bad value (%s) for %stune=%s %s",
3099                ix86_tune_string, prefix, suffix, sw);
3100       else if (!strcmp (ix86_tune_string, "x86-64"))
3101         warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated; use "
3102                  "%stune=k8%s or %stune=generic%s instead as appropriate",
3103                  prefix, suffix, prefix, suffix, prefix, suffix);
3104     }
3105   else
3106     {
3107       if (ix86_arch_string)
3108         ix86_tune_string = ix86_arch_string;
3109       if (!ix86_tune_string)
3110         {
3111           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
3112           ix86_tune_defaulted = 1;
3113         }
3114
3115       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
3116          need to use a sensible tune option.  */
3117       if (!strcmp (ix86_tune_string, "generic")
3118           || !strcmp (ix86_tune_string, "x86-64")
3119           || !strcmp (ix86_tune_string, "i686"))
3120         {
3121           if (TARGET_64BIT)
3122             ix86_tune_string = "generic64";
3123           else
3124             ix86_tune_string = "generic32";
3125         }
3126     }
3127
3128   if (ix86_stringop_alg == rep_prefix_8_byte && !TARGET_64BIT)
3129     {
3130       /* rep; movq isn't available in 32-bit code.  */
3131       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3132       ix86_stringop_alg = no_stringop;
3133     }
3134
3135   if (!ix86_arch_string)
3136     ix86_arch_string = TARGET_64BIT ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3137   else
3138     ix86_arch_specified = 1;
3139
3140   if (!global_options_set.x_ix86_abi)
3141     ix86_abi = DEFAULT_ABI;
3142
3143   if (global_options_set.x_ix86_cmodel)
3144     {
3145       switch (ix86_cmodel)
3146         {
3147         case CM_SMALL:
3148         case CM_SMALL_PIC:
3149           if (flag_pic)
3150             ix86_cmodel = CM_SMALL_PIC;
3151           if (!TARGET_64BIT)
3152             error ("code model %qs not supported in the %s bit mode",
3153                    "small", "32");
3154           break;
3155
3156         case CM_MEDIUM:
3157         case CM_MEDIUM_PIC:
3158           if (flag_pic)
3159             ix86_cmodel = CM_MEDIUM_PIC;
3160           if (!TARGET_64BIT)
3161             error ("code model %qs not supported in the %s bit mode",
3162                    "medium", "32");
3163           else if (TARGET_X32)
3164             error ("code model %qs not supported in x32 mode",
3165                    "medium");
3166           break;
3167
3168         case CM_LARGE:
3169         case CM_LARGE_PIC:
3170           if (flag_pic)
3171             ix86_cmodel = CM_LARGE_PIC;
3172           if (!TARGET_64BIT)
3173             error ("code model %qs not supported in the %s bit mode",
3174                    "large", "32");
3175           else if (TARGET_X32)
3176             error ("code model %qs not supported in x32 mode",
3177                    "medium");
3178           break;
3179
3180         case CM_32:
3181           if (flag_pic)
3182             error ("code model %s does not support PIC mode", "32");
3183           if (TARGET_64BIT)
3184             error ("code model %qs not supported in the %s bit mode",
3185                    "32", "64");
3186           break;
3187
3188         case CM_KERNEL:
3189           if (flag_pic)
3190             {
3191               error ("code model %s does not support PIC mode", "kernel");
3192               ix86_cmodel = CM_32;
3193             }
3194           if (!TARGET_64BIT)
3195             error ("code model %qs not supported in the %s bit mode",
3196                    "kernel", "32");
3197           break;
3198
3199         default:
3200           gcc_unreachable ();
3201         }
3202     }
3203   else
3204     {
3205       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
3206          use of rip-relative addressing.  This eliminates fixups that
3207          would otherwise be needed if this object is to be placed in a
3208          DLL, and is essentially just as efficient as direct addressing.  */
3209       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
3210         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
3211       else if (TARGET_64BIT)
3212         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
3213       else
3214         ix86_cmodel = CM_32;
3215     }
3216   if (TARGET_MACHO && ix86_asm_dialect == ASM_INTEL)
3217     {
3218       error ("-masm=intel not supported in this configuration");
3219       ix86_asm_dialect = ASM_ATT;
3220     }
3221   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
3222     sorry ("%i-bit mode not compiled in",
3223            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
3224
3225   for (i = 0; i < pta_size; i++)
3226     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
3227       {
3228         ix86_schedule = processor_alias_table[i].schedule;
3229         ix86_arch = processor_alias_table[i].processor;
3230         /* Default cpu tuning to the architecture.  */
3231         ix86_tune = ix86_arch;
3232
3233         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
3234           error ("CPU you selected does not support x86-64 "
3235                  "instruction set");
3236
3237         if (processor_alias_table[i].flags & PTA_MMX
3238             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
3239           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
3240         if (processor_alias_table[i].flags & PTA_3DNOW
3241             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
3242           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
3243         if (processor_alias_table[i].flags & PTA_3DNOW_A
3244             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
3245           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
3246         if (processor_alias_table[i].flags & PTA_SSE
3247             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
3248           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
3249         if (processor_alias_table[i].flags & PTA_SSE2
3250             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
3251           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
3252         if (processor_alias_table[i].flags & PTA_SSE3
3253             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
3254           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
3255         if (processor_alias_table[i].flags & PTA_SSSE3
3256             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
3257           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
3258         if (processor_alias_table[i].flags & PTA_SSE4_1
3259             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
3260           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
3261         if (processor_alias_table[i].flags & PTA_SSE4_2
3262             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
3263           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
3264         if (processor_alias_table[i].flags & PTA_AVX
3265             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
3266           ix86_isa_flags |= OPTION_MASK_ISA_AVX;
3267         if (processor_alias_table[i].flags & PTA_FMA
3268             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
3269           ix86_isa_flags |= OPTION_MASK_ISA_FMA;
3270         if (processor_alias_table[i].flags & PTA_SSE4A
3271             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
3272           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
3273         if (processor_alias_table[i].flags & PTA_FMA4
3274             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
3275           ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
3276         if (processor_alias_table[i].flags & PTA_XOP
3277             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
3278           ix86_isa_flags |= OPTION_MASK_ISA_XOP;
3279         if (processor_alias_table[i].flags & PTA_LWP
3280             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
3281           ix86_isa_flags |= OPTION_MASK_ISA_LWP;
3282         if (processor_alias_table[i].flags & PTA_ABM
3283             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
3284           ix86_isa_flags |= OPTION_MASK_ISA_ABM;
3285         if (processor_alias_table[i].flags & PTA_BMI
3286             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI))
3287           ix86_isa_flags |= OPTION_MASK_ISA_BMI;
3288         if (processor_alias_table[i].flags & (PTA_LZCNT | PTA_ABM)
3289             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LZCNT))
3290           ix86_isa_flags |= OPTION_MASK_ISA_LZCNT;
3291         if (processor_alias_table[i].flags & PTA_TBM
3292             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_TBM))
3293           ix86_isa_flags |= OPTION_MASK_ISA_TBM;
3294         if (processor_alias_table[i].flags & PTA_CX16
3295             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_CX16))
3296           ix86_isa_flags |= OPTION_MASK_ISA_CX16;
3297         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)
3298             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
3299           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
3300         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF))
3301             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
3302           ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
3303         if (processor_alias_table[i].flags & PTA_MOVBE
3304             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MOVBE))
3305           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE;
3306         if (processor_alias_table[i].flags & PTA_AES
3307             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
3308           ix86_isa_flags |= OPTION_MASK_ISA_AES;
3309         if (processor_alias_table[i].flags & PTA_PCLMUL
3310             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
3311           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
3312         if (processor_alias_table[i].flags & PTA_FSGSBASE
3313             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FSGSBASE))
3314           ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE;
3315         if (processor_alias_table[i].flags & PTA_RDRND
3316             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_RDRND))
3317           ix86_isa_flags |= OPTION_MASK_ISA_RDRND;
3318         if (processor_alias_table[i].flags & PTA_F16C
3319             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_F16C))
3320           ix86_isa_flags |= OPTION_MASK_ISA_F16C;
3321         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
3322           x86_prefetch_sse = true;
3323
3324         break;
3325       }
3326
3327   if (!strcmp (ix86_arch_string, "generic"))
3328     error ("generic CPU can be used only for %stune=%s %s",
3329            prefix, suffix, sw);
3330   else if (!strncmp (ix86_arch_string, "generic", 7) || i == pta_size)
3331     error ("bad value (%s) for %sarch=%s %s",
3332            ix86_arch_string, prefix, suffix, sw);
3333
3334   ix86_arch_mask = 1u << ix86_arch;
3335   for (i = 0; i < X86_ARCH_LAST; ++i)
3336     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3337
3338   for (i = 0; i < pta_size; i++)
3339     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
3340       {
3341         ix86_schedule = processor_alias_table[i].schedule;
3342         ix86_tune = processor_alias_table[i].processor;
3343         if (TARGET_64BIT)
3344           {
3345             if (!(processor_alias_table[i].flags & PTA_64BIT))
3346               {
3347                 if (ix86_tune_defaulted)
3348                   {
3349                     ix86_tune_string = "x86-64";
3350                     for (i = 0; i < pta_size; i++)
3351                       if (! strcmp (ix86_tune_string,
3352                                     processor_alias_table[i].name))
3353                         break;
3354                     ix86_schedule = processor_alias_table[i].schedule;
3355                     ix86_tune = processor_alias_table[i].processor;
3356                   }
3357                 else
3358                   error ("CPU you selected does not support x86-64 "
3359                          "instruction set");
3360               }
3361           }
3362         else
3363           {
3364             /* Adjust tuning when compiling for 32-bit ABI.  */
3365             switch (ix86_tune)
3366               {
3367               case PROCESSOR_GENERIC64:
3368                 ix86_tune = PROCESSOR_GENERIC32;
3369                 ix86_schedule = CPU_PENTIUMPRO;
3370                 break;
3371
3372               case PROCESSOR_CORE2_64:
3373                 ix86_tune = PROCESSOR_CORE2_32;
3374                 break;
3375
3376               case PROCESSOR_COREI7_64:
3377                 ix86_tune = PROCESSOR_COREI7_32;
3378                 break;
3379
3380               default:
3381                 break;
3382               }
3383           }
3384         /* Intel CPUs have always interpreted SSE prefetch instructions as
3385            NOPs; so, we can enable SSE prefetch instructions even when
3386            -mtune (rather than -march) points us to a processor that has them.
3387            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
3388            higher processors.  */
3389         if (TARGET_CMOVE
3390             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
3391           x86_prefetch_sse = true;
3392         break;
3393       }
3394
3395   if (ix86_tune_specified && i == pta_size)
3396     error ("bad value (%s) for %stune=%s %s",
3397            ix86_tune_string, prefix, suffix, sw);
3398
3399   ix86_tune_mask = 1u << ix86_tune;
3400   for (i = 0; i < X86_TUNE_LAST; ++i)
3401     ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3402
3403 #ifndef USE_IX86_FRAME_POINTER
3404 #define USE_IX86_FRAME_POINTER 0
3405 #endif
3406
3407 #ifndef USE_X86_64_FRAME_POINTER
3408 #define USE_X86_64_FRAME_POINTER 0
3409 #endif
3410
3411   /* Set the default values for switches whose default depends on TARGET_64BIT
3412      in case they weren't overwritten by command line options.  */
3413   if (TARGET_64BIT)
3414     {
3415       if (optimize > 1 && !global_options_set.x_flag_zee)
3416         flag_zee = 1;
3417       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3418         flag_omit_frame_pointer = !USE_X86_64_FRAME_POINTER;
3419       if (flag_asynchronous_unwind_tables == 2)
3420         flag_unwind_tables = flag_asynchronous_unwind_tables = 1;
3421       if (flag_pcc_struct_return == 2)
3422         flag_pcc_struct_return = 0;
3423     }
3424   else
3425     {
3426       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3427         flag_omit_frame_pointer = !(USE_IX86_FRAME_POINTER || optimize_size);
3428       if (flag_asynchronous_unwind_tables == 2)
3429         flag_asynchronous_unwind_tables = !USE_IX86_FRAME_POINTER;
3430       if (flag_pcc_struct_return == 2)
3431         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
3432     }
3433
3434   if (optimize_size)
3435     ix86_cost = &ix86_size_cost;
3436   else
3437     ix86_cost = processor_target_table[ix86_tune].cost;
3438
3439   /* Arrange to set up i386_stack_locals for all functions.  */
3440   init_machine_status = ix86_init_machine_status;
3441
3442   /* Validate -mregparm= value.  */
3443   if (global_options_set.x_ix86_regparm)
3444     {
3445       if (TARGET_64BIT)
3446         warning (0, "-mregparm is ignored in 64-bit mode");
3447       if (ix86_regparm > REGPARM_MAX)
3448         {
3449           error ("-mregparm=%d is not between 0 and %d",
3450                  ix86_regparm, REGPARM_MAX);
3451           ix86_regparm = 0;
3452         }
3453     }
3454   if (TARGET_64BIT)
3455     ix86_regparm = REGPARM_MAX;
3456
3457   /* Default align_* from the processor table.  */
3458   if (align_loops == 0)
3459     {
3460       align_loops = processor_target_table[ix86_tune].align_loop;
3461       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3462     }
3463   if (align_jumps == 0)
3464     {
3465       align_jumps = processor_target_table[ix86_tune].align_jump;
3466       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3467     }
3468   if (align_functions == 0)
3469     {
3470       align_functions = processor_target_table[ix86_tune].align_func;
3471     }
3472
3473   /* Provide default for -mbranch-cost= value.  */
3474   if (!global_options_set.x_ix86_branch_cost)
3475     ix86_branch_cost = ix86_cost->branch_cost;
3476
3477   if (TARGET_64BIT)
3478     {
3479       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
3480
3481       /* Enable by default the SSE and MMX builtins.  Do allow the user to
3482          explicitly disable any of these.  In particular, disabling SSE and
3483          MMX for kernel code is extremely useful.  */
3484       if (!ix86_arch_specified)
3485       ix86_isa_flags
3486         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
3487              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
3488
3489       if (TARGET_RTD)
3490         warning (0, "%srtd%s is ignored in 64bit mode", prefix, suffix);
3491     }
3492   else
3493     {
3494       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
3495
3496       if (!ix86_arch_specified)
3497       ix86_isa_flags
3498         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
3499
3500       /* i386 ABI does not specify red zone.  It still makes sense to use it
3501          when programmer takes care to stack from being destroyed.  */
3502       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
3503         target_flags |= MASK_NO_RED_ZONE;
3504     }
3505
3506   /* Keep nonleaf frame pointers.  */
3507   if (flag_omit_frame_pointer)
3508     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
3509   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
3510     flag_omit_frame_pointer = 1;
3511
3512   /* If we're doing fast math, we don't care about comparison order
3513      wrt NaNs.  This lets us use a shorter comparison sequence.  */
3514   if (flag_finite_math_only)
3515     target_flags &= ~MASK_IEEE_FP;
3516
3517   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
3518      since the insns won't need emulation.  */
3519   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
3520     target_flags &= ~MASK_NO_FANCY_MATH_387;
3521
3522   /* Likewise, if the target doesn't have a 387, or we've specified
3523      software floating point, don't use 387 inline intrinsics.  */
3524   if (!TARGET_80387)
3525     target_flags |= MASK_NO_FANCY_MATH_387;
3526
3527   /* Turn on MMX builtins for -msse.  */
3528   if (TARGET_SSE)
3529     {
3530       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
3531       x86_prefetch_sse = true;
3532     }
3533
3534   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
3535   if (TARGET_SSE4_2 || TARGET_ABM)
3536     ix86_isa_flags |= OPTION_MASK_ISA_POPCNT & ~ix86_isa_flags_explicit;
3537
3538   /* Turn on lzcnt instruction for -mabm.  */
3539   if (TARGET_ABM)
3540     ix86_isa_flags |= OPTION_MASK_ISA_LZCNT & ~ix86_isa_flags_explicit;
3541
3542   /* Validate -mpreferred-stack-boundary= value or default it to
3543      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
3544   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
3545   if (global_options_set.x_ix86_preferred_stack_boundary_arg)
3546     {
3547       int min = (TARGET_64BIT ? 4 : 2);
3548       int max = (TARGET_SEH ? 4 : 12);
3549
3550       if (ix86_preferred_stack_boundary_arg < min
3551           || ix86_preferred_stack_boundary_arg > max)
3552         {
3553           if (min == max)
3554             error ("-mpreferred-stack-boundary is not supported "
3555                    "for this target");
3556           else
3557             error ("-mpreferred-stack-boundary=%d is not between %d and %d",
3558                    ix86_preferred_stack_boundary_arg, min, max);
3559         }
3560       else
3561         ix86_preferred_stack_boundary
3562           = (1 << ix86_preferred_stack_boundary_arg) * BITS_PER_UNIT;
3563     }
3564
3565   /* Set the default value for -mstackrealign.  */
3566   if (ix86_force_align_arg_pointer == -1)
3567     ix86_force_align_arg_pointer = STACK_REALIGN_DEFAULT;
3568
3569   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
3570
3571   /* Validate -mincoming-stack-boundary= value or default it to
3572      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
3573   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
3574   if (global_options_set.x_ix86_incoming_stack_boundary_arg)
3575     {
3576       if (ix86_incoming_stack_boundary_arg < (TARGET_64BIT ? 4 : 2)
3577           || ix86_incoming_stack_boundary_arg > 12)
3578         error ("-mincoming-stack-boundary=%d is not between %d and 12",
3579                ix86_incoming_stack_boundary_arg, TARGET_64BIT ? 4 : 2);
3580       else
3581         {
3582           ix86_user_incoming_stack_boundary
3583             = (1 << ix86_incoming_stack_boundary_arg) * BITS_PER_UNIT;
3584           ix86_incoming_stack_boundary
3585             = ix86_user_incoming_stack_boundary;
3586         }
3587     }
3588
3589   /* Accept -msseregparm only if at least SSE support is enabled.  */
3590   if (TARGET_SSEREGPARM
3591       && ! TARGET_SSE)
3592     error ("%ssseregparm%s used without SSE enabled", prefix, suffix);
3593
3594   if (global_options_set.x_ix86_fpmath)
3595     {
3596       if (ix86_fpmath & FPMATH_SSE)
3597         {
3598           if (!TARGET_SSE)
3599             {
3600               warning (0, "SSE instruction set disabled, using 387 arithmetics");
3601               ix86_fpmath = FPMATH_387;
3602             }
3603           else if ((ix86_fpmath & FPMATH_387) && !TARGET_80387)
3604             {
3605               warning (0, "387 instruction set disabled, using SSE arithmetics");
3606               ix86_fpmath = FPMATH_SSE;
3607             }
3608         }
3609     }
3610   else
3611     ix86_fpmath = TARGET_FPMATH_DEFAULT;
3612
3613   /* If the i387 is disabled, then do not return values in it. */
3614   if (!TARGET_80387)
3615     target_flags &= ~MASK_FLOAT_RETURNS;
3616
3617   /* Use external vectorized library in vectorizing intrinsics.  */
3618   if (global_options_set.x_ix86_veclibabi_type)
3619     switch (ix86_veclibabi_type)
3620       {
3621       case ix86_veclibabi_type_svml:
3622         ix86_veclib_handler = ix86_veclibabi_svml;
3623         break;
3624
3625       case ix86_veclibabi_type_acml:
3626         ix86_veclib_handler = ix86_veclibabi_acml;
3627         break;
3628
3629       default:
3630         gcc_unreachable ();
3631       }
3632
3633   if ((!USE_IX86_FRAME_POINTER
3634        || (x86_accumulate_outgoing_args & ix86_tune_mask))
3635       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3636       && !optimize_size)
3637     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3638
3639   /* ??? Unwind info is not correct around the CFG unless either a frame
3640      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
3641      unwind info generation to be aware of the CFG and propagating states
3642      around edges.  */
3643   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
3644        || flag_exceptions || flag_non_call_exceptions)
3645       && flag_omit_frame_pointer
3646       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3647     {
3648       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3649         warning (0, "unwind tables currently require either a frame pointer "
3650                  "or %saccumulate-outgoing-args%s for correctness",
3651                  prefix, suffix);
3652       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3653     }
3654
3655   /* If stack probes are required, the space used for large function
3656      arguments on the stack must also be probed, so enable
3657      -maccumulate-outgoing-args so this happens in the prologue.  */
3658   if (TARGET_STACK_PROBE
3659       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3660     {
3661       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3662         warning (0, "stack probing requires %saccumulate-outgoing-args%s "
3663                  "for correctness", prefix, suffix);
3664       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3665     }
3666
3667   /* For sane SSE instruction set generation we need fcomi instruction.
3668      It is safe to enable all CMOVE instructions.  Also, RDRAND intrinsic
3669      expands to a sequence that includes conditional move. */
3670   if (TARGET_SSE || TARGET_RDRND)
3671     TARGET_CMOVE = 1;
3672
3673   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
3674   {
3675     char *p;
3676     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
3677     p = strchr (internal_label_prefix, 'X');
3678     internal_label_prefix_len = p - internal_label_prefix;
3679     *p = '\0';
3680   }
3681
3682   /* When scheduling description is not available, disable scheduler pass
3683      so it won't slow down the compilation and make x87 code slower.  */
3684   if (!TARGET_SCHEDULE)
3685     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
3686
3687   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3688                          ix86_cost->simultaneous_prefetches,
3689                          global_options.x_param_values,
3690                          global_options_set.x_param_values);
3691   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, ix86_cost->prefetch_block,
3692                          global_options.x_param_values,
3693                          global_options_set.x_param_values);
3694   maybe_set_param_value (PARAM_L1_CACHE_SIZE, ix86_cost->l1_cache_size,
3695                          global_options.x_param_values,
3696                          global_options_set.x_param_values);
3697   maybe_set_param_value (PARAM_L2_CACHE_SIZE, ix86_cost->l2_cache_size,
3698                          global_options.x_param_values,
3699                          global_options_set.x_param_values);
3700
3701   /* Enable sw prefetching at -O3 for CPUS that prefetching is helpful.  */
3702   if (flag_prefetch_loop_arrays < 0
3703       && HAVE_prefetch
3704       && optimize >= 3
3705       && TARGET_SOFTWARE_PREFETCHING_BENEFICIAL)
3706     flag_prefetch_loop_arrays = 1;
3707
3708   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
3709      can be optimized to ap = __builtin_next_arg (0).  */
3710   if (!TARGET_64BIT && !flag_split_stack)
3711     targetm.expand_builtin_va_start = NULL;
3712
3713   if (TARGET_64BIT)
3714     {
3715       ix86_gen_leave = gen_leave_rex64;
3716       ix86_gen_add3 = gen_adddi3;
3717       ix86_gen_sub3 = gen_subdi3;
3718       ix86_gen_sub3_carry = gen_subdi3_carry;
3719       ix86_gen_one_cmpl2 = gen_one_cmpldi2;
3720       ix86_gen_monitor = gen_sse3_monitor64;
3721       ix86_gen_andsp = gen_anddi3;
3722       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_di;
3723       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probedi;
3724       ix86_gen_probe_stack_range = gen_probe_stack_rangedi;
3725     }
3726   else
3727     {
3728       ix86_gen_leave = gen_leave;
3729       ix86_gen_add3 = gen_addsi3;
3730       ix86_gen_sub3 = gen_subsi3;
3731       ix86_gen_sub3_carry = gen_subsi3_carry;
3732       ix86_gen_one_cmpl2 = gen_one_cmplsi2;
3733       ix86_gen_monitor = gen_sse3_monitor;
3734       ix86_gen_andsp = gen_andsi3;
3735       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_si;
3736       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probesi;
3737       ix86_gen_probe_stack_range = gen_probe_stack_rangesi;
3738     }
3739
3740 #ifdef USE_IX86_CLD
3741   /* Use -mcld by default for 32-bit code if configured with --enable-cld.  */
3742   if (!TARGET_64BIT)
3743     target_flags |= MASK_CLD & ~target_flags_explicit;
3744 #endif
3745
3746   if (!TARGET_64BIT && flag_pic)
3747     {
3748       if (flag_fentry > 0)
3749         sorry ("-mfentry isn%'t supported for 32-bit in combination "
3750                "with -fpic");
3751       flag_fentry = 0;
3752     }
3753   else if (TARGET_SEH)
3754     {
3755       if (flag_fentry == 0)
3756         sorry ("-mno-fentry isn%'t compatible with SEH");
3757       flag_fentry = 1;
3758     }
3759   else if (flag_fentry < 0)
3760    {
3761 #if defined(PROFILE_BEFORE_PROLOGUE)
3762      flag_fentry = 1;
3763 #else
3764      flag_fentry = 0;
3765 #endif
3766    }
3767
3768   if (TARGET_AVX)
3769     {
3770       /* When not optimize for size, enable vzeroupper optimization for
3771          TARGET_AVX with -fexpensive-optimizations and split 32-byte
3772          AVX unaligned load/store.  */
3773       if (!optimize_size)
3774         {
3775           if (flag_expensive_optimizations
3776               && !(target_flags_explicit & MASK_VZEROUPPER))
3777             target_flags |= MASK_VZEROUPPER;
3778           if ((x86_avx256_split_unaligned_load & ix86_tune_mask)
3779               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_LOAD))
3780             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_LOAD;
3781           if ((x86_avx256_split_unaligned_store & ix86_tune_mask)
3782               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_STORE))
3783             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_STORE;
3784           /* Enable 128-bit AVX instruction generation for the auto-vectorizer.  */
3785           if (TARGET_AVX128_OPTIMAL && !(target_flags_explicit & MASK_PREFER_AVX128))
3786             target_flags |= MASK_PREFER_AVX128;
3787         }
3788     }
3789   else
3790     {
3791       /* Disable vzeroupper pass if TARGET_AVX is disabled.  */
3792       target_flags &= ~MASK_VZEROUPPER;
3793     }
3794
3795   /* Save the initial options in case the user does function specific
3796      options.  */
3797   if (main_args_p)
3798     target_option_default_node = target_option_current_node
3799       = build_target_option_node ();
3800 }
3801
3802 /* Return TRUE if VAL is passed in register with 256bit AVX modes.  */
3803
3804 static bool
3805 function_pass_avx256_p (const_rtx val)
3806 {
3807   if (!val)
3808     return false;
3809
3810   if (REG_P (val) && VALID_AVX256_REG_MODE (GET_MODE (val)))
3811     return true;
3812
3813   if (GET_CODE (val) == PARALLEL)
3814     {
3815       int i;
3816       rtx r;
3817
3818       for (i = XVECLEN (val, 0) - 1; i >= 0; i--)
3819         {
3820           r = XVECEXP (val, 0, i);
3821           if (GET_CODE (r) == EXPR_LIST
3822               && XEXP (r, 0)
3823               && REG_P (XEXP (r, 0))
3824               && (GET_MODE (XEXP (r, 0)) == OImode
3825                   || VALID_AVX256_REG_MODE (GET_MODE (XEXP (r, 0)))))
3826             return true;
3827         }
3828     }
3829
3830   return false;
3831 }
3832
3833 /* Implement the TARGET_OPTION_OVERRIDE hook.  */
3834
3835 static void
3836 ix86_option_override (void)
3837 {
3838   ix86_option_override_internal (true);
3839 }
3840
3841 /* Update register usage after having seen the compiler flags.  */
3842
3843 static void
3844 ix86_conditional_register_usage (void)
3845 {
3846   int i;
3847   unsigned int j;
3848
3849   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3850     {
3851       if (fixed_regs[i] > 1)
3852         fixed_regs[i] = (fixed_regs[i] == (TARGET_64BIT ? 3 : 2));
3853       if (call_used_regs[i] > 1)
3854         call_used_regs[i] = (call_used_regs[i] == (TARGET_64BIT ? 3 : 2));
3855     }
3856
3857   /* The PIC register, if it exists, is fixed.  */
3858   j = PIC_OFFSET_TABLE_REGNUM;
3859   if (j != INVALID_REGNUM)
3860     fixed_regs[j] = call_used_regs[j] = 1;
3861
3862   /* The 64-bit MS_ABI changes the set of call-used registers.  */
3863   if (TARGET_64BIT_MS_ABI)
3864     {
3865       call_used_regs[SI_REG] = 0;
3866       call_used_regs[DI_REG] = 0;
3867       call_used_regs[XMM6_REG] = 0;
3868       call_used_regs[XMM7_REG] = 0;
3869       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3870         call_used_regs[i] = 0;
3871     }
3872
3873   /* The default setting of CLOBBERED_REGS is for 32-bit; add in the
3874      other call-clobbered regs for 64-bit.  */
3875   if (TARGET_64BIT)
3876     {
3877       CLEAR_HARD_REG_SET (reg_class_contents[(int)CLOBBERED_REGS]);
3878
3879       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3880         if (TEST_HARD_REG_BIT (reg_class_contents[(int)GENERAL_REGS], i)
3881             && call_used_regs[i])
3882           SET_HARD_REG_BIT (reg_class_contents[(int)CLOBBERED_REGS], i);
3883     }
3884
3885   /* If MMX is disabled, squash the registers.  */
3886   if (! TARGET_MMX)
3887     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3888       if (TEST_HARD_REG_BIT (reg_class_contents[(int)MMX_REGS], i))
3889         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3890
3891   /* If SSE is disabled, squash the registers.  */
3892   if (! TARGET_SSE)
3893     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3894       if (TEST_HARD_REG_BIT (reg_class_contents[(int)SSE_REGS], i))
3895         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3896
3897   /* If the FPU is disabled, squash the registers.  */
3898   if (! (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387))
3899     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3900       if (TEST_HARD_REG_BIT (reg_class_contents[(int)FLOAT_REGS], i))
3901         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3902
3903   /* If 32-bit, squash the 64-bit registers.  */
3904   if (! TARGET_64BIT)
3905     {
3906       for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++)
3907         reg_names[i] = "";
3908       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3909         reg_names[i] = "";
3910     }
3911 }
3912
3913 \f
3914 /* Save the current options */
3915
3916 static void
3917 ix86_function_specific_save (struct cl_target_option *ptr)
3918 {
3919   ptr->arch = ix86_arch;
3920   ptr->schedule = ix86_schedule;
3921   ptr->tune = ix86_tune;
3922   ptr->branch_cost = ix86_branch_cost;
3923   ptr->tune_defaulted = ix86_tune_defaulted;
3924   ptr->arch_specified = ix86_arch_specified;
3925   ptr->x_ix86_isa_flags_explicit = ix86_isa_flags_explicit;
3926   ptr->ix86_target_flags_explicit = target_flags_explicit;
3927
3928   /* The fields are char but the variables are not; make sure the
3929      values fit in the fields.  */
3930   gcc_assert (ptr->arch == ix86_arch);
3931   gcc_assert (ptr->schedule == ix86_schedule);
3932   gcc_assert (ptr->tune == ix86_tune);
3933   gcc_assert (ptr->branch_cost == ix86_branch_cost);
3934 }
3935
3936 /* Restore the current options */
3937
3938 static void
3939 ix86_function_specific_restore (struct cl_target_option *ptr)
3940 {
3941   enum processor_type old_tune = ix86_tune;
3942   enum processor_type old_arch = ix86_arch;
3943   unsigned int ix86_arch_mask, ix86_tune_mask;
3944   int i;
3945
3946   ix86_arch = (enum processor_type) ptr->arch;
3947   ix86_schedule = (enum attr_cpu) ptr->schedule;
3948   ix86_tune = (enum processor_type) ptr->tune;
3949   ix86_branch_cost = ptr->branch_cost;
3950   ix86_tune_defaulted = ptr->tune_defaulted;
3951   ix86_arch_specified = ptr->arch_specified;
3952   ix86_isa_flags_explicit = ptr->x_ix86_isa_flags_explicit;
3953   target_flags_explicit = ptr->ix86_target_flags_explicit;
3954
3955   /* Recreate the arch feature tests if the arch changed */
3956   if (old_arch != ix86_arch)
3957     {
3958       ix86_arch_mask = 1u << ix86_arch;
3959       for (i = 0; i < X86_ARCH_LAST; ++i)
3960         ix86_arch_features[i]
3961           = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3962     }
3963
3964   /* Recreate the tune optimization tests */
3965   if (old_tune != ix86_tune)
3966     {
3967       ix86_tune_mask = 1u << ix86_tune;
3968       for (i = 0; i < X86_TUNE_LAST; ++i)
3969         ix86_tune_features[i]
3970           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3971     }
3972 }
3973
3974 /* Print the current options */
3975
3976 static void
3977 ix86_function_specific_print (FILE *file, int indent,
3978                               struct cl_target_option *ptr)
3979 {
3980   char *target_string
3981     = ix86_target_string (ptr->x_ix86_isa_flags, ptr->x_target_flags,
3982                           NULL, NULL, ptr->x_ix86_fpmath, false);
3983
3984   fprintf (file, "%*sarch = %d (%s)\n",
3985            indent, "",
3986            ptr->arch,
3987            ((ptr->arch < TARGET_CPU_DEFAULT_max)
3988             ? cpu_names[ptr->arch]
3989             : "<unknown>"));
3990
3991   fprintf (file, "%*stune = %d (%s)\n",
3992            indent, "",
3993            ptr->tune,
3994            ((ptr->tune < TARGET_CPU_DEFAULT_max)
3995             ? cpu_names[ptr->tune]
3996             : "<unknown>"));
3997
3998   fprintf (file, "%*sbranch_cost = %d\n", indent, "", ptr->branch_cost);
3999
4000   if (target_string)
4001     {
4002       fprintf (file, "%*s%s\n", indent, "", target_string);
4003       free (target_string);
4004     }
4005 }
4006
4007 \f
4008 /* Inner function to process the attribute((target(...))), take an argument and
4009    set the current options from the argument. If we have a list, recursively go
4010    over the list.  */
4011
4012 static bool
4013 ix86_valid_target_attribute_inner_p (tree args, char *p_strings[],
4014                                      struct gcc_options *enum_opts_set)
4015 {
4016   char *next_optstr;
4017   bool ret = true;
4018
4019 #define IX86_ATTR_ISA(S,O)   { S, sizeof (S)-1, ix86_opt_isa, O, 0 }
4020 #define IX86_ATTR_STR(S,O)   { S, sizeof (S)-1, ix86_opt_str, O, 0 }
4021 #define IX86_ATTR_ENUM(S,O)  { S, sizeof (S)-1, ix86_opt_enum, O, 0 }
4022 #define IX86_ATTR_YES(S,O,M) { S, sizeof (S)-1, ix86_opt_yes, O, M }
4023 #define IX86_ATTR_NO(S,O,M)  { S, sizeof (S)-1, ix86_opt_no,  O, M }
4024
4025   enum ix86_opt_type
4026   {
4027     ix86_opt_unknown,
4028     ix86_opt_yes,
4029     ix86_opt_no,
4030     ix86_opt_str,
4031     ix86_opt_enum,
4032     ix86_opt_isa
4033   };
4034
4035   static const struct
4036   {
4037     const char *string;
4038     size_t len;
4039     enum ix86_opt_type type;
4040     int opt;
4041     int mask;
4042   } attrs[] = {
4043     /* isa options */
4044     IX86_ATTR_ISA ("3dnow",     OPT_m3dnow),
4045     IX86_ATTR_ISA ("abm",       OPT_mabm),
4046     IX86_ATTR_ISA ("bmi",       OPT_mbmi),
4047     IX86_ATTR_ISA ("lzcnt",     OPT_mlzcnt),
4048     IX86_ATTR_ISA ("tbm",       OPT_mtbm),
4049     IX86_ATTR_ISA ("aes",       OPT_maes),
4050     IX86_ATTR_ISA ("avx",       OPT_mavx),
4051     IX86_ATTR_ISA ("mmx",       OPT_mmmx),
4052     IX86_ATTR_ISA ("pclmul",    OPT_mpclmul),
4053     IX86_ATTR_ISA ("popcnt",    OPT_mpopcnt),
4054     IX86_ATTR_ISA ("sse",       OPT_msse),
4055     IX86_ATTR_ISA ("sse2",      OPT_msse2),
4056     IX86_ATTR_ISA ("sse3",      OPT_msse3),
4057     IX86_ATTR_ISA ("sse4",      OPT_msse4),
4058     IX86_ATTR_ISA ("sse4.1",    OPT_msse4_1),
4059     IX86_ATTR_ISA ("sse4.2",    OPT_msse4_2),
4060     IX86_ATTR_ISA ("sse4a",     OPT_msse4a),
4061     IX86_ATTR_ISA ("ssse3",     OPT_mssse3),
4062     IX86_ATTR_ISA ("fma4",      OPT_mfma4),
4063     IX86_ATTR_ISA ("xop",       OPT_mxop),
4064     IX86_ATTR_ISA ("lwp",       OPT_mlwp),
4065     IX86_ATTR_ISA ("fsgsbase",  OPT_mfsgsbase),
4066     IX86_ATTR_ISA ("rdrnd",     OPT_mrdrnd),
4067     IX86_ATTR_ISA ("f16c",      OPT_mf16c),
4068
4069     /* enum options */
4070     IX86_ATTR_ENUM ("fpmath=",  OPT_mfpmath_),
4071
4072     /* string options */
4073     IX86_ATTR_STR ("arch=",     IX86_FUNCTION_SPECIFIC_ARCH),
4074     IX86_ATTR_STR ("tune=",     IX86_FUNCTION_SPECIFIC_TUNE),
4075
4076     /* flag options */
4077     IX86_ATTR_YES ("cld",
4078                    OPT_mcld,
4079                    MASK_CLD),
4080
4081     IX86_ATTR_NO ("fancy-math-387",
4082                   OPT_mfancy_math_387,
4083                   MASK_NO_FANCY_MATH_387),
4084
4085     IX86_ATTR_YES ("ieee-fp",
4086                    OPT_mieee_fp,
4087                    MASK_IEEE_FP),
4088
4089     IX86_ATTR_YES ("inline-all-stringops",
4090                    OPT_minline_all_stringops,
4091                    MASK_INLINE_ALL_STRINGOPS),
4092
4093     IX86_ATTR_YES ("inline-stringops-dynamically",
4094                    OPT_minline_stringops_dynamically,
4095                    MASK_INLINE_STRINGOPS_DYNAMICALLY),
4096
4097     IX86_ATTR_NO ("align-stringops",
4098                   OPT_mno_align_stringops,
4099                   MASK_NO_ALIGN_STRINGOPS),
4100
4101     IX86_ATTR_YES ("recip",
4102                    OPT_mrecip,
4103                    MASK_RECIP),
4104
4105   };
4106
4107   /* If this is a list, recurse to get the options.  */
4108   if (TREE_CODE (args) == TREE_LIST)
4109     {
4110       bool ret = true;
4111
4112       for (; args; args = TREE_CHAIN (args))
4113         if (TREE_VALUE (args)
4114             && !ix86_valid_target_attribute_inner_p (TREE_VALUE (args),
4115                                                      p_strings, enum_opts_set))
4116           ret = false;
4117
4118       return ret;
4119     }
4120
4121   else if (TREE_CODE (args) != STRING_CST)
4122     gcc_unreachable ();
4123
4124   /* Handle multiple arguments separated by commas.  */
4125   next_optstr = ASTRDUP (TREE_STRING_POINTER (args));
4126
4127   while (next_optstr && *next_optstr != '\0')
4128     {
4129       char *p = next_optstr;
4130       char *orig_p = p;
4131       char *comma = strchr (next_optstr, ',');
4132       const char *opt_string;
4133       size_t len, opt_len;
4134       int opt;
4135       bool opt_set_p;
4136       char ch;
4137       unsigned i;
4138       enum ix86_opt_type type = ix86_opt_unknown;
4139       int mask = 0;
4140
4141       if (comma)
4142         {
4143           *comma = '\0';
4144           len = comma - next_optstr;
4145           next_optstr = comma + 1;
4146         }
4147       else
4148         {
4149           len = strlen (p);
4150           next_optstr = NULL;
4151         }
4152
4153       /* Recognize no-xxx.  */
4154       if (len > 3 && p[0] == 'n' && p[1] == 'o' && p[2] == '-')
4155         {
4156           opt_set_p = false;
4157           p += 3;
4158           len -= 3;
4159         }
4160       else
4161         opt_set_p = true;
4162
4163       /* Find the option.  */
4164       ch = *p;
4165       opt = N_OPTS;
4166       for (i = 0; i < ARRAY_SIZE (attrs); i++)
4167         {
4168           type = attrs[i].type;
4169           opt_len = attrs[i].len;
4170           if (ch == attrs[i].string[0]
4171               && ((type != ix86_opt_str && type != ix86_opt_enum)
4172                   ? len == opt_len
4173                   : len > opt_len)
4174               && memcmp (p, attrs[i].string, opt_len) == 0)
4175             {
4176               opt = attrs[i].opt;
4177               mask = attrs[i].mask;
4178               opt_string = attrs[i].string;
4179               break;
4180             }
4181         }
4182
4183       /* Process the option.  */
4184       if (opt == N_OPTS)
4185         {
4186           error ("attribute(target(\"%s\")) is unknown", orig_p);
4187           ret = false;
4188         }
4189
4190       else if (type == ix86_opt_isa)
4191         {
4192           struct cl_decoded_option decoded;
4193
4194           generate_option (opt, NULL, opt_set_p, CL_TARGET, &decoded);
4195           ix86_handle_option (&global_options, &global_options_set,
4196                               &decoded, input_location);
4197         }
4198
4199       else if (type == ix86_opt_yes || type == ix86_opt_no)
4200         {
4201           if (type == ix86_opt_no)
4202             opt_set_p = !opt_set_p;
4203
4204           if (opt_set_p)
4205             target_flags |= mask;
4206           else
4207             target_flags &= ~mask;
4208         }
4209
4210       else if (type == ix86_opt_str)
4211         {
4212           if (p_strings[opt])
4213             {
4214               error ("option(\"%s\") was already specified", opt_string);
4215               ret = false;
4216             }
4217           else
4218             p_strings[opt] = xstrdup (p + opt_len);
4219         }
4220
4221       else if (type == ix86_opt_enum)
4222         {
4223           bool arg_ok;
4224           int value;
4225
4226           arg_ok = opt_enum_arg_to_value (opt, p + opt_len, &value, CL_TARGET);
4227           if (arg_ok)
4228             set_option (&global_options, enum_opts_set, opt, value,
4229                         p + opt_len, DK_UNSPECIFIED, input_location,
4230                         global_dc);
4231           else
4232             {
4233               error ("attribute(target(\"%s\")) is unknown", orig_p);
4234               ret = false;
4235             }
4236         }
4237
4238       else
4239         gcc_unreachable ();
4240     }
4241
4242   return ret;
4243 }
4244
4245 /* Return a TARGET_OPTION_NODE tree of the target options listed or NULL.  */
4246
4247 tree
4248 ix86_valid_target_attribute_tree (tree args)
4249 {
4250   const char *orig_arch_string = ix86_arch_string;
4251   const char *orig_tune_string = ix86_tune_string;
4252   enum fpmath_unit orig_fpmath_set = global_options_set.x_ix86_fpmath;
4253   int orig_tune_defaulted = ix86_tune_defaulted;
4254   int orig_arch_specified = ix86_arch_specified;
4255   char *option_strings[IX86_FUNCTION_SPECIFIC_MAX] = { NULL, NULL };
4256   tree t = NULL_TREE;
4257   int i;
4258   struct cl_target_option *def
4259     = TREE_TARGET_OPTION (target_option_default_node);
4260   struct gcc_options enum_opts_set;
4261
4262   memset (&enum_opts_set, 0, sizeof (enum_opts_set));
4263
4264   /* Process each of the options on the chain.  */
4265   if (! ix86_valid_target_attribute_inner_p (args, option_strings,
4266                                              &enum_opts_set))
4267     return NULL_TREE;
4268
4269   /* If the changed options are different from the default, rerun
4270      ix86_option_override_internal, and then save the options away.
4271      The string options are are attribute options, and will be undone
4272      when we copy the save structure.  */
4273   if (ix86_isa_flags != def->x_ix86_isa_flags
4274       || target_flags != def->x_target_flags
4275       || option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
4276       || option_strings[IX86_FUNCTION_SPECIFIC_TUNE]
4277       || enum_opts_set.x_ix86_fpmath)
4278     {
4279       /* If we are using the default tune= or arch=, undo the string assigned,
4280          and use the default.  */
4281       if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH])
4282         ix86_arch_string = option_strings[IX86_FUNCTION_SPECIFIC_ARCH];
4283       else if (!orig_arch_specified)
4284         ix86_arch_string = NULL;
4285
4286       if (option_strings[IX86_FUNCTION_SPECIFIC_TUNE])
4287         ix86_tune_string = option_strings[IX86_FUNCTION_SPECIFIC_TUNE];
4288       else if (orig_tune_defaulted)
4289         ix86_tune_string = NULL;
4290
4291       /* If fpmath= is not set, and we now have sse2 on 32-bit, use it.  */
4292       if (enum_opts_set.x_ix86_fpmath)
4293         global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4294       else if (!TARGET_64BIT && TARGET_SSE)
4295         {
4296           ix86_fpmath = (enum fpmath_unit) (FPMATH_SSE | FPMATH_387);
4297           global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4298         }
4299
4300       /* Do any overrides, such as arch=xxx, or tune=xxx support.  */
4301       ix86_option_override_internal (false);
4302
4303       /* Add any builtin functions with the new isa if any.  */
4304       ix86_add_new_builtins (ix86_isa_flags);
4305
4306       /* Save the current options unless we are validating options for
4307          #pragma.  */
4308       t = build_target_option_node ();
4309
4310       ix86_arch_string = orig_arch_string;
4311       ix86_tune_string = orig_tune_string;
4312       global_options_set.x_ix86_fpmath = orig_fpmath_set;
4313
4314       /* Free up memory allocated to hold the strings */
4315       for (i = 0; i < IX86_FUNCTION_SPECIFIC_MAX; i++)
4316         free (option_strings[i]);
4317     }
4318
4319   return t;
4320 }
4321
4322 /* Hook to validate attribute((target("string"))).  */
4323
4324 static bool
4325 ix86_valid_target_attribute_p (tree fndecl,
4326                                tree ARG_UNUSED (name),
4327                                tree args,
4328                                int ARG_UNUSED (flags))
4329 {
4330   struct cl_target_option cur_target;
4331   bool ret = true;
4332   tree old_optimize = build_optimization_node ();
4333   tree new_target, new_optimize;
4334   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
4335
4336   /* If the function changed the optimization levels as well as setting target
4337      options, start with the optimizations specified.  */
4338   if (func_optimize && func_optimize != old_optimize)
4339     cl_optimization_restore (&global_options,
4340                              TREE_OPTIMIZATION (func_optimize));
4341
4342   /* The target attributes may also change some optimization flags, so update
4343      the optimization options if necessary.  */
4344   cl_target_option_save (&cur_target, &global_options);
4345   new_target = ix86_valid_target_attribute_tree (args);
4346   new_optimize = build_optimization_node ();
4347
4348   if (!new_target)
4349     ret = false;
4350
4351   else if (fndecl)
4352     {
4353       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
4354
4355       if (old_optimize != new_optimize)
4356         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
4357     }
4358
4359   cl_target_option_restore (&global_options, &cur_target);
4360
4361   if (old_optimize != new_optimize)
4362     cl_optimization_restore (&global_options,
4363                              TREE_OPTIMIZATION (old_optimize));
4364
4365   return ret;
4366 }
4367
4368 \f
4369 /* Hook to determine if one function can safely inline another.  */
4370
4371 static bool
4372 ix86_can_inline_p (tree caller, tree callee)
4373 {
4374   bool ret = false;
4375   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
4376   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
4377
4378   /* If callee has no option attributes, then it is ok to inline.  */
4379   if (!callee_tree)
4380     ret = true;
4381
4382   /* If caller has no option attributes, but callee does then it is not ok to
4383      inline.  */
4384   else if (!caller_tree)
4385     ret = false;
4386
4387   else
4388     {
4389       struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
4390       struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
4391
4392       /* Callee's isa options should a subset of the caller's, i.e. a SSE4 function
4393          can inline a SSE2 function but a SSE2 function can't inline a SSE4
4394          function.  */
4395       if ((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
4396           != callee_opts->x_ix86_isa_flags)
4397         ret = false;
4398
4399       /* See if we have the same non-isa options.  */
4400       else if (caller_opts->x_target_flags != callee_opts->x_target_flags)
4401         ret = false;
4402
4403       /* See if arch, tune, etc. are the same.  */
4404       else if (caller_opts->arch != callee_opts->arch)
4405         ret = false;
4406
4407       else if (caller_opts->tune != callee_opts->tune)
4408         ret = false;
4409
4410       else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath)
4411         ret = false;
4412
4413       else if (caller_opts->branch_cost != callee_opts->branch_cost)
4414         ret = false;
4415
4416       else
4417         ret = true;
4418     }
4419
4420   return ret;
4421 }
4422
4423 \f
4424 /* Remember the last target of ix86_set_current_function.  */
4425 static GTY(()) tree ix86_previous_fndecl;
4426
4427 /* Establish appropriate back-end context for processing the function
4428    FNDECL.  The argument might be NULL to indicate processing at top
4429    level, outside of any function scope.  */
4430 static void
4431 ix86_set_current_function (tree fndecl)
4432 {
4433   /* Only change the context if the function changes.  This hook is called
4434      several times in the course of compiling a function, and we don't want to
4435      slow things down too much or call target_reinit when it isn't safe.  */
4436   if (fndecl && fndecl != ix86_previous_fndecl)
4437     {
4438       tree old_tree = (ix86_previous_fndecl
4439                        ? DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl)
4440                        : NULL_TREE);
4441
4442       tree new_tree = (fndecl
4443                        ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl)
4444                        : NULL_TREE);
4445
4446       ix86_previous_fndecl = fndecl;
4447       if (old_tree == new_tree)
4448         ;
4449
4450       else if (new_tree)
4451         {
4452           cl_target_option_restore (&global_options,
4453                                     TREE_TARGET_OPTION (new_tree));
4454           target_reinit ();
4455         }
4456
4457       else if (old_tree)
4458         {
4459           struct cl_target_option *def
4460             = TREE_TARGET_OPTION (target_option_current_node);
4461
4462           cl_target_option_restore (&global_options, def);
4463           target_reinit ();
4464         }
4465     }
4466 }
4467
4468 \f
4469 /* Return true if this goes in large data/bss.  */
4470
4471 static bool
4472 ix86_in_large_data_p (tree exp)
4473 {
4474   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
4475     return false;
4476
4477   /* Functions are never large data.  */
4478   if (TREE_CODE (exp) == FUNCTION_DECL)
4479     return false;
4480
4481   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
4482     {
4483       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
4484       if (strcmp (section, ".ldata") == 0
4485           || strcmp (section, ".lbss") == 0)
4486         return true;
4487       return false;
4488     }
4489   else
4490     {
4491       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
4492
4493       /* If this is an incomplete type with size 0, then we can't put it
4494          in data because it might be too big when completed.  */
4495       if (!size || size > ix86_section_threshold)
4496         return true;
4497     }
4498
4499   return false;
4500 }
4501
4502 /* Switch to the appropriate section for output of DECL.
4503    DECL is either a `VAR_DECL' node or a constant of some sort.
4504    RELOC indicates whether forming the initial value of DECL requires
4505    link-time relocations.  */
4506
4507 static section * x86_64_elf_select_section (tree, int, unsigned HOST_WIDE_INT)
4508         ATTRIBUTE_UNUSED;
4509
4510 static section *
4511 x86_64_elf_select_section (tree decl, int reloc,
4512                            unsigned HOST_WIDE_INT align)
4513 {
4514   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4515       && ix86_in_large_data_p (decl))
4516     {
4517       const char *sname = NULL;
4518       unsigned int flags = SECTION_WRITE;
4519       switch (categorize_decl_for_section (decl, reloc))
4520         {
4521         case SECCAT_DATA:
4522           sname = ".ldata";
4523           break;
4524         case SECCAT_DATA_REL:
4525           sname = ".ldata.rel";
4526           break;
4527         case SECCAT_DATA_REL_LOCAL:
4528           sname = ".ldata.rel.local";
4529           break;
4530         case SECCAT_DATA_REL_RO:
4531           sname = ".ldata.rel.ro";
4532           break;
4533         case SECCAT_DATA_REL_RO_LOCAL:
4534           sname = ".ldata.rel.ro.local";
4535           break;
4536         case SECCAT_BSS:
4537           sname = ".lbss";
4538           flags |= SECTION_BSS;
4539           break;
4540         case SECCAT_RODATA:
4541         case SECCAT_RODATA_MERGE_STR:
4542         case SECCAT_RODATA_MERGE_STR_INIT:
4543         case SECCAT_RODATA_MERGE_CONST:
4544           sname = ".lrodata";
4545           flags = 0;
4546           break;
4547         case SECCAT_SRODATA:
4548         case SECCAT_SDATA:
4549         case SECCAT_SBSS:
4550           gcc_unreachable ();
4551         case SECCAT_TEXT:
4552         case SECCAT_TDATA:
4553         case SECCAT_TBSS:
4554           /* We don't split these for medium model.  Place them into
4555              default sections and hope for best.  */
4556           break;
4557         }
4558       if (sname)
4559         {
4560           /* We might get called with string constants, but get_named_section
4561              doesn't like them as they are not DECLs.  Also, we need to set
4562              flags in that case.  */
4563           if (!DECL_P (decl))
4564             return get_section (sname, flags, NULL);
4565           return get_named_section (decl, sname, reloc);
4566         }
4567     }
4568   return default_elf_select_section (decl, reloc, align);
4569 }
4570
4571 /* Build up a unique section name, expressed as a
4572    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
4573    RELOC indicates whether the initial value of EXP requires
4574    link-time relocations.  */
4575
4576 static void ATTRIBUTE_UNUSED
4577 x86_64_elf_unique_section (tree decl, int reloc)
4578 {
4579   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4580       && ix86_in_large_data_p (decl))
4581     {
4582       const char *prefix = NULL;
4583       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
4584       bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
4585
4586       switch (categorize_decl_for_section (decl, reloc))
4587         {
4588         case SECCAT_DATA:
4589         case SECCAT_DATA_REL:
4590         case SECCAT_DATA_REL_LOCAL:
4591         case SECCAT_DATA_REL_RO:
4592         case SECCAT_DATA_REL_RO_LOCAL:
4593           prefix = one_only ? ".ld" : ".ldata";
4594           break;
4595         case SECCAT_BSS:
4596           prefix = one_only ? ".lb" : ".lbss";
4597           break;
4598         case SECCAT_RODATA:
4599         case SECCAT_RODATA_MERGE_STR:
4600         case SECCAT_RODATA_MERGE_STR_INIT:
4601         case SECCAT_RODATA_MERGE_CONST:
4602           prefix = one_only ? ".lr" : ".lrodata";
4603           break;
4604         case SECCAT_SRODATA:
4605         case SECCAT_SDATA:
4606         case SECCAT_SBSS:
4607           gcc_unreachable ();
4608         case SECCAT_TEXT:
4609         case SECCAT_TDATA:
4610         case SECCAT_TBSS:
4611           /* We don't split these for medium model.  Place them into
4612              default sections and hope for best.  */
4613           break;
4614         }
4615       if (prefix)
4616         {
4617           const char *name, *linkonce;
4618           char *string;
4619
4620           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4621           name = targetm.strip_name_encoding (name);
4622
4623           /* If we're using one_only, then there needs to be a .gnu.linkonce
4624              prefix to the section name.  */
4625           linkonce = one_only ? ".gnu.linkonce" : "";
4626
4627           string = ACONCAT ((linkonce, prefix, ".", name, NULL));
4628
4629           DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
4630           return;
4631         }
4632     }
4633   default_unique_section (decl, reloc);
4634 }
4635
4636 #ifdef COMMON_ASM_OP
4637 /* This says how to output assembler code to declare an
4638    uninitialized external linkage data object.
4639
4640    For medium model x86-64 we need to use .largecomm opcode for
4641    large objects.  */
4642 void
4643 x86_elf_aligned_common (FILE *file,
4644                         const char *name, unsigned HOST_WIDE_INT size,
4645                         int align)
4646 {
4647   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4648       && size > (unsigned int)ix86_section_threshold)
4649     fputs (".largecomm\t", file);
4650   else
4651     fputs (COMMON_ASM_OP, file);
4652   assemble_name (file, name);
4653   fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
4654            size, align / BITS_PER_UNIT);
4655 }
4656 #endif
4657
4658 /* Utility function for targets to use in implementing
4659    ASM_OUTPUT_ALIGNED_BSS.  */
4660
4661 void
4662 x86_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
4663                         const char *name, unsigned HOST_WIDE_INT size,
4664                         int align)
4665 {
4666   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4667       && size > (unsigned int)ix86_section_threshold)
4668     switch_to_section (get_named_section (decl, ".lbss", 0));
4669   else
4670     switch_to_section (bss_section);
4671   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
4672 #ifdef ASM_DECLARE_OBJECT_NAME
4673   last_assemble_variable_decl = decl;
4674   ASM_DECLARE_OBJECT_NAME (file, name, decl);
4675 #else
4676   /* Standard thing is just output label for the object.  */
4677   ASM_OUTPUT_LABEL (file, name);
4678 #endif /* ASM_DECLARE_OBJECT_NAME */
4679   ASM_OUTPUT_SKIP (file, size ? size : 1);
4680 }
4681 \f
4682 /* Decide whether we must probe the stack before any space allocation
4683    on this target.  It's essentially TARGET_STACK_PROBE except when
4684    -fstack-check causes the stack to be already probed differently.  */
4685
4686 bool
4687 ix86_target_stack_probe (void)
4688 {
4689   /* Do not probe the stack twice if static stack checking is enabled.  */
4690   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
4691     return false;
4692
4693   return TARGET_STACK_PROBE;
4694 }
4695 \f
4696 /* Decide whether we can make a sibling call to a function.  DECL is the
4697    declaration of the function being targeted by the call and EXP is the
4698    CALL_EXPR representing the call.  */
4699
4700 static bool
4701 ix86_function_ok_for_sibcall (tree decl, tree exp)
4702 {
4703   tree type, decl_or_type;
4704   rtx a, b;
4705
4706   /* If we are generating position-independent code, we cannot sibcall
4707      optimize any indirect call, or a direct call to a global function,
4708      as the PLT requires %ebx be live. (Darwin does not have a PLT.)  */
4709   if (!TARGET_MACHO
4710       && !TARGET_64BIT
4711       && flag_pic
4712       && (!decl || !targetm.binds_local_p (decl)))
4713     return false;
4714
4715   /* If we need to align the outgoing stack, then sibcalling would
4716      unalign the stack, which may break the called function.  */
4717   if (ix86_minimum_incoming_stack_boundary (true)
4718       < PREFERRED_STACK_BOUNDARY)
4719     return false;
4720
4721   if (decl)
4722     {
4723       decl_or_type = decl;
4724       type = TREE_TYPE (decl);
4725     }
4726   else
4727     {
4728       /* We're looking at the CALL_EXPR, we need the type of the function.  */
4729       type = CALL_EXPR_FN (exp);                /* pointer expression */
4730       type = TREE_TYPE (type);                  /* pointer type */
4731       type = TREE_TYPE (type);                  /* function type */
4732       decl_or_type = type;
4733     }
4734
4735   /* Check that the return value locations are the same.  Like
4736      if we are returning floats on the 80387 register stack, we cannot
4737      make a sibcall from a function that doesn't return a float to a
4738      function that does or, conversely, from a function that does return
4739      a float to a function that doesn't; the necessary stack adjustment
4740      would not be executed.  This is also the place we notice
4741      differences in the return value ABI.  Note that it is ok for one
4742      of the functions to have void return type as long as the return
4743      value of the other is passed in a register.  */
4744   a = ix86_function_value (TREE_TYPE (exp), decl_or_type, false);
4745   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
4746                            cfun->decl, false);
4747   if (STACK_REG_P (a) || STACK_REG_P (b))
4748     {
4749       if (!rtx_equal_p (a, b))
4750         return false;
4751     }
4752   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
4753     {
4754       /* Disable sibcall if we need to generate vzeroupper after
4755          callee returns.  */
4756       if (TARGET_VZEROUPPER
4757           && cfun->machine->callee_return_avx256_p
4758           && !cfun->machine->caller_return_avx256_p)
4759         return false;
4760     }
4761   else if (!rtx_equal_p (a, b))
4762     return false;
4763
4764   if (TARGET_64BIT)
4765     {
4766       /* The SYSV ABI has more call-clobbered registers;
4767          disallow sibcalls from MS to SYSV.  */
4768       if (cfun->machine->call_abi == MS_ABI
4769           && ix86_function_type_abi (type) == SYSV_ABI)
4770         return false;
4771     }
4772   else
4773     {
4774       /* If this call is indirect, we'll need to be able to use a
4775          call-clobbered register for the address of the target function.
4776          Make sure that all such registers are not used for passing
4777          parameters.  Note that DLLIMPORT functions are indirect.  */
4778       if (!decl
4779           || (TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P (decl)))
4780         {
4781           if (ix86_function_regparm (type, NULL) >= 3)
4782             {
4783               /* ??? Need to count the actual number of registers to be used,
4784                  not the possible number of registers.  Fix later.  */
4785               return false;
4786             }
4787         }
4788     }
4789
4790   /* Otherwise okay.  That also includes certain types of indirect calls.  */
4791   return true;
4792 }
4793
4794 /* Handle "cdecl", "stdcall", "fastcall", "regparm", "thiscall",
4795    and "sseregparm" calling convention attributes;
4796    arguments as in struct attribute_spec.handler.  */
4797
4798 static tree
4799 ix86_handle_cconv_attribute (tree *node, tree name,
4800                                    tree args,
4801                                    int flags ATTRIBUTE_UNUSED,
4802                                    bool *no_add_attrs)
4803 {
4804   if (TREE_CODE (*node) != FUNCTION_TYPE
4805       && TREE_CODE (*node) != METHOD_TYPE
4806       && TREE_CODE (*node) != FIELD_DECL
4807       && TREE_CODE (*node) != TYPE_DECL)
4808     {
4809       warning (OPT_Wattributes, "%qE attribute only applies to functions",
4810                name);
4811       *no_add_attrs = true;
4812       return NULL_TREE;
4813     }
4814
4815   /* Can combine regparm with all attributes but fastcall, and thiscall.  */
4816   if (is_attribute_p ("regparm", name))
4817     {
4818       tree cst;
4819
4820       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4821         {
4822           error ("fastcall and regparm attributes are not compatible");
4823         }
4824
4825       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4826         {
4827           error ("regparam and thiscall attributes are not compatible");
4828         }
4829
4830       cst = TREE_VALUE (args);
4831       if (TREE_CODE (cst) != INTEGER_CST)
4832         {
4833           warning (OPT_Wattributes,
4834                    "%qE attribute requires an integer constant argument",
4835                    name);
4836           *no_add_attrs = true;
4837         }
4838       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
4839         {
4840           warning (OPT_Wattributes, "argument to %qE attribute larger than %d",
4841                    name, REGPARM_MAX);
4842           *no_add_attrs = true;
4843         }
4844
4845       return NULL_TREE;
4846     }
4847
4848   if (TARGET_64BIT)
4849     {
4850       /* Do not warn when emulating the MS ABI.  */
4851       if ((TREE_CODE (*node) != FUNCTION_TYPE
4852            && TREE_CODE (*node) != METHOD_TYPE)
4853           || ix86_function_type_abi (*node) != MS_ABI)
4854         warning (OPT_Wattributes, "%qE attribute ignored",
4855                  name);
4856       *no_add_attrs = true;
4857       return NULL_TREE;
4858     }
4859
4860   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
4861   if (is_attribute_p ("fastcall", name))
4862     {
4863       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4864         {
4865           error ("fastcall and cdecl attributes are not compatible");
4866         }
4867       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4868         {
4869           error ("fastcall and stdcall attributes are not compatible");
4870         }
4871       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
4872         {
4873           error ("fastcall and regparm attributes are not compatible");
4874         }
4875       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4876         {
4877           error ("fastcall and thiscall attributes are not compatible");
4878         }
4879     }
4880
4881   /* Can combine stdcall with fastcall (redundant), regparm and
4882      sseregparm.  */
4883   else if (is_attribute_p ("stdcall", name))
4884     {
4885       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4886         {
4887           error ("stdcall and cdecl attributes are not compatible");
4888         }
4889       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4890         {
4891           error ("stdcall and fastcall attributes are not compatible");
4892         }
4893       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4894         {
4895           error ("stdcall and thiscall attributes are not compatible");
4896         }
4897     }
4898
4899   /* Can combine cdecl with regparm and sseregparm.  */
4900   else if (is_attribute_p ("cdecl", name))
4901     {
4902       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4903         {
4904           error ("stdcall and cdecl attributes are not compatible");
4905         }
4906       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4907         {
4908           error ("fastcall and cdecl attributes are not compatible");
4909         }
4910       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4911         {
4912           error ("cdecl and thiscall attributes are not compatible");
4913         }
4914     }
4915   else if (is_attribute_p ("thiscall", name))
4916     {
4917       if (TREE_CODE (*node) != METHOD_TYPE && pedantic)
4918         warning (OPT_Wattributes, "%qE attribute is used for none class-method",
4919                  name);
4920       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4921         {
4922           error ("stdcall and thiscall attributes are not compatible");
4923         }
4924       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4925         {
4926           error ("fastcall and thiscall attributes are not compatible");
4927         }
4928       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4929         {
4930           error ("cdecl and thiscall attributes are not compatible");
4931         }
4932     }
4933
4934   /* Can combine sseregparm with all attributes.  */
4935
4936   return NULL_TREE;
4937 }
4938
4939 /* This function determines from TYPE the calling-convention.  */
4940
4941 unsigned int
4942 ix86_get_callcvt (const_tree type)
4943 {
4944   unsigned int ret = 0;
4945   bool is_stdarg;
4946   tree attrs;
4947
4948   if (TARGET_64BIT)
4949     return IX86_CALLCVT_CDECL;
4950
4951   attrs = TYPE_ATTRIBUTES (type);
4952   if (attrs != NULL_TREE)
4953     {
4954       if (lookup_attribute ("cdecl", attrs))
4955         ret |= IX86_CALLCVT_CDECL;
4956       else if (lookup_attribute ("stdcall", attrs))
4957         ret |= IX86_CALLCVT_STDCALL;
4958       else if (lookup_attribute ("fastcall", attrs))
4959         ret |= IX86_CALLCVT_FASTCALL;
4960       else if (lookup_attribute ("thiscall", attrs))
4961         ret |= IX86_CALLCVT_THISCALL;
4962
4963       /* Regparam isn't allowed for thiscall and fastcall.  */
4964       if ((ret & (IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL)) == 0)
4965         {
4966           if (lookup_attribute ("regparm", attrs))
4967             ret |= IX86_CALLCVT_REGPARM;
4968           if (lookup_attribute ("sseregparm", attrs))
4969             ret |= IX86_CALLCVT_SSEREGPARM;
4970         }
4971
4972       if (IX86_BASE_CALLCVT(ret) != 0)
4973         return ret;
4974     }
4975
4976   is_stdarg = stdarg_p (type);
4977   if (TARGET_RTD && !is_stdarg)
4978     return IX86_CALLCVT_STDCALL | ret;
4979
4980   if (ret != 0
4981       || is_stdarg
4982       || TREE_CODE (type) != METHOD_TYPE
4983       || ix86_function_type_abi (type) != MS_ABI)
4984     return IX86_CALLCVT_CDECL | ret;
4985
4986   return IX86_CALLCVT_THISCALL;
4987 }
4988
4989 /* Return 0 if the attributes for two types are incompatible, 1 if they
4990    are compatible, and 2 if they are nearly compatible (which causes a
4991    warning to be generated).  */
4992
4993 static int
4994 ix86_comp_type_attributes (const_tree type1, const_tree type2)
4995 {
4996   unsigned int ccvt1, ccvt2;
4997
4998   if (TREE_CODE (type1) != FUNCTION_TYPE
4999       && TREE_CODE (type1) != METHOD_TYPE)
5000     return 1;
5001
5002   ccvt1 = ix86_get_callcvt (type1);
5003   ccvt2 = ix86_get_callcvt (type2);
5004   if (ccvt1 != ccvt2)
5005     return 0;
5006   if (ix86_function_regparm (type1, NULL)
5007       != ix86_function_regparm (type2, NULL))
5008     return 0;
5009
5010   return 1;
5011 }
5012 \f
5013 /* Return the regparm value for a function with the indicated TYPE and DECL.
5014    DECL may be NULL when calling function indirectly
5015    or considering a libcall.  */
5016
5017 static int
5018 ix86_function_regparm (const_tree type, const_tree decl)
5019 {
5020   tree attr;
5021   int regparm;
5022   unsigned int ccvt;
5023
5024   if (TARGET_64BIT)
5025     return (ix86_function_type_abi (type) == SYSV_ABI
5026             ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX);
5027   ccvt = ix86_get_callcvt (type);
5028   regparm = ix86_regparm;
5029
5030   if ((ccvt & IX86_CALLCVT_REGPARM) != 0)
5031     {
5032       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
5033       if (attr)
5034         {
5035           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
5036           return regparm;
5037         }
5038     }
5039   else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5040     return 2;
5041   else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5042     return 1;
5043
5044   /* Use register calling convention for local functions when possible.  */
5045   if (decl
5046       && TREE_CODE (decl) == FUNCTION_DECL
5047       && optimize
5048       && !(profile_flag && !flag_fentry))
5049     {
5050       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5051       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE (decl));
5052       if (i && i->local && i->can_change_signature)
5053         {
5054           int local_regparm, globals = 0, regno;
5055
5056           /* Make sure no regparm register is taken by a
5057              fixed register variable.  */
5058           for (local_regparm = 0; local_regparm < REGPARM_MAX; local_regparm++)
5059             if (fixed_regs[local_regparm])
5060               break;
5061
5062           /* We don't want to use regparm(3) for nested functions as
5063              these use a static chain pointer in the third argument.  */
5064           if (local_regparm == 3 && DECL_STATIC_CHAIN (decl))
5065             local_regparm = 2;
5066
5067           /* In 32-bit mode save a register for the split stack.  */
5068           if (!TARGET_64BIT && local_regparm == 3 && flag_split_stack)
5069             local_regparm = 2;
5070
5071           /* Each fixed register usage increases register pressure,
5072              so less registers should be used for argument passing.
5073              This functionality can be overriden by an explicit
5074              regparm value.  */
5075           for (regno = 0; regno <= DI_REG; regno++)
5076             if (fixed_regs[regno])
5077               globals++;
5078
5079           local_regparm
5080             = globals < local_regparm ? local_regparm - globals : 0;
5081
5082           if (local_regparm > regparm)
5083             regparm = local_regparm;
5084         }
5085     }
5086
5087   return regparm;
5088 }
5089
5090 /* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
5091    DFmode (2) arguments in SSE registers for a function with the
5092    indicated TYPE and DECL.  DECL may be NULL when calling function
5093    indirectly or considering a libcall.  Otherwise return 0.  */
5094
5095 static int
5096 ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
5097 {
5098   gcc_assert (!TARGET_64BIT);
5099
5100   /* Use SSE registers to pass SFmode and DFmode arguments if requested
5101      by the sseregparm attribute.  */
5102   if (TARGET_SSEREGPARM
5103       || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
5104     {
5105       if (!TARGET_SSE)
5106         {
5107           if (warn)
5108             {
5109               if (decl)
5110                 error ("calling %qD with attribute sseregparm without "
5111                        "SSE/SSE2 enabled", decl);
5112               else
5113                 error ("calling %qT with attribute sseregparm without "
5114                        "SSE/SSE2 enabled", type);
5115             }
5116           return 0;
5117         }
5118
5119       return 2;
5120     }
5121
5122   /* For local functions, pass up to SSE_REGPARM_MAX SFmode
5123      (and DFmode for SSE2) arguments in SSE registers.  */
5124   if (decl && TARGET_SSE_MATH && optimize
5125       && !(profile_flag && !flag_fentry))
5126     {
5127       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5128       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE(decl));
5129       if (i && i->local && i->can_change_signature)
5130         return TARGET_SSE2 ? 2 : 1;
5131     }
5132
5133   return 0;
5134 }
5135
5136 /* Return true if EAX is live at the start of the function.  Used by
5137    ix86_expand_prologue to determine if we need special help before
5138    calling allocate_stack_worker.  */
5139
5140 static bool
5141 ix86_eax_live_at_start_p (void)
5142 {
5143   /* Cheat.  Don't bother working forward from ix86_function_regparm
5144      to the function type to whether an actual argument is located in
5145      eax.  Instead just look at cfg info, which is still close enough
5146      to correct at this point.  This gives false positives for broken
5147      functions that might use uninitialized data that happens to be
5148      allocated in eax, but who cares?  */
5149   return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), 0);
5150 }
5151
5152 static bool
5153 ix86_keep_aggregate_return_pointer (tree fntype)
5154 {
5155   tree attr;
5156
5157   if (!TARGET_64BIT)
5158     {
5159       attr = lookup_attribute ("callee_pop_aggregate_return",
5160                                TYPE_ATTRIBUTES (fntype));
5161       if (attr)
5162         return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr))) == 0);
5163
5164       /* For 32-bit MS-ABI the default is to keep aggregate
5165          return pointer.  */
5166       if (ix86_function_type_abi (fntype) == MS_ABI)
5167         return true;
5168     }
5169   return KEEP_AGGREGATE_RETURN_POINTER != 0;
5170 }
5171
5172 /* Value is the number of bytes of arguments automatically
5173    popped when returning from a subroutine call.
5174    FUNDECL is the declaration node of the function (as a tree),
5175    FUNTYPE is the data type of the function (as a tree),
5176    or for a library call it is an identifier node for the subroutine name.
5177    SIZE is the number of bytes of arguments passed on the stack.
5178
5179    On the 80386, the RTD insn may be used to pop them if the number
5180      of args is fixed, but if the number is variable then the caller
5181      must pop them all.  RTD can't be used for library calls now
5182      because the library is compiled with the Unix compiler.
5183    Use of RTD is a selectable option, since it is incompatible with
5184    standard Unix calling sequences.  If the option is not selected,
5185    the caller must always pop the args.
5186
5187    The attribute stdcall is equivalent to RTD on a per module basis.  */
5188
5189 static int
5190 ix86_return_pops_args (tree fundecl, tree funtype, int size)
5191 {
5192   unsigned int ccvt;
5193
5194   /* None of the 64-bit ABIs pop arguments.  */
5195   if (TARGET_64BIT)
5196     return 0;
5197
5198   ccvt = ix86_get_callcvt (funtype);
5199
5200   if ((ccvt & (IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL
5201                | IX86_CALLCVT_THISCALL)) != 0
5202       && ! stdarg_p (funtype))
5203     return size;
5204
5205   /* Lose any fake structure return argument if it is passed on the stack.  */
5206   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
5207       && !ix86_keep_aggregate_return_pointer (funtype))
5208     {
5209       int nregs = ix86_function_regparm (funtype, fundecl);
5210       if (nregs == 0)
5211         return GET_MODE_SIZE (Pmode);
5212     }
5213
5214   return 0;
5215 }
5216 \f
5217 /* Argument support functions.  */
5218
5219 /* Return true when register may be used to pass function parameters.  */
5220 bool
5221 ix86_function_arg_regno_p (int regno)
5222 {
5223   int i;
5224   const int *parm_regs;
5225
5226   if (!TARGET_64BIT)
5227     {
5228       if (TARGET_MACHO)
5229         return (regno < REGPARM_MAX
5230                 || (TARGET_SSE && SSE_REGNO_P (regno) && !fixed_regs[regno]));
5231       else
5232         return (regno < REGPARM_MAX
5233                 || (TARGET_MMX && MMX_REGNO_P (regno)
5234                     && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
5235                 || (TARGET_SSE && SSE_REGNO_P (regno)
5236                     && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
5237     }
5238
5239   if (TARGET_MACHO)
5240     {
5241       if (SSE_REGNO_P (regno) && TARGET_SSE)
5242         return true;
5243     }
5244   else
5245     {
5246       if (TARGET_SSE && SSE_REGNO_P (regno)
5247           && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
5248         return true;
5249     }
5250
5251   /* TODO: The function should depend on current function ABI but
5252      builtins.c would need updating then. Therefore we use the
5253      default ABI.  */
5254
5255   /* RAX is used as hidden argument to va_arg functions.  */
5256   if (ix86_abi == SYSV_ABI && regno == AX_REG)
5257     return true;
5258
5259   if (ix86_abi == MS_ABI)
5260     parm_regs = x86_64_ms_abi_int_parameter_registers;
5261   else
5262     parm_regs = x86_64_int_parameter_registers;
5263   for (i = 0; i < (ix86_abi == MS_ABI
5264                    ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX); i++)
5265     if (regno == parm_regs[i])
5266       return true;
5267   return false;
5268 }
5269
5270 /* Return if we do not know how to pass TYPE solely in registers.  */
5271
5272 static bool
5273 ix86_must_pass_in_stack (enum machine_mode mode, const_tree type)
5274 {
5275   if (must_pass_in_stack_var_size_or_pad (mode, type))
5276     return true;
5277
5278   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
5279      The layout_type routine is crafty and tries to trick us into passing
5280      currently unsupported vector types on the stack by using TImode.  */
5281   return (!TARGET_64BIT && mode == TImode
5282           && type && TREE_CODE (type) != VECTOR_TYPE);
5283 }
5284
5285 /* It returns the size, in bytes, of the area reserved for arguments passed
5286    in registers for the function represented by fndecl dependent to the used
5287    abi format.  */
5288 int
5289 ix86_reg_parm_stack_space (const_tree fndecl)
5290 {
5291   enum calling_abi call_abi = SYSV_ABI;
5292   if (fndecl != NULL_TREE && TREE_CODE (fndecl) == FUNCTION_DECL)
5293     call_abi = ix86_function_abi (fndecl);
5294   else
5295     call_abi = ix86_function_type_abi (fndecl);
5296   if (TARGET_64BIT && call_abi == MS_ABI)
5297     return 32;
5298   return 0;
5299 }
5300
5301 /* Returns value SYSV_ABI, MS_ABI dependent on fntype, specifying the
5302    call abi used.  */
5303 enum calling_abi
5304 ix86_function_type_abi (const_tree fntype)
5305 {
5306   if (fntype != NULL_TREE && TYPE_ATTRIBUTES (fntype) != NULL_TREE)
5307     {
5308       enum calling_abi abi = ix86_abi;
5309       if (abi == SYSV_ABI)
5310         {
5311           if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)))
5312             abi = MS_ABI;
5313         }
5314       else if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)))
5315         abi = SYSV_ABI;
5316       return abi;
5317     }
5318   return ix86_abi;
5319 }
5320
5321 static bool
5322 ix86_function_ms_hook_prologue (const_tree fn)
5323 {
5324   if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)))
5325     {
5326       if (decl_function_context (fn) != NULL_TREE)
5327         error_at (DECL_SOURCE_LOCATION (fn),
5328                   "ms_hook_prologue is not compatible with nested function");
5329       else
5330         return true;
5331     }
5332   return false;
5333 }
5334
5335 static enum calling_abi
5336 ix86_function_abi (const_tree fndecl)
5337 {
5338   if (! fndecl)
5339     return ix86_abi;
5340   return ix86_function_type_abi (TREE_TYPE (fndecl));
5341 }
5342
5343 /* Returns value SYSV_ABI, MS_ABI dependent on cfun, specifying the
5344    call abi used.  */
5345 enum calling_abi
5346 ix86_cfun_abi (void)
5347 {
5348   if (! cfun)
5349     return ix86_abi;
5350   return cfun->machine->call_abi;
5351 }
5352
5353 /* Write the extra assembler code needed to declare a function properly.  */
5354
5355 void
5356 ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
5357                                 tree decl)
5358 {
5359   bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
5360
5361   if (is_ms_hook)
5362     {
5363       int i, filler_count = (TARGET_64BIT ? 32 : 16);
5364       unsigned int filler_cc = 0xcccccccc;
5365
5366       for (i = 0; i < filler_count; i += 4)
5367         fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
5368     }
5369
5370 #ifdef SUBTARGET_ASM_UNWIND_INIT
5371   SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
5372 #endif
5373
5374   ASM_OUTPUT_LABEL (asm_out_file, fname);
5375
5376   /* Output magic byte marker, if hot-patch attribute is set.  */
5377   if (is_ms_hook)
5378     {
5379       if (TARGET_64BIT)
5380         {
5381           /* leaq [%rsp + 0], %rsp  */
5382           asm_fprintf (asm_out_file, ASM_BYTE
5383                        "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n");
5384         }
5385       else
5386         {
5387           /* movl.s %edi, %edi
5388              push   %ebp
5389              movl.s %esp, %ebp */
5390           asm_fprintf (asm_out_file, ASM_BYTE
5391                        "0x8b, 0xff, 0x55, 0x8b, 0xec\n");
5392         }
5393     }
5394 }
5395
5396 /* regclass.c  */
5397 extern void init_regs (void);
5398
5399 /* Implementation of call abi switching target hook. Specific to FNDECL
5400    the specific call register sets are set.  See also
5401    ix86_conditional_register_usage for more details.  */
5402 void
5403 ix86_call_abi_override (const_tree fndecl)
5404 {
5405   if (fndecl == NULL_TREE)
5406     cfun->machine->call_abi = ix86_abi;
5407   else
5408     cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
5409 }
5410
5411 /* 64-bit MS and SYSV ABI have different set of call used registers.  Avoid
5412    expensive re-initialization of init_regs each time we switch function context
5413    since this is needed only during RTL expansion.  */
5414 static void
5415 ix86_maybe_switch_abi (void)
5416 {
5417   if (TARGET_64BIT &&
5418       call_used_regs[SI_REG] == (cfun->machine->call_abi == MS_ABI))
5419     reinit_regs ();
5420 }
5421
5422 /* Initialize a variable CUM of type CUMULATIVE_ARGS
5423    for a call to a function whose data type is FNTYPE.
5424    For a library call, FNTYPE is 0.  */
5425
5426 void
5427 init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
5428                       tree fntype,      /* tree ptr for function decl */
5429                       rtx libname,      /* SYMBOL_REF of library name or 0 */
5430                       tree fndecl,
5431                       int caller)
5432 {
5433   struct cgraph_local_info *i;
5434   tree fnret_type;
5435
5436   memset (cum, 0, sizeof (*cum));
5437
5438   /* Initialize for the current callee.  */
5439   if (caller)
5440     {
5441       cfun->machine->callee_pass_avx256_p = false;
5442       cfun->machine->callee_return_avx256_p = false;
5443     }
5444
5445   if (fndecl)
5446     {
5447       i = cgraph_local_info (fndecl);
5448       cum->call_abi = ix86_function_abi (fndecl);
5449       fnret_type = TREE_TYPE (TREE_TYPE (fndecl));
5450     }
5451   else
5452     {
5453       i = NULL;
5454       cum->call_abi = ix86_function_type_abi (fntype);
5455       if (fntype)
5456         fnret_type = TREE_TYPE (fntype);
5457       else
5458         fnret_type = NULL;
5459     }
5460
5461   if (TARGET_VZEROUPPER && fnret_type)
5462     {
5463       rtx fnret_value = ix86_function_value (fnret_type, fntype,
5464                                              false);
5465       if (function_pass_avx256_p (fnret_value))
5466         {
5467           /* The return value of this function uses 256bit AVX modes.  */
5468           if (caller)
5469             cfun->machine->callee_return_avx256_p = true;
5470           else
5471             cfun->machine->caller_return_avx256_p = true;
5472         }
5473     }
5474
5475   cum->caller = caller;
5476
5477   /* Set up the number of registers to use for passing arguments.  */
5478
5479   if (TARGET_64BIT && cum->call_abi == MS_ABI && !ACCUMULATE_OUTGOING_ARGS)
5480     sorry ("ms_abi attribute requires -maccumulate-outgoing-args "
5481            "or subtarget optimization implying it");
5482   cum->nregs = ix86_regparm;
5483   if (TARGET_64BIT)
5484     {
5485       cum->nregs = (cum->call_abi == SYSV_ABI
5486                    ? X86_64_REGPARM_MAX
5487                    : X86_64_MS_REGPARM_MAX);
5488     }
5489   if (TARGET_SSE)
5490     {
5491       cum->sse_nregs = SSE_REGPARM_MAX;
5492       if (TARGET_64BIT)
5493         {
5494           cum->sse_nregs = (cum->call_abi == SYSV_ABI
5495                            ? X86_64_SSE_REGPARM_MAX
5496                            : X86_64_MS_SSE_REGPARM_MAX);
5497         }
5498     }
5499   if (TARGET_MMX)
5500     cum->mmx_nregs = MMX_REGPARM_MAX;
5501   cum->warn_avx = true;
5502   cum->warn_sse = true;
5503   cum->warn_mmx = true;
5504
5505   /* Because type might mismatch in between caller and callee, we need to
5506      use actual type of function for local calls.
5507      FIXME: cgraph_analyze can be told to actually record if function uses
5508      va_start so for local functions maybe_vaarg can be made aggressive
5509      helping K&R code.
5510      FIXME: once typesytem is fixed, we won't need this code anymore.  */
5511   if (i && i->local && i->can_change_signature)
5512     fntype = TREE_TYPE (fndecl);
5513   cum->maybe_vaarg = (fntype
5514                       ? (!prototype_p (fntype) || stdarg_p (fntype))
5515                       : !libname);
5516
5517   if (!TARGET_64BIT)
5518     {
5519       /* If there are variable arguments, then we won't pass anything
5520          in registers in 32-bit mode. */
5521       if (stdarg_p (fntype))
5522         {
5523           cum->nregs = 0;
5524           cum->sse_nregs = 0;
5525           cum->mmx_nregs = 0;
5526           cum->warn_avx = 0;
5527           cum->warn_sse = 0;
5528           cum->warn_mmx = 0;
5529           return;
5530         }
5531
5532       /* Use ecx and edx registers if function has fastcall attribute,
5533          else look for regparm information.  */
5534       if (fntype)
5535         {
5536           unsigned int ccvt = ix86_get_callcvt (fntype);
5537           if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5538             {
5539               cum->nregs = 1;
5540               cum->fastcall = 1; /* Same first register as in fastcall.  */
5541             }
5542           else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5543             {
5544               cum->nregs = 2;
5545               cum->fastcall = 1;
5546             }
5547           else
5548             cum->nregs = ix86_function_regparm (fntype, fndecl);
5549         }
5550
5551       /* Set up the number of SSE registers used for passing SFmode
5552          and DFmode arguments.  Warn for mismatching ABI.  */
5553       cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
5554     }
5555 }
5556
5557 /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
5558    But in the case of vector types, it is some vector mode.
5559
5560    When we have only some of our vector isa extensions enabled, then there
5561    are some modes for which vector_mode_supported_p is false.  For these
5562    modes, the generic vector support in gcc will choose some non-vector mode
5563    in order to implement the type.  By computing the natural mode, we'll
5564    select the proper ABI location for the operand and not depend on whatever
5565    the middle-end decides to do with these vector types.
5566
5567    The midde-end can't deal with the vector types > 16 bytes.  In this
5568    case, we return the original mode and warn ABI change if CUM isn't
5569    NULL.  */
5570
5571 static enum machine_mode
5572 type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum)
5573 {
5574   enum machine_mode mode = TYPE_MODE (type);
5575
5576   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
5577     {
5578       HOST_WIDE_INT size = int_size_in_bytes (type);
5579       if ((size == 8 || size == 16 || size == 32)
5580           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
5581           && TYPE_VECTOR_SUBPARTS (type) > 1)
5582         {
5583           enum machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
5584
5585           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5586             mode = MIN_MODE_VECTOR_FLOAT;
5587           else
5588             mode = MIN_MODE_VECTOR_INT;
5589
5590           /* Get the mode which has this inner mode and number of units.  */
5591           for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
5592             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
5593                 && GET_MODE_INNER (mode) == innermode)
5594               {
5595                 if (size == 32 && !TARGET_AVX)
5596                   {
5597                     static bool warnedavx;
5598
5599                     if (cum
5600                         && !warnedavx
5601                         && cum->warn_avx)
5602                       {
5603                         warnedavx = true;
5604                         warning (0, "AVX vector argument without AVX "
5605                                  "enabled changes the ABI");
5606                       }
5607                     return TYPE_MODE (type);
5608                   }
5609                 else
5610                   return mode;
5611               }
5612
5613           gcc_unreachable ();
5614         }
5615     }
5616
5617   return mode;
5618 }
5619
5620 /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
5621    this may not agree with the mode that the type system has chosen for the
5622    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
5623    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
5624
5625 static rtx
5626 gen_reg_or_parallel (enum machine_mode mode, enum machine_mode orig_mode,
5627                      unsigned int regno)
5628 {
5629   rtx tmp;
5630
5631   if (orig_mode != BLKmode)
5632     tmp = gen_rtx_REG (orig_mode, regno);
5633   else
5634     {
5635       tmp = gen_rtx_REG (mode, regno);
5636       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
5637       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
5638     }
5639
5640   return tmp;
5641 }
5642
5643 /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
5644    of this code is to classify each 8bytes of incoming argument by the register
5645    class and assign registers accordingly.  */
5646
5647 /* Return the union class of CLASS1 and CLASS2.
5648    See the x86-64 PS ABI for details.  */
5649
5650 static enum x86_64_reg_class
5651 merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
5652 {
5653   /* Rule #1: If both classes are equal, this is the resulting class.  */
5654   if (class1 == class2)
5655     return class1;
5656
5657   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
5658      the other class.  */
5659   if (class1 == X86_64_NO_CLASS)
5660     return class2;
5661   if (class2 == X86_64_NO_CLASS)
5662     return class1;
5663
5664   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
5665   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
5666     return X86_64_MEMORY_CLASS;
5667
5668   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
5669   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
5670       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
5671     return X86_64_INTEGERSI_CLASS;
5672   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
5673       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
5674     return X86_64_INTEGER_CLASS;
5675
5676   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
5677      MEMORY is used.  */
5678   if (class1 == X86_64_X87_CLASS
5679       || class1 == X86_64_X87UP_CLASS
5680       || class1 == X86_64_COMPLEX_X87_CLASS
5681       || class2 == X86_64_X87_CLASS
5682       || class2 == X86_64_X87UP_CLASS
5683       || class2 == X86_64_COMPLEX_X87_CLASS)
5684     return X86_64_MEMORY_CLASS;
5685
5686   /* Rule #6: Otherwise class SSE is used.  */
5687   return X86_64_SSE_CLASS;
5688 }
5689
5690 /* Classify the argument of type TYPE and mode MODE.
5691    CLASSES will be filled by the register class used to pass each word
5692    of the operand.  The number of words is returned.  In case the parameter
5693    should be passed in memory, 0 is returned. As a special case for zero
5694    sized containers, classes[0] will be NO_CLASS and 1 is returned.
5695
5696    BIT_OFFSET is used internally for handling records and specifies offset
5697    of the offset in bits modulo 256 to avoid overflow cases.
5698
5699    See the x86-64 PS ABI for details.
5700 */
5701
5702 static int
5703 classify_argument (enum machine_mode mode, const_tree type,
5704                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
5705 {
5706   HOST_WIDE_INT bytes =
5707     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
5708   int words = (bytes + (bit_offset % 64) / 8 + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5709
5710   /* Variable sized entities are always passed/returned in memory.  */
5711   if (bytes < 0)
5712     return 0;
5713
5714   if (mode != VOIDmode
5715       && targetm.calls.must_pass_in_stack (mode, type))
5716     return 0;
5717
5718   if (type && AGGREGATE_TYPE_P (type))
5719     {
5720       int i;
5721       tree field;
5722       enum x86_64_reg_class subclasses[MAX_CLASSES];
5723
5724       /* On x86-64 we pass structures larger than 32 bytes on the stack.  */
5725       if (bytes > 32)
5726         return 0;
5727
5728       for (i = 0; i < words; i++)
5729         classes[i] = X86_64_NO_CLASS;
5730
5731       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
5732          signalize memory class, so handle it as special case.  */
5733       if (!words)
5734         {
5735           classes[0] = X86_64_NO_CLASS;
5736           return 1;
5737         }
5738
5739       /* Classify each field of record and merge classes.  */
5740       switch (TREE_CODE (type))
5741         {
5742         case RECORD_TYPE:
5743           /* And now merge the fields of structure.  */
5744           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5745             {
5746               if (TREE_CODE (field) == FIELD_DECL)
5747                 {
5748                   int num;
5749
5750                   if (TREE_TYPE (field) == error_mark_node)
5751                     continue;
5752
5753                   /* Bitfields are always classified as integer.  Handle them
5754                      early, since later code would consider them to be
5755                      misaligned integers.  */
5756                   if (DECL_BIT_FIELD (field))
5757                     {
5758                       for (i = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5759                            i < ((int_bit_position (field) + (bit_offset % 64))
5760                                 + tree_low_cst (DECL_SIZE (field), 0)
5761                                 + 63) / 8 / 8; i++)
5762                         classes[i] =
5763                           merge_classes (X86_64_INTEGER_CLASS,
5764                                          classes[i]);
5765                     }
5766                   else
5767                     {
5768                       int pos;
5769
5770                       type = TREE_TYPE (field);
5771
5772                       /* Flexible array member is ignored.  */
5773                       if (TYPE_MODE (type) == BLKmode
5774                           && TREE_CODE (type) == ARRAY_TYPE
5775                           && TYPE_SIZE (type) == NULL_TREE
5776                           && TYPE_DOMAIN (type) != NULL_TREE
5777                           && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))
5778                               == NULL_TREE))
5779                         {
5780                           static bool warned;
5781
5782                           if (!warned && warn_psabi)
5783                             {
5784                               warned = true;
5785                               inform (input_location,
5786                                       "the ABI of passing struct with"
5787                                       " a flexible array member has"
5788                                       " changed in GCC 4.4");
5789                             }
5790                           continue;
5791                         }
5792                       num = classify_argument (TYPE_MODE (type), type,
5793                                                subclasses,
5794                                                (int_bit_position (field)
5795                                                 + bit_offset) % 256);
5796                       if (!num)
5797                         return 0;
5798                       pos = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5799                       for (i = 0; i < num && (i + pos) < words; i++)
5800                         classes[i + pos] =
5801                           merge_classes (subclasses[i], classes[i + pos]);
5802                     }
5803                 }
5804             }
5805           break;
5806
5807         case ARRAY_TYPE:
5808           /* Arrays are handled as small records.  */
5809           {
5810             int num;
5811             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
5812                                      TREE_TYPE (type), subclasses, bit_offset);
5813             if (!num)
5814               return 0;
5815
5816             /* The partial classes are now full classes.  */
5817             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
5818               subclasses[0] = X86_64_SSE_CLASS;
5819             if (subclasses[0] == X86_64_INTEGERSI_CLASS
5820                 && !((bit_offset % 64) == 0 && bytes == 4))
5821               subclasses[0] = X86_64_INTEGER_CLASS;
5822
5823             for (i = 0; i < words; i++)
5824               classes[i] = subclasses[i % num];
5825
5826             break;
5827           }
5828         case UNION_TYPE:
5829         case QUAL_UNION_TYPE:
5830           /* Unions are similar to RECORD_TYPE but offset is always 0.
5831              */
5832           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5833             {
5834               if (TREE_CODE (field) == FIELD_DECL)
5835                 {
5836                   int num;
5837
5838                   if (TREE_TYPE (field) == error_mark_node)
5839                     continue;
5840
5841                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
5842                                            TREE_TYPE (field), subclasses,
5843                                            bit_offset);
5844                   if (!num)
5845                     return 0;
5846                   for (i = 0; i < num; i++)
5847                     classes[i] = merge_classes (subclasses[i], classes[i]);
5848                 }
5849             }
5850           break;
5851
5852         default:
5853           gcc_unreachable ();
5854         }
5855
5856       if (words > 2)
5857         {
5858           /* When size > 16 bytes, if the first one isn't
5859              X86_64_SSE_CLASS or any other ones aren't
5860              X86_64_SSEUP_CLASS, everything should be passed in
5861              memory.  */
5862           if (classes[0] != X86_64_SSE_CLASS)
5863               return 0;
5864
5865           for (i = 1; i < words; i++)
5866             if (classes[i] != X86_64_SSEUP_CLASS)
5867               return 0;
5868         }
5869
5870       /* Final merger cleanup.  */
5871       for (i = 0; i < words; i++)
5872         {
5873           /* If one class is MEMORY, everything should be passed in
5874              memory.  */
5875           if (classes[i] == X86_64_MEMORY_CLASS)
5876             return 0;
5877
5878           /* The X86_64_SSEUP_CLASS should be always preceded by
5879              X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
5880           if (classes[i] == X86_64_SSEUP_CLASS
5881               && classes[i - 1] != X86_64_SSE_CLASS
5882               && classes[i - 1] != X86_64_SSEUP_CLASS)
5883             {
5884               /* The first one should never be X86_64_SSEUP_CLASS.  */
5885               gcc_assert (i != 0);
5886               classes[i] = X86_64_SSE_CLASS;
5887             }
5888
5889           /*  If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
5890                everything should be passed in memory.  */
5891           if (classes[i] == X86_64_X87UP_CLASS
5892               && (classes[i - 1] != X86_64_X87_CLASS))
5893             {
5894               static bool warned;
5895
5896               /* The first one should never be X86_64_X87UP_CLASS.  */
5897               gcc_assert (i != 0);
5898               if (!warned && warn_psabi)
5899                 {
5900                   warned = true;
5901                   inform (input_location,
5902                           "the ABI of passing union with long double"
5903                           " has changed in GCC 4.4");
5904                 }
5905               return 0;
5906             }
5907         }
5908       return words;
5909     }
5910
5911   /* Compute alignment needed.  We align all types to natural boundaries with
5912      exception of XFmode that is aligned to 64bits.  */
5913   if (mode != VOIDmode && mode != BLKmode)
5914     {
5915       int mode_alignment = GET_MODE_BITSIZE (mode);
5916
5917       if (mode == XFmode)
5918         mode_alignment = 128;
5919       else if (mode == XCmode)
5920         mode_alignment = 256;
5921       if (COMPLEX_MODE_P (mode))
5922         mode_alignment /= 2;
5923       /* Misaligned fields are always returned in memory.  */
5924       if (bit_offset % mode_alignment)
5925         return 0;
5926     }
5927
5928   /* for V1xx modes, just use the base mode */
5929   if (VECTOR_MODE_P (mode) && mode != V1DImode && mode != V1TImode
5930       && GET_MODE_SIZE (GET_MODE_INNER (mode)) == bytes)
5931     mode = GET_MODE_INNER (mode);
5932
5933   /* Classification of atomic types.  */
5934   switch (mode)
5935     {
5936     case SDmode:
5937     case DDmode:
5938       classes[0] = X86_64_SSE_CLASS;
5939       return 1;
5940     case TDmode:
5941       classes[0] = X86_64_SSE_CLASS;
5942       classes[1] = X86_64_SSEUP_CLASS;
5943       return 2;
5944     case DImode:
5945     case SImode:
5946     case HImode:
5947     case QImode:
5948     case CSImode:
5949     case CHImode:
5950     case CQImode:
5951       {
5952         int size = (bit_offset % 64)+ (int) GET_MODE_BITSIZE (mode);
5953
5954         if (size <= 32)
5955           {
5956             classes[0] = X86_64_INTEGERSI_CLASS;
5957             return 1;
5958           }
5959         else if (size <= 64)
5960           {
5961             classes[0] = X86_64_INTEGER_CLASS;
5962             return 1;
5963           }
5964         else if (size <= 64+32)
5965           {
5966             classes[0] = X86_64_INTEGER_CLASS;
5967             classes[1] = X86_64_INTEGERSI_CLASS;
5968             return 2;
5969           }
5970         else if (size <= 64+64)
5971           {
5972             classes[0] = classes[1] = X86_64_INTEGER_CLASS;
5973             return 2;
5974           }
5975         else
5976           gcc_unreachable ();
5977       }
5978     case CDImode:
5979     case TImode:
5980       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
5981       return 2;
5982     case COImode:
5983     case OImode:
5984       /* OImode shouldn't be used directly.  */
5985       gcc_unreachable ();
5986     case CTImode:
5987       return 0;
5988     case SFmode:
5989       if (!(bit_offset % 64))
5990         classes[0] = X86_64_SSESF_CLASS;
5991       else
5992         classes[0] = X86_64_SSE_CLASS;
5993       return 1;
5994     case DFmode:
5995       classes[0] = X86_64_SSEDF_CLASS;
5996       return 1;
5997     case XFmode:
5998       classes[0] = X86_64_X87_CLASS;
5999       classes[1] = X86_64_X87UP_CLASS;
6000       return 2;
6001     case TFmode:
6002       classes[0] = X86_64_SSE_CLASS;
6003       classes[1] = X86_64_SSEUP_CLASS;
6004       return 2;
6005     case SCmode:
6006       classes[0] = X86_64_SSE_CLASS;
6007       if (!(bit_offset % 64))
6008         return 1;
6009       else
6010         {
6011           static bool warned;
6012
6013           if (!warned && warn_psabi)
6014             {
6015               warned = true;
6016               inform (input_location,
6017                       "the ABI of passing structure with complex float"
6018                       " member has changed in GCC 4.4");
6019             }
6020           classes[1] = X86_64_SSESF_CLASS;
6021           return 2;
6022         }
6023     case DCmode:
6024       classes[0] = X86_64_SSEDF_CLASS;
6025       classes[1] = X86_64_SSEDF_CLASS;
6026       return 2;
6027     case XCmode:
6028       classes[0] = X86_64_COMPLEX_X87_CLASS;
6029       return 1;
6030     case TCmode:
6031       /* This modes is larger than 16 bytes.  */
6032       return 0;
6033     case V8SFmode:
6034     case V8SImode:
6035     case V32QImode:
6036     case V16HImode:
6037     case V4DFmode:
6038     case V4DImode:
6039       classes[0] = X86_64_SSE_CLASS;
6040       classes[1] = X86_64_SSEUP_CLASS;
6041       classes[2] = X86_64_SSEUP_CLASS;
6042       classes[3] = X86_64_SSEUP_CLASS;
6043       return 4;
6044     case V4SFmode:
6045     case V4SImode:
6046     case V16QImode:
6047     case V8HImode:
6048     case V2DFmode:
6049     case V2DImode:
6050       classes[0] = X86_64_SSE_CLASS;
6051       classes[1] = X86_64_SSEUP_CLASS;
6052       return 2;
6053     case V1TImode:
6054     case V1DImode:
6055     case V2SFmode:
6056     case V2SImode:
6057     case V4HImode:
6058     case V8QImode:
6059       classes[0] = X86_64_SSE_CLASS;
6060       return 1;
6061     case BLKmode:
6062     case VOIDmode:
6063       return 0;
6064     default:
6065       gcc_assert (VECTOR_MODE_P (mode));
6066
6067       if (bytes > 16)
6068         return 0;
6069
6070       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
6071
6072       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
6073         classes[0] = X86_64_INTEGERSI_CLASS;
6074       else
6075         classes[0] = X86_64_INTEGER_CLASS;
6076       classes[1] = X86_64_INTEGER_CLASS;
6077       return 1 + (bytes > 8);
6078     }
6079 }
6080
6081 /* Examine the argument and return set number of register required in each
6082    class.  Return 0 iff parameter should be passed in memory.  */
6083 static int
6084 examine_argument (enum machine_mode mode, const_tree type, int in_return,
6085                   int *int_nregs, int *sse_nregs)
6086 {
6087   enum x86_64_reg_class regclass[MAX_CLASSES];
6088   int n = classify_argument (mode, type, regclass, 0);
6089
6090   *int_nregs = 0;
6091   *sse_nregs = 0;
6092   if (!n)
6093     return 0;
6094   for (n--; n >= 0; n--)
6095     switch (regclass[n])
6096       {
6097       case X86_64_INTEGER_CLASS:
6098       case X86_64_INTEGERSI_CLASS:
6099         (*int_nregs)++;
6100         break;
6101       case X86_64_SSE_CLASS:
6102       case X86_64_SSESF_CLASS:
6103       case X86_64_SSEDF_CLASS:
6104         (*sse_nregs)++;
6105         break;
6106       case X86_64_NO_CLASS:
6107       case X86_64_SSEUP_CLASS:
6108         break;
6109       case X86_64_X87_CLASS:
6110       case X86_64_X87UP_CLASS:
6111         if (!in_return)
6112           return 0;
6113         break;
6114       case X86_64_COMPLEX_X87_CLASS:
6115         return in_return ? 2 : 0;
6116       case X86_64_MEMORY_CLASS:
6117         gcc_unreachable ();
6118       }
6119   return 1;
6120 }
6121
6122 /* Construct container for the argument used by GCC interface.  See
6123    FUNCTION_ARG for the detailed description.  */
6124
6125 static rtx
6126 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
6127                      const_tree type, int in_return, int nintregs, int nsseregs,
6128                      const int *intreg, int sse_regno)
6129 {
6130   /* The following variables hold the static issued_error state.  */
6131   static bool issued_sse_arg_error;
6132   static bool issued_sse_ret_error;
6133   static bool issued_x87_ret_error;
6134
6135   enum machine_mode tmpmode;
6136   int bytes =
6137     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
6138   enum x86_64_reg_class regclass[MAX_CLASSES];
6139   int n;
6140   int i;
6141   int nexps = 0;
6142   int needed_sseregs, needed_intregs;
6143   rtx exp[MAX_CLASSES];
6144   rtx ret;
6145
6146   n = classify_argument (mode, type, regclass, 0);
6147   if (!n)
6148     return NULL;
6149   if (!examine_argument (mode, type, in_return, &needed_intregs,
6150                          &needed_sseregs))
6151     return NULL;
6152   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
6153     return NULL;
6154
6155   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
6156      some less clueful developer tries to use floating-point anyway.  */
6157   if (needed_sseregs && !TARGET_SSE)
6158     {
6159       if (in_return)
6160         {
6161           if (!issued_sse_ret_error)
6162             {
6163               error ("SSE register return with SSE disabled");
6164               issued_sse_ret_error = true;
6165             }
6166         }
6167       else if (!issued_sse_arg_error)
6168         {
6169           error ("SSE register argument with SSE disabled");
6170           issued_sse_arg_error = true;
6171         }
6172       return NULL;
6173     }
6174
6175   /* Likewise, error if the ABI requires us to return values in the
6176      x87 registers and the user specified -mno-80387.  */
6177   if (!TARGET_80387 && in_return)
6178     for (i = 0; i < n; i++)
6179       if (regclass[i] == X86_64_X87_CLASS
6180           || regclass[i] == X86_64_X87UP_CLASS
6181           || regclass[i] == X86_64_COMPLEX_X87_CLASS)
6182         {
6183           if (!issued_x87_ret_error)
6184             {
6185               error ("x87 register return with x87 disabled");
6186               issued_x87_ret_error = true;
6187             }
6188           return NULL;
6189         }
6190
6191   /* First construct simple cases.  Avoid SCmode, since we want to use
6192      single register to pass this type.  */
6193   if (n == 1 && mode != SCmode)
6194     switch (regclass[0])
6195       {
6196       case X86_64_INTEGER_CLASS:
6197       case X86_64_INTEGERSI_CLASS:
6198         return gen_rtx_REG (mode, intreg[0]);
6199       case X86_64_SSE_CLASS:
6200       case X86_64_SSESF_CLASS:
6201       case X86_64_SSEDF_CLASS:
6202         if (mode != BLKmode)
6203           return gen_reg_or_parallel (mode, orig_mode,
6204                                       SSE_REGNO (sse_regno));
6205         break;
6206       case X86_64_X87_CLASS:
6207       case X86_64_COMPLEX_X87_CLASS:
6208         return gen_rtx_REG (mode, FIRST_STACK_REG);
6209       case X86_64_NO_CLASS:
6210         /* Zero sized array, struct or class.  */
6211         return NULL;
6212       default:
6213         gcc_unreachable ();
6214       }
6215   if (n == 2 && regclass[0] == X86_64_SSE_CLASS
6216       && regclass[1] == X86_64_SSEUP_CLASS && mode != BLKmode)
6217     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6218   if (n == 4
6219       && regclass[0] == X86_64_SSE_CLASS
6220       && regclass[1] == X86_64_SSEUP_CLASS
6221       && regclass[2] == X86_64_SSEUP_CLASS
6222       && regclass[3] == X86_64_SSEUP_CLASS
6223       && mode != BLKmode)
6224     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6225
6226   if (n == 2
6227       && regclass[0] == X86_64_X87_CLASS && regclass[1] == X86_64_X87UP_CLASS)
6228     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
6229   if (n == 2 && regclass[0] == X86_64_INTEGER_CLASS
6230       && regclass[1] == X86_64_INTEGER_CLASS
6231       && (mode == CDImode || mode == TImode || mode == TFmode)
6232       && intreg[0] + 1 == intreg[1])
6233     return gen_rtx_REG (mode, intreg[0]);
6234
6235   /* Otherwise figure out the entries of the PARALLEL.  */
6236   for (i = 0; i < n; i++)
6237     {
6238       int pos;
6239
6240       switch (regclass[i])
6241         {
6242           case X86_64_NO_CLASS:
6243             break;
6244           case X86_64_INTEGER_CLASS:
6245           case X86_64_INTEGERSI_CLASS:
6246             /* Merge TImodes on aligned occasions here too.  */
6247             if (i * 8 + 8 > bytes)
6248               tmpmode = mode_for_size ((bytes - i * 8) * BITS_PER_UNIT, MODE_INT, 0);
6249             else if (regclass[i] == X86_64_INTEGERSI_CLASS)
6250               tmpmode = SImode;
6251             else
6252               tmpmode = DImode;
6253             /* We've requested 24 bytes we don't have mode for.  Use DImode.  */
6254             if (tmpmode == BLKmode)
6255               tmpmode = DImode;
6256             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6257                                                gen_rtx_REG (tmpmode, *intreg),
6258                                                GEN_INT (i*8));
6259             intreg++;
6260             break;
6261           case X86_64_SSESF_CLASS:
6262             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6263                                                gen_rtx_REG (SFmode,
6264                                                             SSE_REGNO (sse_regno)),
6265                                                GEN_INT (i*8));
6266             sse_regno++;
6267             break;
6268           case X86_64_SSEDF_CLASS:
6269             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6270                                                gen_rtx_REG (DFmode,
6271                                                             SSE_REGNO (sse_regno)),
6272                                                GEN_INT (i*8));
6273             sse_regno++;
6274             break;
6275           case X86_64_SSE_CLASS:
6276             pos = i;
6277             switch (n)
6278               {
6279               case 1:
6280                 tmpmode = DImode;
6281                 break;
6282               case 2:
6283                 if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
6284                   {
6285                     tmpmode = TImode;
6286                     i++;
6287                   }
6288                 else
6289                   tmpmode = DImode;
6290                 break;
6291               case 4:
6292                 gcc_assert (i == 0
6293                             && regclass[1] == X86_64_SSEUP_CLASS
6294                             && regclass[2] == X86_64_SSEUP_CLASS
6295                             && regclass[3] == X86_64_SSEUP_CLASS);
6296                 tmpmode = OImode;
6297                 i += 3;
6298                 break;
6299               default:
6300                 gcc_unreachable ();
6301               }
6302             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6303                                                gen_rtx_REG (tmpmode,
6304                                                             SSE_REGNO (sse_regno)),
6305                                                GEN_INT (pos*8));
6306             sse_regno++;
6307             break;
6308           default:
6309             gcc_unreachable ();
6310         }
6311     }
6312
6313   /* Empty aligned struct, union or class.  */
6314   if (nexps == 0)
6315     return NULL;
6316
6317   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
6318   for (i = 0; i < nexps; i++)
6319     XVECEXP (ret, 0, i) = exp [i];
6320   return ret;
6321 }
6322
6323 /* Update the data in CUM to advance over an argument of mode MODE
6324    and data type TYPE.  (TYPE is null for libcalls where that information
6325    may not be available.)  */
6326
6327 static void
6328 function_arg_advance_32 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6329                          const_tree type, HOST_WIDE_INT bytes,
6330                          HOST_WIDE_INT words)
6331 {
6332   switch (mode)
6333     {
6334     default:
6335       break;
6336
6337     case BLKmode:
6338       if (bytes < 0)
6339         break;
6340       /* FALLTHRU */
6341
6342     case DImode:
6343     case SImode:
6344     case HImode:
6345     case QImode:
6346       cum->words += words;
6347       cum->nregs -= words;
6348       cum->regno += words;
6349
6350       if (cum->nregs <= 0)
6351         {
6352           cum->nregs = 0;
6353           cum->regno = 0;
6354         }
6355       break;
6356
6357     case OImode:
6358       /* OImode shouldn't be used directly.  */
6359       gcc_unreachable ();
6360
6361     case DFmode:
6362       if (cum->float_in_sse < 2)
6363         break;
6364     case SFmode:
6365       if (cum->float_in_sse < 1)
6366         break;
6367       /* FALLTHRU */
6368
6369     case V8SFmode:
6370     case V8SImode:
6371     case V32QImode:
6372     case V16HImode:
6373     case V4DFmode:
6374     case V4DImode:
6375     case TImode:
6376     case V16QImode:
6377     case V8HImode:
6378     case V4SImode:
6379     case V2DImode:
6380     case V4SFmode:
6381     case V2DFmode:
6382       if (!type || !AGGREGATE_TYPE_P (type))
6383         {
6384           cum->sse_words += words;
6385           cum->sse_nregs -= 1;
6386           cum->sse_regno += 1;
6387           if (cum->sse_nregs <= 0)
6388             {
6389               cum->sse_nregs = 0;
6390               cum->sse_regno = 0;
6391             }
6392         }
6393       break;
6394
6395     case V8QImode:
6396     case V4HImode:
6397     case V2SImode:
6398     case V2SFmode:
6399     case V1TImode:
6400     case V1DImode:
6401       if (!type || !AGGREGATE_TYPE_P (type))
6402         {
6403           cum->mmx_words += words;
6404           cum->mmx_nregs -= 1;
6405           cum->mmx_regno += 1;
6406           if (cum->mmx_nregs <= 0)
6407             {
6408               cum->mmx_nregs = 0;
6409               cum->mmx_regno = 0;
6410             }
6411         }
6412       break;
6413     }
6414 }
6415
6416 static void
6417 function_arg_advance_64 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6418                          const_tree type, HOST_WIDE_INT words, bool named)
6419 {
6420   int int_nregs, sse_nregs;
6421
6422   /* Unnamed 256bit vector mode parameters are passed on stack.  */
6423   if (!named && VALID_AVX256_REG_MODE (mode))
6424     return;
6425
6426   if (examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
6427       && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
6428     {
6429       cum->nregs -= int_nregs;
6430       cum->sse_nregs -= sse_nregs;
6431       cum->regno += int_nregs;
6432       cum->sse_regno += sse_nregs;
6433     }
6434   else
6435     {
6436       int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD;
6437       cum->words = (cum->words + align - 1) & ~(align - 1);
6438       cum->words += words;
6439     }
6440 }
6441
6442 static void
6443 function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INT bytes,
6444                             HOST_WIDE_INT words)
6445 {
6446   /* Otherwise, this should be passed indirect.  */
6447   gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8);
6448
6449   cum->words += words;
6450   if (cum->nregs > 0)
6451     {
6452       cum->nregs -= 1;
6453       cum->regno += 1;
6454     }
6455 }
6456
6457 /* Update the data in CUM to advance over an argument of mode MODE and
6458    data type TYPE.  (TYPE is null for libcalls where that information
6459    may not be available.)  */
6460
6461 static void
6462 ix86_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6463                            const_tree type, bool named)
6464 {
6465   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6466   HOST_WIDE_INT bytes, words;
6467
6468   if (mode == BLKmode)
6469     bytes = int_size_in_bytes (type);
6470   else
6471     bytes = GET_MODE_SIZE (mode);
6472   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6473
6474   if (type)
6475     mode = type_natural_mode (type, NULL);
6476
6477   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6478     function_arg_advance_ms_64 (cum, bytes, words);
6479   else if (TARGET_64BIT)
6480     function_arg_advance_64 (cum, mode, type, words, named);
6481   else
6482     function_arg_advance_32 (cum, mode, type, bytes, words);
6483 }
6484
6485 /* Define where to put the arguments to a function.
6486    Value is zero to push the argument on the stack,
6487    or a hard register in which to store the argument.
6488
6489    MODE is the argument's machine mode.
6490    TYPE is the data type of the argument (as a tree).
6491     This is null for libcalls where that information may
6492     not be available.
6493    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6494     the preceding args and about the function being called.
6495    NAMED is nonzero if this argument is a named parameter
6496     (otherwise it is an extra parameter matching an ellipsis).  */
6497
6498 static rtx
6499 function_arg_32 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6500                  enum machine_mode orig_mode, const_tree type,
6501                  HOST_WIDE_INT bytes, HOST_WIDE_INT words)
6502 {
6503   static bool warnedsse, warnedmmx;
6504
6505   /* Avoid the AL settings for the Unix64 ABI.  */
6506   if (mode == VOIDmode)
6507     return constm1_rtx;
6508
6509   switch (mode)
6510     {
6511     default:
6512       break;
6513
6514     case BLKmode:
6515       if (bytes < 0)
6516         break;
6517       /* FALLTHRU */
6518     case DImode:
6519     case SImode:
6520     case HImode:
6521     case QImode:
6522       if (words <= cum->nregs)
6523         {
6524           int regno = cum->regno;
6525
6526           /* Fastcall allocates the first two DWORD (SImode) or
6527             smaller arguments to ECX and EDX if it isn't an
6528             aggregate type .  */
6529           if (cum->fastcall)
6530             {
6531               if (mode == BLKmode
6532                   || mode == DImode
6533                   || (type && AGGREGATE_TYPE_P (type)))
6534                 break;
6535
6536               /* ECX not EAX is the first allocated register.  */
6537               if (regno == AX_REG)
6538                 regno = CX_REG;
6539             }
6540           return gen_rtx_REG (mode, regno);
6541         }
6542       break;
6543
6544     case DFmode:
6545       if (cum->float_in_sse < 2)
6546         break;
6547     case SFmode:
6548       if (cum->float_in_sse < 1)
6549         break;
6550       /* FALLTHRU */
6551     case TImode:
6552       /* In 32bit, we pass TImode in xmm registers.  */
6553     case V16QImode:
6554     case V8HImode:
6555     case V4SImode:
6556     case V2DImode:
6557     case V4SFmode:
6558     case V2DFmode:
6559       if (!type || !AGGREGATE_TYPE_P (type))
6560         {
6561           if (!TARGET_SSE && !warnedsse && cum->warn_sse)
6562             {
6563               warnedsse = true;
6564               warning (0, "SSE vector argument without SSE enabled "
6565                        "changes the ABI");
6566             }
6567           if (cum->sse_nregs)
6568             return gen_reg_or_parallel (mode, orig_mode,
6569                                         cum->sse_regno + FIRST_SSE_REG);
6570         }
6571       break;
6572
6573     case OImode:
6574       /* OImode shouldn't be used directly.  */
6575       gcc_unreachable ();
6576
6577     case V8SFmode:
6578     case V8SImode:
6579     case V32QImode:
6580     case V16HImode:
6581     case V4DFmode:
6582     case V4DImode:
6583       if (!type || !AGGREGATE_TYPE_P (type))
6584         {
6585           if (cum->sse_nregs)
6586             return gen_reg_or_parallel (mode, orig_mode,
6587                                         cum->sse_regno + FIRST_SSE_REG);
6588         }
6589       break;
6590
6591     case V8QImode:
6592     case V4HImode:
6593     case V2SImode:
6594     case V2SFmode:
6595     case V1TImode:
6596     case V1DImode:
6597       if (!type || !AGGREGATE_TYPE_P (type))
6598         {
6599           if (!TARGET_MMX && !warnedmmx && cum->warn_mmx)
6600             {
6601               warnedmmx = true;
6602               warning (0, "MMX vector argument without MMX enabled "
6603                        "changes the ABI");
6604             }
6605           if (cum->mmx_nregs)
6606             return gen_reg_or_parallel (mode, orig_mode,
6607                                         cum->mmx_regno + FIRST_MMX_REG);
6608         }
6609       break;
6610     }
6611
6612   return NULL_RTX;
6613 }
6614
6615 static rtx
6616 function_arg_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6617                  enum machine_mode orig_mode, const_tree type, bool named)
6618 {
6619   /* Handle a hidden AL argument containing number of registers
6620      for varargs x86-64 functions.  */
6621   if (mode == VOIDmode)
6622     return GEN_INT (cum->maybe_vaarg
6623                     ? (cum->sse_nregs < 0
6624                        ? X86_64_SSE_REGPARM_MAX
6625                        : cum->sse_regno)
6626                     : -1);
6627
6628   switch (mode)
6629     {
6630     default:
6631       break;
6632
6633     case V8SFmode:
6634     case V8SImode:
6635     case V32QImode:
6636     case V16HImode:
6637     case V4DFmode:
6638     case V4DImode:
6639       /* Unnamed 256bit vector mode parameters are passed on stack.  */
6640       if (!named)
6641         return NULL;
6642       break;
6643     }
6644
6645   return construct_container (mode, orig_mode, type, 0, cum->nregs,
6646                               cum->sse_nregs,
6647                               &x86_64_int_parameter_registers [cum->regno],
6648                               cum->sse_regno);
6649 }
6650
6651 static rtx
6652 function_arg_ms_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6653                     enum machine_mode orig_mode, bool named,
6654                     HOST_WIDE_INT bytes)
6655 {
6656   unsigned int regno;
6657
6658   /* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
6659      We use value of -2 to specify that current function call is MSABI.  */
6660   if (mode == VOIDmode)
6661     return GEN_INT (-2);
6662
6663   /* If we've run out of registers, it goes on the stack.  */
6664   if (cum->nregs == 0)
6665     return NULL_RTX;
6666
6667   regno = x86_64_ms_abi_int_parameter_registers[cum->regno];
6668
6669   /* Only floating point modes are passed in anything but integer regs.  */
6670   if (TARGET_SSE && (mode == SFmode || mode == DFmode))
6671     {
6672       if (named)
6673         regno = cum->regno + FIRST_SSE_REG;
6674       else
6675         {
6676           rtx t1, t2;
6677
6678           /* Unnamed floating parameters are passed in both the
6679              SSE and integer registers.  */
6680           t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG);
6681           t2 = gen_rtx_REG (mode, regno);
6682           t1 = gen_rtx_EXPR_LIST (VOIDmode, t1, const0_rtx);
6683           t2 = gen_rtx_EXPR_LIST (VOIDmode, t2, const0_rtx);
6684           return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2));
6685         }
6686     }
6687   /* Handle aggregated types passed in register.  */
6688   if (orig_mode == BLKmode)
6689     {
6690       if (bytes > 0 && bytes <= 8)
6691         mode = (bytes > 4 ? DImode : SImode);
6692       if (mode == BLKmode)
6693         mode = DImode;
6694     }
6695
6696   return gen_reg_or_parallel (mode, orig_mode, regno);
6697 }
6698
6699 /* Return where to put the arguments to a function.
6700    Return zero to push the argument on the stack, or a hard register in which to store the argument.
6701
6702    MODE is the argument's machine mode.  TYPE is the data type of the
6703    argument.  It is null for libcalls where that information may not be
6704    available.  CUM gives information about the preceding args and about
6705    the function being called.  NAMED is nonzero if this argument is a
6706    named parameter (otherwise it is an extra parameter matching an
6707    ellipsis).  */
6708
6709 static rtx
6710 ix86_function_arg (cumulative_args_t cum_v, enum machine_mode omode,
6711                    const_tree type, bool named)
6712 {
6713   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6714   enum machine_mode mode = omode;
6715   HOST_WIDE_INT bytes, words;
6716   rtx arg;
6717
6718   if (mode == BLKmode)
6719     bytes = int_size_in_bytes (type);
6720   else
6721     bytes = GET_MODE_SIZE (mode);
6722   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6723
6724   /* To simplify the code below, represent vector types with a vector mode
6725      even if MMX/SSE are not active.  */
6726   if (type && TREE_CODE (type) == VECTOR_TYPE)
6727     mode = type_natural_mode (type, cum);
6728
6729   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6730     arg = function_arg_ms_64 (cum, mode, omode, named, bytes);
6731   else if (TARGET_64BIT)
6732     arg = function_arg_64 (cum, mode, omode, type, named);
6733   else
6734     arg = function_arg_32 (cum, mode, omode, type, bytes, words);
6735
6736   if (TARGET_VZEROUPPER && function_pass_avx256_p (arg))
6737     {
6738       /* This argument uses 256bit AVX modes.  */
6739       if (cum->caller)
6740         cfun->machine->callee_pass_avx256_p = true;
6741       else
6742         cfun->machine->caller_pass_avx256_p = true;
6743     }
6744
6745   return arg;
6746 }
6747
6748 /* A C expression that indicates when an argument must be passed by
6749    reference.  If nonzero for an argument, a copy of that argument is
6750    made in memory and a pointer to the argument is passed instead of
6751    the argument itself.  The pointer is passed in whatever way is
6752    appropriate for passing a pointer to that type.  */
6753
6754 static bool
6755 ix86_pass_by_reference (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
6756                         enum machine_mode mode ATTRIBUTE_UNUSED,
6757                         const_tree type, bool named ATTRIBUTE_UNUSED)
6758 {
6759   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6760
6761   /* See Windows x64 Software Convention.  */
6762   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6763     {
6764       int msize = (int) GET_MODE_SIZE (mode);
6765       if (type)
6766         {
6767           /* Arrays are passed by reference.  */
6768           if (TREE_CODE (type) == ARRAY_TYPE)
6769             return true;
6770
6771           if (AGGREGATE_TYPE_P (type))
6772             {
6773               /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
6774                  are passed by reference.  */
6775               msize = int_size_in_bytes (type);
6776             }
6777         }
6778
6779       /* __m128 is passed by reference.  */
6780       switch (msize) {
6781       case 1: case 2: case 4: case 8:
6782         break;
6783       default:
6784         return true;
6785       }
6786     }
6787   else if (TARGET_64BIT && type && int_size_in_bytes (type) == -1)
6788     return 1;
6789
6790   return 0;
6791 }
6792
6793 /* Return true when TYPE should be 128bit aligned for 32bit argument
6794    passing ABI.  XXX: This function is obsolete and is only used for
6795    checking psABI compatibility with previous versions of GCC.  */
6796
6797 static bool
6798 ix86_compat_aligned_value_p (const_tree type)
6799 {
6800   enum machine_mode mode = TYPE_MODE (type);
6801   if (((TARGET_SSE && SSE_REG_MODE_P (mode))
6802        || mode == TDmode
6803        || mode == TFmode
6804        || mode == TCmode)
6805       && (!TYPE_USER_ALIGN (type) || TYPE_ALIGN (type) > 128))
6806     return true;
6807   if (TYPE_ALIGN (type) < 128)
6808     return false;
6809
6810   if (AGGREGATE_TYPE_P (type))
6811     {
6812       /* Walk the aggregates recursively.  */
6813       switch (TREE_CODE (type))
6814         {
6815         case RECORD_TYPE:
6816         case UNION_TYPE:
6817         case QUAL_UNION_TYPE:
6818           {
6819             tree field;
6820
6821             /* Walk all the structure fields.  */
6822             for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6823               {
6824                 if (TREE_CODE (field) == FIELD_DECL
6825                     && ix86_compat_aligned_value_p (TREE_TYPE (field)))
6826                   return true;
6827               }
6828             break;
6829           }
6830
6831         case ARRAY_TYPE:
6832           /* Just for use if some languages passes arrays by value.  */
6833           if (ix86_compat_aligned_value_p (TREE_TYPE (type)))
6834             return true;
6835           break;
6836
6837         default:
6838           gcc_unreachable ();
6839         }
6840     }
6841   return false;
6842 }
6843
6844 /* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
6845    XXX: This function is obsolete and is only used for checking psABI
6846    compatibility with previous versions of GCC.  */
6847
6848 static unsigned int
6849 ix86_compat_function_arg_boundary (enum machine_mode mode,
6850                                    const_tree type, unsigned int align)
6851 {
6852   /* In 32bit, only _Decimal128 and __float128 are aligned to their
6853      natural boundaries.  */
6854   if (!TARGET_64BIT && mode != TDmode && mode != TFmode)
6855     {
6856       /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
6857          make an exception for SSE modes since these require 128bit
6858          alignment.
6859
6860          The handling here differs from field_alignment.  ICC aligns MMX
6861          arguments to 4 byte boundaries, while structure fields are aligned
6862          to 8 byte boundaries.  */
6863       if (!type)
6864         {
6865           if (!(TARGET_SSE && SSE_REG_MODE_P (mode)))
6866             align = PARM_BOUNDARY;
6867         }
6868       else
6869         {
6870           if (!ix86_compat_aligned_value_p (type))
6871             align = PARM_BOUNDARY;
6872         }
6873     }
6874   if (align > BIGGEST_ALIGNMENT)
6875     align = BIGGEST_ALIGNMENT;
6876   return align;
6877 }
6878
6879 /* Return true when TYPE should be 128bit aligned for 32bit argument
6880    passing ABI.  */
6881
6882 static bool
6883 ix86_contains_aligned_value_p (const_tree type)
6884 {
6885   enum machine_mode mode = TYPE_MODE (type);
6886
6887   if (mode == XFmode || mode == XCmode)
6888     return false;
6889
6890   if (TYPE_ALIGN (type) < 128)
6891     return false;
6892
6893   if (AGGREGATE_TYPE_P (type))
6894     {
6895       /* Walk the aggregates recursively.  */
6896       switch (TREE_CODE (type))
6897         {
6898         case RECORD_TYPE:
6899         case UNION_TYPE:
6900         case QUAL_UNION_TYPE:
6901           {
6902             tree field;
6903
6904             /* Walk all the structure fields.  */
6905             for (field = TYPE_FIELDS (type);
6906                  field;
6907                  field = DECL_CHAIN (field))
6908               {
6909                 if (TREE_CODE (field) == FIELD_DECL
6910                     && ix86_contains_aligned_value_p (TREE_TYPE (field)))
6911                   return true;
6912               }
6913             break;
6914           }
6915
6916         case ARRAY_TYPE:
6917           /* Just for use if some languages passes arrays by value.  */
6918           if (ix86_contains_aligned_value_p (TREE_TYPE (type)))
6919             return true;
6920           break;
6921
6922         default:
6923           gcc_unreachable ();
6924         }
6925     }
6926   else
6927     return TYPE_ALIGN (type) >= 128;
6928
6929   return false;
6930 }
6931
6932 /* Gives the alignment boundary, in bits, of an argument with the
6933    specified mode and type.  */
6934
6935 static unsigned int
6936 ix86_function_arg_boundary (enum machine_mode mode, const_tree type)
6937 {
6938   unsigned int align;
6939   if (type)
6940     {
6941       /* Since the main variant type is used for call, we convert it to
6942          the main variant type.  */
6943       type = TYPE_MAIN_VARIANT (type);
6944       align = TYPE_ALIGN (type);
6945     }
6946   else
6947     align = GET_MODE_ALIGNMENT (mode);
6948   if (align < PARM_BOUNDARY)
6949     align = PARM_BOUNDARY;
6950   else
6951     {
6952       static bool warned;
6953       unsigned int saved_align = align;
6954
6955       if (!TARGET_64BIT)
6956         {
6957           /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
6958           if (!type)
6959             {
6960               if (mode == XFmode || mode == XCmode)
6961                 align = PARM_BOUNDARY;
6962             }
6963           else if (!ix86_contains_aligned_value_p (type))
6964             align = PARM_BOUNDARY;
6965
6966           if (align < 128)
6967             align = PARM_BOUNDARY;
6968         }
6969
6970       if (warn_psabi
6971           && !warned
6972           && align != ix86_compat_function_arg_boundary (mode, type,
6973                                                          saved_align))
6974         {
6975           warned = true;
6976           inform (input_location,
6977                   "The ABI for passing parameters with %d-byte"
6978                   " alignment has changed in GCC 4.6",
6979                   align / BITS_PER_UNIT);
6980         }
6981     }
6982
6983   return align;
6984 }
6985
6986 /* Return true if N is a possible register number of function value.  */
6987
6988 static bool
6989 ix86_function_value_regno_p (const unsigned int regno)
6990 {
6991   switch (regno)
6992     {
6993     case 0:
6994       return true;
6995
6996     case FIRST_FLOAT_REG:
6997       /* TODO: The function should depend on current function ABI but
6998        builtins.c would need updating then. Therefore we use the
6999        default ABI.  */
7000       if (TARGET_64BIT && ix86_abi == MS_ABI)
7001         return false;
7002       return TARGET_FLOAT_RETURNS_IN_80387;
7003
7004     case FIRST_SSE_REG:
7005       return TARGET_SSE;
7006
7007     case FIRST_MMX_REG:
7008       if (TARGET_MACHO || TARGET_64BIT)
7009         return false;
7010       return TARGET_MMX;
7011     }
7012
7013   return false;
7014 }
7015
7016 /* Define how to find the value returned by a function.
7017    VALTYPE is the data type of the value (as a tree).
7018    If the precise function being called is known, FUNC is its FUNCTION_DECL;
7019    otherwise, FUNC is 0.  */
7020
7021 static rtx
7022 function_value_32 (enum machine_mode orig_mode, enum machine_mode mode,
7023                    const_tree fntype, const_tree fn)
7024 {
7025   unsigned int regno;
7026
7027   /* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
7028      we normally prevent this case when mmx is not available.  However
7029      some ABIs may require the result to be returned like DImode.  */
7030   if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7031     regno = TARGET_MMX ? FIRST_MMX_REG : 0;
7032
7033   /* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
7034      we prevent this case when sse is not available.  However some ABIs
7035      may require the result to be returned like integer TImode.  */
7036   else if (mode == TImode
7037            || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7038     regno = TARGET_SSE ? FIRST_SSE_REG : 0;
7039
7040   /* 32-byte vector modes in %ymm0.   */
7041   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 32)
7042     regno = TARGET_AVX ? FIRST_SSE_REG : 0;
7043
7044   /* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
7045   else if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387)
7046     regno = FIRST_FLOAT_REG;
7047   else
7048     /* Most things go in %eax.  */
7049     regno = AX_REG;
7050
7051   /* Override FP return register with %xmm0 for local functions when
7052      SSE math is enabled or for functions with sseregparm attribute.  */
7053   if ((fn || fntype) && (mode == SFmode || mode == DFmode))
7054     {
7055       int sse_level = ix86_function_sseregparm (fntype, fn, false);
7056       if ((sse_level >= 1 && mode == SFmode)
7057           || (sse_level == 2 && mode == DFmode))
7058         regno = FIRST_SSE_REG;
7059     }
7060
7061   /* OImode shouldn't be used directly.  */
7062   gcc_assert (mode != OImode);
7063
7064   return gen_rtx_REG (orig_mode, regno);
7065 }
7066
7067 static rtx
7068 function_value_64 (enum machine_mode orig_mode, enum machine_mode mode,
7069                    const_tree valtype)
7070 {
7071   rtx ret;
7072
7073   /* Handle libcalls, which don't provide a type node.  */
7074   if (valtype == NULL)
7075     {
7076       switch (mode)
7077         {
7078         case SFmode:
7079         case SCmode:
7080         case DFmode:
7081         case DCmode:
7082         case TFmode:
7083         case SDmode:
7084         case DDmode:
7085         case TDmode:
7086           return gen_rtx_REG (mode, FIRST_SSE_REG);
7087         case XFmode:
7088         case XCmode:
7089           return gen_rtx_REG (mode, FIRST_FLOAT_REG);
7090         case TCmode:
7091           return NULL;
7092         default:
7093           return gen_rtx_REG (mode, AX_REG);
7094         }
7095     }
7096   else if (POINTER_TYPE_P (valtype))
7097     {
7098       /* Pointers are always returned in Pmode. */
7099       mode = Pmode;
7100     }
7101
7102   ret = construct_container (mode, orig_mode, valtype, 1,
7103                              X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
7104                              x86_64_int_return_registers, 0);
7105
7106   /* For zero sized structures, construct_container returns NULL, but we
7107      need to keep rest of compiler happy by returning meaningful value.  */
7108   if (!ret)
7109     ret = gen_rtx_REG (orig_mode, AX_REG);
7110
7111   return ret;
7112 }
7113
7114 static rtx
7115 function_value_ms_64 (enum machine_mode orig_mode, enum machine_mode mode)
7116 {
7117   unsigned int regno = AX_REG;
7118
7119   if (TARGET_SSE)
7120     {
7121       switch (GET_MODE_SIZE (mode))
7122         {
7123         case 16:
7124           if((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7125              && !COMPLEX_MODE_P (mode))
7126             regno = FIRST_SSE_REG;
7127           break;
7128         case 8:
7129         case 4:
7130           if (mode == SFmode || mode == DFmode)
7131             regno = FIRST_SSE_REG;
7132           break;
7133         default:
7134           break;
7135         }
7136     }
7137   return gen_rtx_REG (orig_mode, regno);
7138 }
7139
7140 static rtx
7141 ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
7142                        enum machine_mode orig_mode, enum machine_mode mode)
7143 {
7144   const_tree fn, fntype;
7145
7146   fn = NULL_TREE;
7147   if (fntype_or_decl && DECL_P (fntype_or_decl))
7148     fn = fntype_or_decl;
7149   fntype = fn ? TREE_TYPE (fn) : fntype_or_decl;
7150
7151   if (TARGET_64BIT && ix86_function_type_abi (fntype) == MS_ABI)
7152     return function_value_ms_64 (orig_mode, mode);
7153   else if (TARGET_64BIT)
7154     return function_value_64 (orig_mode, mode, valtype);
7155   else
7156     return function_value_32 (orig_mode, mode, fntype, fn);
7157 }
7158
7159 static rtx
7160 ix86_function_value (const_tree valtype, const_tree fntype_or_decl,
7161                      bool outgoing ATTRIBUTE_UNUSED)
7162 {
7163   enum machine_mode mode, orig_mode;
7164
7165   orig_mode = TYPE_MODE (valtype);
7166   mode = type_natural_mode (valtype, NULL);
7167   return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
7168 }
7169
7170 /* Pointer function arguments and return values are promoted to Pmode.  */
7171
7172 static enum machine_mode
7173 ix86_promote_function_mode (const_tree type, enum machine_mode mode,
7174                             int *punsignedp, const_tree fntype,
7175                             int for_return)
7176 {
7177   if (type != NULL_TREE && POINTER_TYPE_P (type))
7178     {
7179       *punsignedp = POINTERS_EXTEND_UNSIGNED;
7180       return Pmode;
7181     }
7182   return default_promote_function_mode (type, mode, punsignedp, fntype,
7183                                         for_return);
7184 }
7185
7186 rtx
7187 ix86_libcall_value (enum machine_mode mode)
7188 {
7189   return ix86_function_value_1 (NULL, NULL, mode, mode);
7190 }
7191
7192 /* Return true iff type is returned in memory.  */
7193
7194 static bool ATTRIBUTE_UNUSED
7195 return_in_memory_32 (const_tree type, enum machine_mode mode)
7196 {
7197   HOST_WIDE_INT size;
7198
7199   if (mode == BLKmode)
7200     return true;
7201
7202   size = int_size_in_bytes (type);
7203
7204   if (MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P (type) && size <= 8)
7205     return false;
7206
7207   if (VECTOR_MODE_P (mode) || mode == TImode)
7208     {
7209       /* User-created vectors small enough to fit in EAX.  */
7210       if (size < 8)
7211         return false;
7212
7213       /* MMX/3dNow values are returned in MM0,
7214          except when it doesn't exits or the ABI prescribes otherwise.  */
7215       if (size == 8)
7216         return !TARGET_MMX || TARGET_VECT8_RETURNS;
7217
7218       /* SSE values are returned in XMM0, except when it doesn't exist.  */
7219       if (size == 16)
7220         return !TARGET_SSE;
7221
7222       /* AVX values are returned in YMM0, except when it doesn't exist.  */
7223       if (size == 32)
7224         return !TARGET_AVX;
7225     }
7226
7227   if (mode == XFmode)
7228     return false;
7229
7230   if (size > 12)
7231     return true;
7232
7233   /* OImode shouldn't be used directly.  */
7234   gcc_assert (mode != OImode);
7235
7236   return false;
7237 }
7238
7239 static bool ATTRIBUTE_UNUSED
7240 return_in_memory_64 (const_tree type, enum machine_mode mode)
7241 {
7242   int needed_intregs, needed_sseregs;
7243   return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs);
7244 }
7245
7246 static bool ATTRIBUTE_UNUSED
7247 return_in_memory_ms_64 (const_tree type, enum machine_mode mode)
7248 {
7249   HOST_WIDE_INT size = int_size_in_bytes (type);
7250
7251   /* __m128 is returned in xmm0.  */
7252   if ((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7253       && !COMPLEX_MODE_P (mode) && (GET_MODE_SIZE (mode) == 16 || size == 16))
7254     return false;
7255
7256   /* Otherwise, the size must be exactly in [1248]. */
7257   return size != 1 && size != 2 && size != 4 && size != 8;
7258 }
7259
7260 static bool
7261 ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
7262 {
7263 #ifdef SUBTARGET_RETURN_IN_MEMORY
7264   return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
7265 #else
7266   const enum machine_mode mode = type_natural_mode (type, NULL);
7267
7268   if (TARGET_64BIT)
7269     {
7270       if (ix86_function_type_abi (fntype) == MS_ABI)
7271         return return_in_memory_ms_64 (type, mode);
7272       else
7273         return return_in_memory_64 (type, mode);
7274     }
7275   else
7276     return return_in_memory_32 (type, mode);
7277 #endif
7278 }
7279
7280 /* When returning SSE vector types, we have a choice of either
7281      (1) being abi incompatible with a -march switch, or
7282      (2) generating an error.
7283    Given no good solution, I think the safest thing is one warning.
7284    The user won't be able to use -Werror, but....
7285
7286    Choose the STRUCT_VALUE_RTX hook because that's (at present) only
7287    called in response to actually generating a caller or callee that
7288    uses such a type.  As opposed to TARGET_RETURN_IN_MEMORY, which is called
7289    via aggregate_value_p for general type probing from tree-ssa.  */
7290
7291 static rtx
7292 ix86_struct_value_rtx (tree type, int incoming ATTRIBUTE_UNUSED)
7293 {
7294   static bool warnedsse, warnedmmx;
7295
7296   if (!TARGET_64BIT && type)
7297     {
7298       /* Look at the return type of the function, not the function type.  */
7299       enum machine_mode mode = TYPE_MODE (TREE_TYPE (type));
7300
7301       if (!TARGET_SSE && !warnedsse)
7302         {
7303           if (mode == TImode
7304               || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7305             {
7306               warnedsse = true;
7307               warning (0, "SSE vector return without SSE enabled "
7308                        "changes the ABI");
7309             }
7310         }
7311
7312       if (!TARGET_MMX && !warnedmmx)
7313         {
7314           if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7315             {
7316               warnedmmx = true;
7317               warning (0, "MMX vector return without MMX enabled "
7318                        "changes the ABI");
7319             }
7320         }
7321     }
7322
7323   return NULL;
7324 }
7325
7326 \f
7327 /* Create the va_list data type.  */
7328
7329 /* Returns the calling convention specific va_list date type.
7330    The argument ABI can be DEFAULT_ABI, MS_ABI, or SYSV_ABI.  */
7331
7332 static tree
7333 ix86_build_builtin_va_list_abi (enum calling_abi abi)
7334 {
7335   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
7336
7337   /* For i386 we use plain pointer to argument area.  */
7338   if (!TARGET_64BIT || abi == MS_ABI)
7339     return build_pointer_type (char_type_node);
7340
7341   record = lang_hooks.types.make_type (RECORD_TYPE);
7342   type_decl = build_decl (BUILTINS_LOCATION,
7343                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
7344
7345   f_gpr = build_decl (BUILTINS_LOCATION,
7346                       FIELD_DECL, get_identifier ("gp_offset"),
7347                       unsigned_type_node);
7348   f_fpr = build_decl (BUILTINS_LOCATION,
7349                       FIELD_DECL, get_identifier ("fp_offset"),
7350                       unsigned_type_node);
7351   f_ovf = build_decl (BUILTINS_LOCATION,
7352                       FIELD_DECL, get_identifier ("overflow_arg_area"),
7353                       ptr_type_node);
7354   f_sav = build_decl (BUILTINS_LOCATION,
7355                       FIELD_DECL, get_identifier ("reg_save_area"),
7356                       ptr_type_node);
7357
7358   va_list_gpr_counter_field = f_gpr;
7359   va_list_fpr_counter_field = f_fpr;
7360
7361   DECL_FIELD_CONTEXT (f_gpr) = record;
7362   DECL_FIELD_CONTEXT (f_fpr) = record;
7363   DECL_FIELD_CONTEXT (f_ovf) = record;
7364   DECL_FIELD_CONTEXT (f_sav) = record;
7365
7366   TYPE_STUB_DECL (record) = type_decl;
7367   TYPE_NAME (record) = type_decl;
7368   TYPE_FIELDS (record) = f_gpr;
7369   DECL_CHAIN (f_gpr) = f_fpr;
7370   DECL_CHAIN (f_fpr) = f_ovf;
7371   DECL_CHAIN (f_ovf) = f_sav;
7372
7373   layout_type (record);
7374
7375   /* The correct type is an array type of one element.  */
7376   return build_array_type (record, build_index_type (size_zero_node));
7377 }
7378
7379 /* Setup the builtin va_list data type and for 64-bit the additional
7380    calling convention specific va_list data types.  */
7381
7382 static tree
7383 ix86_build_builtin_va_list (void)
7384 {
7385   tree ret = ix86_build_builtin_va_list_abi (ix86_abi);
7386
7387   /* Initialize abi specific va_list builtin types.  */
7388   if (TARGET_64BIT)
7389     {
7390       tree t;
7391       if (ix86_abi == MS_ABI)
7392         {
7393           t = ix86_build_builtin_va_list_abi (SYSV_ABI);
7394           if (TREE_CODE (t) != RECORD_TYPE)
7395             t = build_variant_type_copy (t);
7396           sysv_va_list_type_node = t;
7397         }
7398       else
7399         {
7400           t = ret;
7401           if (TREE_CODE (t) != RECORD_TYPE)
7402             t = build_variant_type_copy (t);
7403           sysv_va_list_type_node = t;
7404         }
7405       if (ix86_abi != MS_ABI)
7406         {
7407           t = ix86_build_builtin_va_list_abi (MS_ABI);
7408           if (TREE_CODE (t) != RECORD_TYPE)
7409             t = build_variant_type_copy (t);
7410           ms_va_list_type_node = t;
7411         }
7412       else
7413         {
7414           t = ret;
7415           if (TREE_CODE (t) != RECORD_TYPE)
7416             t = build_variant_type_copy (t);
7417           ms_va_list_type_node = t;
7418         }
7419     }
7420
7421   return ret;
7422 }
7423
7424 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
7425
7426 static void
7427 setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
7428 {
7429   rtx save_area, mem;
7430   alias_set_type set;
7431   int i, max;
7432
7433   /* GPR size of varargs save area.  */
7434   if (cfun->va_list_gpr_size)
7435     ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD;
7436   else
7437     ix86_varargs_gpr_size = 0;
7438
7439   /* FPR size of varargs save area.  We don't need it if we don't pass
7440      anything in SSE registers.  */
7441   if (TARGET_SSE && cfun->va_list_fpr_size)
7442     ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16;
7443   else
7444     ix86_varargs_fpr_size = 0;
7445
7446   if (! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size)
7447     return;
7448
7449   save_area = frame_pointer_rtx;
7450   set = get_varargs_alias_set ();
7451
7452   max = cum->regno + cfun->va_list_gpr_size / UNITS_PER_WORD;
7453   if (max > X86_64_REGPARM_MAX)
7454     max = X86_64_REGPARM_MAX;
7455
7456   for (i = cum->regno; i < max; i++)
7457     {
7458       mem = gen_rtx_MEM (Pmode,
7459                          plus_constant (save_area, i * UNITS_PER_WORD));
7460       MEM_NOTRAP_P (mem) = 1;
7461       set_mem_alias_set (mem, set);
7462       emit_move_insn (mem, gen_rtx_REG (Pmode,
7463                                         x86_64_int_parameter_registers[i]));
7464     }
7465
7466   if (ix86_varargs_fpr_size)
7467     {
7468       enum machine_mode smode;
7469       rtx label, test;
7470
7471       /* Now emit code to save SSE registers.  The AX parameter contains number
7472          of SSE parameter registers used to call this function, though all we
7473          actually check here is the zero/non-zero status.  */
7474
7475       label = gen_label_rtx ();
7476       test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx);
7477       emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0), XEXP (test, 1),
7478                                       label));
7479
7480       /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
7481          we used movdqa (i.e. TImode) instead?  Perhaps even better would
7482          be if we could determine the real mode of the data, via a hook
7483          into pass_stdarg.  Ignore all that for now.  */
7484       smode = V4SFmode;
7485       if (crtl->stack_alignment_needed < GET_MODE_ALIGNMENT (smode))
7486         crtl->stack_alignment_needed = GET_MODE_ALIGNMENT (smode);
7487
7488       max = cum->sse_regno + cfun->va_list_fpr_size / 16;
7489       if (max > X86_64_SSE_REGPARM_MAX)
7490         max = X86_64_SSE_REGPARM_MAX;
7491
7492       for (i = cum->sse_regno; i < max; ++i)
7493         {
7494           mem = plus_constant (save_area, i * 16 + ix86_varargs_gpr_size);
7495           mem = gen_rtx_MEM (smode, mem);
7496           MEM_NOTRAP_P (mem) = 1;
7497           set_mem_alias_set (mem, set);
7498           set_mem_align (mem, GET_MODE_ALIGNMENT (smode));
7499
7500           emit_move_insn (mem, gen_rtx_REG (smode, SSE_REGNO (i)));
7501         }
7502
7503       emit_label (label);
7504     }
7505 }
7506
7507 static void
7508 setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
7509 {
7510   alias_set_type set = get_varargs_alias_set ();
7511   int i;
7512
7513   /* Reset to zero, as there might be a sysv vaarg used
7514      before.  */
7515   ix86_varargs_gpr_size = 0;
7516   ix86_varargs_fpr_size = 0;
7517
7518   for (i = cum->regno; i < X86_64_MS_REGPARM_MAX; i++)
7519     {
7520       rtx reg, mem;
7521
7522       mem = gen_rtx_MEM (Pmode,
7523                          plus_constant (virtual_incoming_args_rtx,
7524                                         i * UNITS_PER_WORD));
7525       MEM_NOTRAP_P (mem) = 1;
7526       set_mem_alias_set (mem, set);
7527
7528       reg = gen_rtx_REG (Pmode, x86_64_ms_abi_int_parameter_registers[i]);
7529       emit_move_insn (mem, reg);
7530     }
7531 }
7532
7533 static void
7534 ix86_setup_incoming_varargs (cumulative_args_t cum_v, enum machine_mode mode,
7535                              tree type, int *pretend_size ATTRIBUTE_UNUSED,
7536                              int no_rtl)
7537 {
7538   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
7539   CUMULATIVE_ARGS next_cum;
7540   tree fntype;
7541
7542   /* This argument doesn't appear to be used anymore.  Which is good,
7543      because the old code here didn't suppress rtl generation.  */
7544   gcc_assert (!no_rtl);
7545
7546   if (!TARGET_64BIT)
7547     return;
7548
7549   fntype = TREE_TYPE (current_function_decl);
7550
7551   /* For varargs, we do not want to skip the dummy va_dcl argument.
7552      For stdargs, we do want to skip the last named argument.  */
7553   next_cum = *cum;
7554   if (stdarg_p (fntype))
7555     ix86_function_arg_advance (pack_cumulative_args (&next_cum), mode, type,
7556                                true);
7557
7558   if (cum->call_abi == MS_ABI)
7559     setup_incoming_varargs_ms_64 (&next_cum);
7560   else
7561     setup_incoming_varargs_64 (&next_cum);
7562 }
7563
7564 /* Checks if TYPE is of kind va_list char *.  */
7565
7566 static bool
7567 is_va_list_char_pointer (tree type)
7568 {
7569   tree canonic;
7570
7571   /* For 32-bit it is always true.  */
7572   if (!TARGET_64BIT)
7573     return true;
7574   canonic = ix86_canonical_va_list_type (type);
7575   return (canonic == ms_va_list_type_node
7576           || (ix86_abi == MS_ABI && canonic == va_list_type_node));
7577 }
7578
7579 /* Implement va_start.  */
7580
7581 static void
7582 ix86_va_start (tree valist, rtx nextarg)
7583 {
7584   HOST_WIDE_INT words, n_gpr, n_fpr;
7585   tree f_gpr, f_fpr, f_ovf, f_sav;
7586   tree gpr, fpr, ovf, sav, t;
7587   tree type;
7588   rtx ovf_rtx;
7589
7590   if (flag_split_stack
7591       && cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7592     {
7593       unsigned int scratch_regno;
7594
7595       /* When we are splitting the stack, we can't refer to the stack
7596          arguments using internal_arg_pointer, because they may be on
7597          the old stack.  The split stack prologue will arrange to
7598          leave a pointer to the old stack arguments in a scratch
7599          register, which we here copy to a pseudo-register.  The split
7600          stack prologue can't set the pseudo-register directly because
7601          it (the prologue) runs before any registers have been saved.  */
7602
7603       scratch_regno = split_stack_prologue_scratch_regno ();
7604       if (scratch_regno != INVALID_REGNUM)
7605         {
7606           rtx reg, seq;
7607
7608           reg = gen_reg_rtx (Pmode);
7609           cfun->machine->split_stack_varargs_pointer = reg;
7610
7611           start_sequence ();
7612           emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
7613           seq = get_insns ();
7614           end_sequence ();
7615
7616           push_topmost_sequence ();
7617           emit_insn_after (seq, entry_of_function ());
7618           pop_topmost_sequence ();
7619         }
7620     }
7621
7622   /* Only 64bit target needs something special.  */
7623   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7624     {
7625       if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7626         std_expand_builtin_va_start (valist, nextarg);
7627       else
7628         {
7629           rtx va_r, next;
7630
7631           va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
7632           next = expand_binop (ptr_mode, add_optab,
7633                                cfun->machine->split_stack_varargs_pointer,
7634                                crtl->args.arg_offset_rtx,
7635                                NULL_RTX, 0, OPTAB_LIB_WIDEN);
7636           convert_move (va_r, next, 0);
7637         }
7638       return;
7639     }
7640
7641   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7642   f_fpr = DECL_CHAIN (f_gpr);
7643   f_ovf = DECL_CHAIN (f_fpr);
7644   f_sav = DECL_CHAIN (f_ovf);
7645
7646   valist = build_simple_mem_ref (valist);
7647   TREE_TYPE (valist) = TREE_TYPE (sysv_va_list_type_node);
7648   /* The following should be folded into the MEM_REF offset.  */
7649   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), unshare_expr (valist),
7650                 f_gpr, NULL_TREE);
7651   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
7652                 f_fpr, NULL_TREE);
7653   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
7654                 f_ovf, NULL_TREE);
7655   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
7656                 f_sav, NULL_TREE);
7657
7658   /* Count number of gp and fp argument registers used.  */
7659   words = crtl->args.info.words;
7660   n_gpr = crtl->args.info.regno;
7661   n_fpr = crtl->args.info.sse_regno;
7662
7663   if (cfun->va_list_gpr_size)
7664     {
7665       type = TREE_TYPE (gpr);
7666       t = build2 (MODIFY_EXPR, type,
7667                   gpr, build_int_cst (type, n_gpr * 8));
7668       TREE_SIDE_EFFECTS (t) = 1;
7669       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7670     }
7671
7672   if (TARGET_SSE && cfun->va_list_fpr_size)
7673     {
7674       type = TREE_TYPE (fpr);
7675       t = build2 (MODIFY_EXPR, type, fpr,
7676                   build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX));
7677       TREE_SIDE_EFFECTS (t) = 1;
7678       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7679     }
7680
7681   /* Find the overflow area.  */
7682   type = TREE_TYPE (ovf);
7683   if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7684     ovf_rtx = crtl->args.internal_arg_pointer;
7685   else
7686     ovf_rtx = cfun->machine->split_stack_varargs_pointer;
7687   t = make_tree (type, ovf_rtx);
7688   if (words != 0)
7689     t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD);
7690   t = build2 (MODIFY_EXPR, type, ovf, t);
7691   TREE_SIDE_EFFECTS (t) = 1;
7692   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7693
7694   if (ix86_varargs_gpr_size || ix86_varargs_fpr_size)
7695     {
7696       /* Find the register save area.
7697          Prologue of the function save it right above stack frame.  */
7698       type = TREE_TYPE (sav);
7699       t = make_tree (type, frame_pointer_rtx);
7700       if (!ix86_varargs_gpr_size)
7701         t = fold_build_pointer_plus_hwi (t, -8 * X86_64_REGPARM_MAX);
7702       t = build2 (MODIFY_EXPR, type, sav, t);
7703       TREE_SIDE_EFFECTS (t) = 1;
7704       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7705     }
7706 }
7707
7708 /* Implement va_arg.  */
7709
7710 static tree
7711 ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
7712                       gimple_seq *post_p)
7713 {
7714   static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
7715   tree f_gpr, f_fpr, f_ovf, f_sav;
7716   tree gpr, fpr, ovf, sav, t;
7717   int size, rsize;
7718   tree lab_false, lab_over = NULL_TREE;
7719   tree addr, t2;
7720   rtx container;
7721   int indirect_p = 0;
7722   tree ptrtype;
7723   enum machine_mode nat_mode;
7724   unsigned int arg_boundary;
7725
7726   /* Only 64bit target needs something special.  */
7727   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7728     return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
7729
7730   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7731   f_fpr = DECL_CHAIN (f_gpr);
7732   f_ovf = DECL_CHAIN (f_fpr);
7733   f_sav = DECL_CHAIN (f_ovf);
7734
7735   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr),
7736                 build_va_arg_indirect_ref (valist), f_gpr, NULL_TREE);
7737   valist = build_va_arg_indirect_ref (valist);
7738   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
7739   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
7740   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
7741
7742   indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
7743   if (indirect_p)
7744     type = build_pointer_type (type);
7745   size = int_size_in_bytes (type);
7746   rsize = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7747
7748   nat_mode = type_natural_mode (type, NULL);
7749   switch (nat_mode)
7750     {
7751     case V8SFmode:
7752     case V8SImode:
7753     case V32QImode:
7754     case V16HImode:
7755     case V4DFmode:
7756     case V4DImode:
7757       /* Unnamed 256bit vector mode parameters are passed on stack.  */
7758       if (!TARGET_64BIT_MS_ABI)
7759         {
7760           container = NULL;
7761           break;
7762         }
7763
7764     default:
7765       container = construct_container (nat_mode, TYPE_MODE (type),
7766                                        type, 0, X86_64_REGPARM_MAX,
7767                                        X86_64_SSE_REGPARM_MAX, intreg,
7768                                        0);
7769       break;
7770     }
7771
7772   /* Pull the value out of the saved registers.  */
7773
7774   addr = create_tmp_var (ptr_type_node, "addr");
7775
7776   if (container)
7777     {
7778       int needed_intregs, needed_sseregs;
7779       bool need_temp;
7780       tree int_addr, sse_addr;
7781
7782       lab_false = create_artificial_label (UNKNOWN_LOCATION);
7783       lab_over = create_artificial_label (UNKNOWN_LOCATION);
7784
7785       examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
7786
7787       need_temp = (!REG_P (container)
7788                    && ((needed_intregs && TYPE_ALIGN (type) > 64)
7789                        || TYPE_ALIGN (type) > 128));
7790
7791       /* In case we are passing structure, verify that it is consecutive block
7792          on the register save area.  If not we need to do moves.  */
7793       if (!need_temp && !REG_P (container))
7794         {
7795           /* Verify that all registers are strictly consecutive  */
7796           if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0))))
7797             {
7798               int i;
7799
7800               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7801                 {
7802                   rtx slot = XVECEXP (container, 0, i);
7803                   if (REGNO (XEXP (slot, 0)) != FIRST_SSE_REG + (unsigned int) i
7804                       || INTVAL (XEXP (slot, 1)) != i * 16)
7805                     need_temp = 1;
7806                 }
7807             }
7808           else
7809             {
7810               int i;
7811
7812               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7813                 {
7814                   rtx slot = XVECEXP (container, 0, i);
7815                   if (REGNO (XEXP (slot, 0)) != (unsigned int) i
7816                       || INTVAL (XEXP (slot, 1)) != i * 8)
7817                     need_temp = 1;
7818                 }
7819             }
7820         }
7821       if (!need_temp)
7822         {
7823           int_addr = addr;
7824           sse_addr = addr;
7825         }
7826       else
7827         {
7828           int_addr = create_tmp_var (ptr_type_node, "int_addr");
7829           sse_addr = create_tmp_var (ptr_type_node, "sse_addr");
7830         }
7831
7832       /* First ensure that we fit completely in registers.  */
7833       if (needed_intregs)
7834         {
7835           t = build_int_cst (TREE_TYPE (gpr),
7836                              (X86_64_REGPARM_MAX - needed_intregs + 1) * 8);
7837           t = build2 (GE_EXPR, boolean_type_node, gpr, t);
7838           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7839           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7840           gimplify_and_add (t, pre_p);
7841         }
7842       if (needed_sseregs)
7843         {
7844           t = build_int_cst (TREE_TYPE (fpr),
7845                              (X86_64_SSE_REGPARM_MAX - needed_sseregs + 1) * 16
7846                              + X86_64_REGPARM_MAX * 8);
7847           t = build2 (GE_EXPR, boolean_type_node, fpr, t);
7848           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7849           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7850           gimplify_and_add (t, pre_p);
7851         }
7852
7853       /* Compute index to start of area used for integer regs.  */
7854       if (needed_intregs)
7855         {
7856           /* int_addr = gpr + sav; */
7857           t = fold_build_pointer_plus (sav, gpr);
7858           gimplify_assign (int_addr, t, pre_p);
7859         }
7860       if (needed_sseregs)
7861         {
7862           /* sse_addr = fpr + sav; */
7863           t = fold_build_pointer_plus (sav, fpr);
7864           gimplify_assign (sse_addr, t, pre_p);
7865         }
7866       if (need_temp)
7867         {
7868           int i, prev_size = 0;
7869           tree temp = create_tmp_var (type, "va_arg_tmp");
7870
7871           /* addr = &temp; */
7872           t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
7873           gimplify_assign (addr, t, pre_p);
7874
7875           for (i = 0; i < XVECLEN (container, 0); i++)
7876             {
7877               rtx slot = XVECEXP (container, 0, i);
7878               rtx reg = XEXP (slot, 0);
7879               enum machine_mode mode = GET_MODE (reg);
7880               tree piece_type;
7881               tree addr_type;
7882               tree daddr_type;
7883               tree src_addr, src;
7884               int src_offset;
7885               tree dest_addr, dest;
7886               int cur_size = GET_MODE_SIZE (mode);
7887
7888               gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)));
7889               prev_size = INTVAL (XEXP (slot, 1));
7890               if (prev_size + cur_size > size)
7891                 {
7892                   cur_size = size - prev_size;
7893                   mode = mode_for_size (cur_size * BITS_PER_UNIT, MODE_INT, 1);
7894                   if (mode == BLKmode)
7895                     mode = QImode;
7896                 }
7897               piece_type = lang_hooks.types.type_for_mode (mode, 1);
7898               if (mode == GET_MODE (reg))
7899                 addr_type = build_pointer_type (piece_type);
7900               else
7901                 addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7902                                                          true);
7903               daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
7904                                                         true);
7905
7906               if (SSE_REGNO_P (REGNO (reg)))
7907                 {
7908                   src_addr = sse_addr;
7909                   src_offset = (REGNO (reg) - FIRST_SSE_REG) * 16;
7910                 }
7911               else
7912                 {
7913                   src_addr = int_addr;
7914                   src_offset = REGNO (reg) * 8;
7915                 }
7916               src_addr = fold_convert (addr_type, src_addr);
7917               src_addr = fold_build_pointer_plus_hwi (src_addr, src_offset);
7918
7919               dest_addr = fold_convert (daddr_type, addr);
7920               dest_addr = fold_build_pointer_plus_hwi (dest_addr, prev_size);
7921               if (cur_size == GET_MODE_SIZE (mode))
7922                 {
7923                   src = build_va_arg_indirect_ref (src_addr);
7924                   dest = build_va_arg_indirect_ref (dest_addr);
7925
7926                   gimplify_assign (dest, src, pre_p);
7927                 }
7928               else
7929                 {
7930                   tree copy
7931                     = build_call_expr (implicit_built_in_decls[BUILT_IN_MEMCPY],
7932                                        3, dest_addr, src_addr,
7933                                        size_int (cur_size));
7934                   gimplify_and_add (copy, pre_p);
7935                 }
7936               prev_size += cur_size;
7937             }
7938         }
7939
7940       if (needed_intregs)
7941         {
7942           t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
7943                       build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
7944           gimplify_assign (gpr, t, pre_p);
7945         }
7946
7947       if (needed_sseregs)
7948         {
7949           t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
7950                       build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
7951           gimplify_assign (fpr, t, pre_p);
7952         }
7953
7954       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
7955
7956       gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
7957     }
7958
7959   /* ... otherwise out of the overflow area.  */
7960
7961   /* When we align parameter on stack for caller, if the parameter
7962      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
7963      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
7964      here with caller.  */
7965   arg_boundary = ix86_function_arg_boundary (VOIDmode, type);
7966   if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
7967     arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
7968
7969   /* Care for on-stack alignment if needed.  */
7970   if (arg_boundary <= 64 || size == 0)
7971     t = ovf;
7972  else
7973     {
7974       HOST_WIDE_INT align = arg_boundary / 8;
7975       t = fold_build_pointer_plus_hwi (ovf, align - 1);
7976       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
7977                   build_int_cst (TREE_TYPE (t), -align));
7978     }
7979
7980   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
7981   gimplify_assign (addr, t, pre_p);
7982
7983   t = fold_build_pointer_plus_hwi (t, rsize * UNITS_PER_WORD);
7984   gimplify_assign (unshare_expr (ovf), t, pre_p);
7985
7986   if (container)
7987     gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));
7988
7989   ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
7990   addr = fold_convert (ptrtype, addr);
7991
7992   if (indirect_p)
7993     addr = build_va_arg_indirect_ref (addr);
7994   return build_va_arg_indirect_ref (addr);
7995 }
7996 \f
7997 /* Return true if OPNUM's MEM should be matched
7998    in movabs* patterns.  */
7999
8000 bool
8001 ix86_check_movabs (rtx insn, int opnum)
8002 {
8003   rtx set, mem;
8004
8005   set = PATTERN (insn);
8006   if (GET_CODE (set) == PARALLEL)
8007     set = XVECEXP (set, 0, 0);
8008   gcc_assert (GET_CODE (set) == SET);
8009   mem = XEXP (set, opnum);
8010   while (GET_CODE (mem) == SUBREG)
8011     mem = SUBREG_REG (mem);
8012   gcc_assert (MEM_P (mem));
8013   return volatile_ok || !MEM_VOLATILE_P (mem);
8014 }
8015 \f
8016 /* Initialize the table of extra 80387 mathematical constants.  */
8017
8018 static void
8019 init_ext_80387_constants (void)
8020 {
8021   static const char * cst[5] =
8022   {
8023     "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
8024     "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
8025     "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
8026     "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
8027     "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
8028   };
8029   int i;
8030
8031   for (i = 0; i < 5; i++)
8032     {
8033       real_from_string (&ext_80387_constants_table[i], cst[i]);
8034       /* Ensure each constant is rounded to XFmode precision.  */
8035       real_convert (&ext_80387_constants_table[i],
8036                     XFmode, &ext_80387_constants_table[i]);
8037     }
8038
8039   ext_80387_constants_init = 1;
8040 }
8041
8042 /* Return non-zero if the constant is something that
8043    can be loaded with a special instruction.  */
8044
8045 int
8046 standard_80387_constant_p (rtx x)
8047 {
8048   enum machine_mode mode = GET_MODE (x);
8049
8050   REAL_VALUE_TYPE r;
8051
8052   if (!(X87_FLOAT_MODE_P (mode) && (GET_CODE (x) == CONST_DOUBLE)))
8053     return -1;
8054
8055   if (x == CONST0_RTX (mode))
8056     return 1;
8057   if (x == CONST1_RTX (mode))
8058     return 2;
8059
8060   REAL_VALUE_FROM_CONST_DOUBLE (r, x);
8061
8062   /* For XFmode constants, try to find a special 80387 instruction when
8063      optimizing for size or on those CPUs that benefit from them.  */
8064   if (mode == XFmode
8065       && (optimize_function_for_size_p (cfun) || TARGET_EXT_80387_CONSTANTS))
8066     {
8067       int i;
8068
8069       if (! ext_80387_constants_init)
8070         init_ext_80387_constants ();
8071
8072       for (i = 0; i < 5; i++)
8073         if (real_identical (&r, &ext_80387_constants_table[i]))
8074           return i + 3;
8075     }
8076
8077   /* Load of the constant -0.0 or -1.0 will be split as
8078      fldz;fchs or fld1;fchs sequence.  */
8079   if (real_isnegzero (&r))
8080     return 8;
8081   if (real_identical (&r, &dconstm1))
8082     return 9;
8083
8084   return 0;
8085 }
8086
8087 /* Return the opcode of the special instruction to be used to load
8088    the constant X.  */
8089
8090 const char *
8091 standard_80387_constant_opcode (rtx x)
8092 {
8093   switch (standard_80387_constant_p (x))
8094     {
8095     case 1:
8096       return "fldz";
8097     case 2:
8098       return "fld1";
8099     case 3:
8100       return "fldlg2";
8101     case 4:
8102       return "fldln2";
8103     case 5:
8104       return "fldl2e";
8105     case 6:
8106       return "fldl2t";
8107     case 7:
8108       return "fldpi";
8109     case 8:
8110     case 9:
8111       return "#";
8112     default:
8113       gcc_unreachable ();
8114     }
8115 }
8116
8117 /* Return the CONST_DOUBLE representing the 80387 constant that is
8118    loaded by the specified special instruction.  The argument IDX
8119    matches the return value from standard_80387_constant_p.  */
8120
8121 rtx
8122 standard_80387_constant_rtx (int idx)
8123 {
8124   int i;
8125
8126   if (! ext_80387_constants_init)
8127     init_ext_80387_constants ();
8128
8129   switch (idx)
8130     {
8131     case 3:
8132     case 4:
8133     case 5:
8134     case 6:
8135     case 7:
8136       i = idx - 3;
8137       break;
8138
8139     default:
8140       gcc_unreachable ();
8141     }
8142
8143   return CONST_DOUBLE_FROM_REAL_VALUE (ext_80387_constants_table[i],
8144                                        XFmode);
8145 }
8146
8147 /* Return 1 if X is all 0s and 2 if x is all 1s
8148    in supported SSE vector mode.  */
8149
8150 int
8151 standard_sse_constant_p (rtx x)
8152 {
8153   enum machine_mode mode = GET_MODE (x);
8154
8155   if (x == const0_rtx || x == CONST0_RTX (GET_MODE (x)))
8156     return 1;
8157   if (vector_all_ones_operand (x, mode))
8158     switch (mode)
8159       {
8160       case V16QImode:
8161       case V8HImode:
8162       case V4SImode:
8163       case V2DImode:
8164         if (TARGET_SSE2)
8165           return 2;
8166       default:
8167         break;
8168       }
8169
8170   return 0;
8171 }
8172
8173 /* Return the opcode of the special instruction to be used to load
8174    the constant X.  */
8175
8176 const char *
8177 standard_sse_constant_opcode (rtx insn, rtx x)
8178 {
8179   switch (standard_sse_constant_p (x))
8180     {
8181     case 1:
8182       switch (get_attr_mode (insn))
8183         {
8184         case MODE_TI:
8185           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8186             return "%vpxor\t%0, %d0";
8187         case MODE_V2DF:
8188           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8189             return "%vxorpd\t%0, %d0";
8190         case MODE_V4SF:
8191           return "%vxorps\t%0, %d0";
8192
8193         case MODE_OI:
8194           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8195             return "vpxor\t%x0, %x0, %x0";
8196         case MODE_V4DF:
8197           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8198             return "vxorpd\t%x0, %x0, %x0";
8199         case MODE_V8SF:
8200           return "vxorps\t%x0, %x0, %x0";
8201
8202         default:
8203           break;
8204         }
8205
8206     case 2:
8207       return "%vpcmpeqd\t%0, %d0";
8208     default:
8209       break;
8210     }
8211   gcc_unreachable ();
8212 }
8213
8214 /* Returns true if OP contains a symbol reference */
8215
8216 bool
8217 symbolic_reference_mentioned_p (rtx op)
8218 {
8219   const char *fmt;
8220   int i;
8221
8222   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
8223     return true;
8224
8225   fmt = GET_RTX_FORMAT (GET_CODE (op));
8226   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
8227     {
8228       if (fmt[i] == 'E')
8229         {
8230           int j;
8231
8232           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
8233             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
8234               return true;
8235         }
8236
8237       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
8238         return true;
8239     }
8240
8241   return false;
8242 }
8243
8244 /* Return true if it is appropriate to emit `ret' instructions in the
8245    body of a function.  Do this only if the epilogue is simple, needing a
8246    couple of insns.  Prior to reloading, we can't tell how many registers
8247    must be saved, so return false then.  Return false if there is no frame
8248    marker to de-allocate.  */
8249
8250 bool
8251 ix86_can_use_return_insn_p (void)
8252 {
8253   struct ix86_frame frame;
8254
8255   if (! reload_completed || frame_pointer_needed)
8256     return 0;
8257
8258   /* Don't allow more than 32k pop, since that's all we can do
8259      with one instruction.  */
8260   if (crtl->args.pops_args && crtl->args.size >= 32768)
8261     return 0;
8262
8263   ix86_compute_frame_layout (&frame);
8264   return (frame.stack_pointer_offset == UNITS_PER_WORD
8265           && (frame.nregs + frame.nsseregs) == 0);
8266 }
8267 \f
8268 /* Value should be nonzero if functions must have frame pointers.
8269    Zero means the frame pointer need not be set up (and parms may
8270    be accessed via the stack pointer) in functions that seem suitable.  */
8271
8272 static bool
8273 ix86_frame_pointer_required (void)
8274 {
8275   /* If we accessed previous frames, then the generated code expects
8276      to be able to access the saved ebp value in our frame.  */
8277   if (cfun->machine->accesses_prev_frame)
8278     return true;
8279
8280   /* Several x86 os'es need a frame pointer for other reasons,
8281      usually pertaining to setjmp.  */
8282   if (SUBTARGET_FRAME_POINTER_REQUIRED)
8283     return true;
8284
8285   /* In ix86_option_override_internal, TARGET_OMIT_LEAF_FRAME_POINTER
8286      turns off the frame pointer by default.  Turn it back on now if
8287      we've not got a leaf function.  */
8288   if (TARGET_OMIT_LEAF_FRAME_POINTER
8289       && (!current_function_is_leaf
8290           || ix86_current_function_calls_tls_descriptor))
8291     return true;
8292
8293   if (crtl->profile && !flag_fentry)
8294     return true;
8295
8296   return false;
8297 }
8298
8299 /* Record that the current function accesses previous call frames.  */
8300
8301 void
8302 ix86_setup_frame_addresses (void)
8303 {
8304   cfun->machine->accesses_prev_frame = 1;
8305 }
8306 \f
8307 #ifndef USE_HIDDEN_LINKONCE
8308 # if defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)
8309 #  define USE_HIDDEN_LINKONCE 1
8310 # else
8311 #  define USE_HIDDEN_LINKONCE 0
8312 # endif
8313 #endif
8314
8315 static int pic_labels_used;
8316
8317 /* Fills in the label name that should be used for a pc thunk for
8318    the given register.  */
8319
8320 static void
8321 get_pc_thunk_name (char name[32], unsigned int regno)
8322 {
8323   gcc_assert (!TARGET_64BIT);
8324
8325   if (USE_HIDDEN_LINKONCE)
8326     sprintf (name, "__i686.get_pc_thunk.%s", reg_names[regno]);
8327   else
8328     ASM_GENERATE_INTERNAL_LABEL (name, "LPR", regno);
8329 }
8330
8331
8332 /* This function generates code for -fpic that loads %ebx with
8333    the return address of the caller and then returns.  */
8334
8335 static void
8336 ix86_code_end (void)
8337 {
8338   rtx xops[2];
8339   int regno;
8340
8341   for (regno = AX_REG; regno <= SP_REG; regno++)
8342     {
8343       char name[32];
8344       tree decl;
8345
8346       if (!(pic_labels_used & (1 << regno)))
8347         continue;
8348
8349       get_pc_thunk_name (name, regno);
8350
8351       decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
8352                          get_identifier (name),
8353                          build_function_type_list (void_type_node, NULL_TREE));
8354       DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
8355                                        NULL_TREE, void_type_node);
8356       TREE_PUBLIC (decl) = 1;
8357       TREE_STATIC (decl) = 1;
8358
8359 #if TARGET_MACHO
8360       if (TARGET_MACHO)
8361         {
8362           switch_to_section (darwin_sections[text_coal_section]);
8363           fputs ("\t.weak_definition\t", asm_out_file);
8364           assemble_name (asm_out_file, name);
8365           fputs ("\n\t.private_extern\t", asm_out_file);
8366           assemble_name (asm_out_file, name);
8367           putc ('\n', asm_out_file);
8368           ASM_OUTPUT_LABEL (asm_out_file, name);
8369           DECL_WEAK (decl) = 1;
8370         }
8371       else
8372 #endif
8373       if (USE_HIDDEN_LINKONCE)
8374         {
8375           DECL_COMDAT_GROUP (decl) = DECL_ASSEMBLER_NAME (decl);
8376
8377           targetm.asm_out.unique_section (decl, 0);
8378           switch_to_section (get_named_section (decl, NULL, 0));
8379
8380           targetm.asm_out.globalize_label (asm_out_file, name);
8381           fputs ("\t.hidden\t", asm_out_file);
8382           assemble_name (asm_out_file, name);
8383           putc ('\n', asm_out_file);
8384           ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
8385         }
8386       else
8387         {
8388           switch_to_section (text_section);
8389           ASM_OUTPUT_LABEL (asm_out_file, name);
8390         }
8391
8392       DECL_INITIAL (decl) = make_node (BLOCK);
8393       current_function_decl = decl;
8394       init_function_start (decl);
8395       first_function_block_is_cold = false;
8396       /* Make sure unwind info is emitted for the thunk if needed.  */
8397       final_start_function (emit_barrier (), asm_out_file, 1);
8398
8399       /* Pad stack IP move with 4 instructions (two NOPs count
8400          as one instruction).  */
8401       if (TARGET_PAD_SHORT_FUNCTION)
8402         {
8403           int i = 8;
8404
8405           while (i--)
8406             fputs ("\tnop\n", asm_out_file);
8407         }
8408
8409       xops[0] = gen_rtx_REG (Pmode, regno);
8410       xops[1] = gen_rtx_MEM (Pmode, stack_pointer_rtx);
8411       output_asm_insn ("mov%z0\t{%1, %0|%0, %1}", xops);
8412       fputs ("\tret\n", asm_out_file);
8413       final_end_function ();
8414       init_insn_lengths ();
8415       free_after_compilation (cfun);
8416       set_cfun (NULL);
8417       current_function_decl = NULL;
8418     }
8419
8420   if (flag_split_stack)
8421     file_end_indicate_split_stack ();
8422 }
8423
8424 /* Emit code for the SET_GOT patterns.  */
8425
8426 const char *
8427 output_set_got (rtx dest, rtx label ATTRIBUTE_UNUSED)
8428 {
8429   rtx xops[3];
8430
8431   xops[0] = dest;
8432
8433   if (TARGET_VXWORKS_RTP && flag_pic)
8434     {
8435       /* Load (*VXWORKS_GOTT_BASE) into the PIC register.  */
8436       xops[2] = gen_rtx_MEM (Pmode,
8437                              gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE));
8438       output_asm_insn ("mov{l}\t{%2, %0|%0, %2}", xops);
8439
8440       /* Load (*VXWORKS_GOTT_BASE)[VXWORKS_GOTT_INDEX] into the PIC register.
8441          Use %P and a local symbol in order to print VXWORKS_GOTT_INDEX as
8442          an unadorned address.  */
8443       xops[2] = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
8444       SYMBOL_REF_FLAGS (xops[2]) |= SYMBOL_FLAG_LOCAL;
8445       output_asm_insn ("mov{l}\t{%P2(%0), %0|%0, DWORD PTR %P2[%0]}", xops);
8446       return "";
8447     }
8448
8449   xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME);
8450
8451   if (!flag_pic)
8452     {
8453       xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ());
8454
8455       output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops);
8456
8457 #if TARGET_MACHO
8458       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8459          is what will be referenced by the Mach-O PIC subsystem.  */
8460       if (!label)
8461         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8462 #endif
8463
8464       targetm.asm_out.internal_label (asm_out_file, "L",
8465                                       CODE_LABEL_NUMBER (XEXP (xops[2], 0)));
8466     }
8467   else
8468     {
8469       char name[32];
8470       get_pc_thunk_name (name, REGNO (dest));
8471       pic_labels_used |= 1 << REGNO (dest);
8472
8473       xops[2] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
8474       xops[2] = gen_rtx_MEM (QImode, xops[2]);
8475       output_asm_insn ("call\t%X2", xops);
8476       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8477          is what will be referenced by the Mach-O PIC subsystem.  */
8478 #if TARGET_MACHO
8479       if (!label)
8480         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8481       else
8482         targetm.asm_out.internal_label (asm_out_file, "L",
8483                                            CODE_LABEL_NUMBER (label));
8484 #endif
8485     }
8486
8487   if (!TARGET_MACHO)
8488     output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops);
8489
8490   return "";
8491 }
8492
8493 /* Generate an "push" pattern for input ARG.  */
8494
8495 static rtx
8496 gen_push (rtx arg)
8497 {
8498   struct machine_function *m = cfun->machine;
8499
8500   if (m->fs.cfa_reg == stack_pointer_rtx)
8501     m->fs.cfa_offset += UNITS_PER_WORD;
8502   m->fs.sp_offset += UNITS_PER_WORD;
8503
8504   return gen_rtx_SET (VOIDmode,
8505                       gen_rtx_MEM (Pmode,
8506                                    gen_rtx_PRE_DEC (Pmode,
8507                                                     stack_pointer_rtx)),
8508                       arg);
8509 }
8510
8511 /* Generate an "pop" pattern for input ARG.  */
8512
8513 static rtx
8514 gen_pop (rtx arg)
8515 {
8516   return gen_rtx_SET (VOIDmode,
8517                       arg,
8518                       gen_rtx_MEM (Pmode,
8519                                    gen_rtx_POST_INC (Pmode,
8520                                                      stack_pointer_rtx)));
8521 }
8522
8523 /* Return >= 0 if there is an unused call-clobbered register available
8524    for the entire function.  */
8525
8526 static unsigned int
8527 ix86_select_alt_pic_regnum (void)
8528 {
8529   if (current_function_is_leaf
8530       && !crtl->profile
8531       && !ix86_current_function_calls_tls_descriptor)
8532     {
8533       int i, drap;
8534       /* Can't use the same register for both PIC and DRAP.  */
8535       if (crtl->drap_reg)
8536         drap = REGNO (crtl->drap_reg);
8537       else
8538         drap = -1;
8539       for (i = 2; i >= 0; --i)
8540         if (i != drap && !df_regs_ever_live_p (i))
8541           return i;
8542     }
8543
8544   return INVALID_REGNUM;
8545 }
8546
8547 /* Return TRUE if we need to save REGNO.  */
8548
8549 static bool
8550 ix86_save_reg (unsigned int regno, bool maybe_eh_return)
8551 {
8552   if (pic_offset_table_rtx
8553       && regno == REAL_PIC_OFFSET_TABLE_REGNUM
8554       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
8555           || crtl->profile
8556           || crtl->calls_eh_return
8557           || crtl->uses_const_pool))
8558     return ix86_select_alt_pic_regnum () == INVALID_REGNUM;
8559
8560   if (crtl->calls_eh_return && maybe_eh_return)
8561     {
8562       unsigned i;
8563       for (i = 0; ; i++)
8564         {
8565           unsigned test = EH_RETURN_DATA_REGNO (i);
8566           if (test == INVALID_REGNUM)
8567             break;
8568           if (test == regno)
8569             return true;
8570         }
8571     }
8572
8573   if (crtl->drap_reg && regno == REGNO (crtl->drap_reg))
8574     return true;
8575
8576   return (df_regs_ever_live_p (regno)
8577           && !call_used_regs[regno]
8578           && !fixed_regs[regno]
8579           && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
8580 }
8581
8582 /* Return number of saved general prupose registers.  */
8583
8584 static int
8585 ix86_nsaved_regs (void)
8586 {
8587   int nregs = 0;
8588   int regno;
8589
8590   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8591     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8592       nregs ++;
8593   return nregs;
8594 }
8595
8596 /* Return number of saved SSE registrers.  */
8597
8598 static int
8599 ix86_nsaved_sseregs (void)
8600 {
8601   int nregs = 0;
8602   int regno;
8603
8604   if (!TARGET_64BIT_MS_ABI)
8605     return 0;
8606   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8607     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8608       nregs ++;
8609   return nregs;
8610 }
8611
8612 /* Given FROM and TO register numbers, say whether this elimination is
8613    allowed.  If stack alignment is needed, we can only replace argument
8614    pointer with hard frame pointer, or replace frame pointer with stack
8615    pointer.  Otherwise, frame pointer elimination is automatically
8616    handled and all other eliminations are valid.  */
8617
8618 static bool
8619 ix86_can_eliminate (const int from, const int to)
8620 {
8621   if (stack_realign_fp)
8622     return ((from == ARG_POINTER_REGNUM
8623              && to == HARD_FRAME_POINTER_REGNUM)
8624             || (from == FRAME_POINTER_REGNUM
8625                 && to == STACK_POINTER_REGNUM));
8626   else
8627     return to == STACK_POINTER_REGNUM ? !frame_pointer_needed : true;
8628 }
8629
8630 /* Return the offset between two registers, one to be eliminated, and the other
8631    its replacement, at the start of a routine.  */
8632
8633 HOST_WIDE_INT
8634 ix86_initial_elimination_offset (int from, int to)
8635 {
8636   struct ix86_frame frame;
8637   ix86_compute_frame_layout (&frame);
8638
8639   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8640     return frame.hard_frame_pointer_offset;
8641   else if (from == FRAME_POINTER_REGNUM
8642            && to == HARD_FRAME_POINTER_REGNUM)
8643     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
8644   else
8645     {
8646       gcc_assert (to == STACK_POINTER_REGNUM);
8647
8648       if (from == ARG_POINTER_REGNUM)
8649         return frame.stack_pointer_offset;
8650
8651       gcc_assert (from == FRAME_POINTER_REGNUM);
8652       return frame.stack_pointer_offset - frame.frame_pointer_offset;
8653     }
8654 }
8655
8656 /* In a dynamically-aligned function, we can't know the offset from
8657    stack pointer to frame pointer, so we must ensure that setjmp
8658    eliminates fp against the hard fp (%ebp) rather than trying to
8659    index from %esp up to the top of the frame across a gap that is
8660    of unknown (at compile-time) size.  */
8661 static rtx
8662 ix86_builtin_setjmp_frame_value (void)
8663 {
8664   return stack_realign_fp ? hard_frame_pointer_rtx : virtual_stack_vars_rtx;
8665 }
8666
8667 /* When using -fsplit-stack, the allocation routines set a field in
8668    the TCB to the bottom of the stack plus this much space, measured
8669    in bytes.  */
8670
8671 #define SPLIT_STACK_AVAILABLE 256
8672
8673 /* Fill structure ix86_frame about frame of currently computed function.  */
8674
8675 static void
8676 ix86_compute_frame_layout (struct ix86_frame *frame)
8677 {
8678   unsigned int stack_alignment_needed;
8679   HOST_WIDE_INT offset;
8680   unsigned int preferred_alignment;
8681   HOST_WIDE_INT size = get_frame_size ();
8682   HOST_WIDE_INT to_allocate;
8683
8684   frame->nregs = ix86_nsaved_regs ();
8685   frame->nsseregs = ix86_nsaved_sseregs ();
8686
8687   stack_alignment_needed = crtl->stack_alignment_needed / BITS_PER_UNIT;
8688   preferred_alignment = crtl->preferred_stack_boundary / BITS_PER_UNIT;
8689
8690   /* 64-bit MS ABI seem to require stack alignment to be always 16 except for
8691      function prologues and leaf.  */
8692   if ((TARGET_64BIT_MS_ABI && preferred_alignment < 16)
8693       && (!current_function_is_leaf || cfun->calls_alloca != 0
8694           || ix86_current_function_calls_tls_descriptor))
8695     {
8696       preferred_alignment = 16;
8697       stack_alignment_needed = 16;
8698       crtl->preferred_stack_boundary = 128;
8699       crtl->stack_alignment_needed = 128;
8700     }
8701
8702   gcc_assert (!size || stack_alignment_needed);
8703   gcc_assert (preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT);
8704   gcc_assert (preferred_alignment <= stack_alignment_needed);
8705
8706   /* For SEH we have to limit the amount of code movement into the prologue.
8707      At present we do this via a BLOCKAGE, at which point there's very little
8708      scheduling that can be done, which means that there's very little point
8709      in doing anything except PUSHs.  */
8710   if (TARGET_SEH)
8711     cfun->machine->use_fast_prologue_epilogue = false;
8712
8713   /* During reload iteration the amount of registers saved can change.
8714      Recompute the value as needed.  Do not recompute when amount of registers
8715      didn't change as reload does multiple calls to the function and does not
8716      expect the decision to change within single iteration.  */
8717   else if (!optimize_function_for_size_p (cfun)
8718            && cfun->machine->use_fast_prologue_epilogue_nregs != frame->nregs)
8719     {
8720       int count = frame->nregs;
8721       struct cgraph_node *node = cgraph_get_node (current_function_decl);
8722
8723       cfun->machine->use_fast_prologue_epilogue_nregs = count;
8724
8725       /* The fast prologue uses move instead of push to save registers.  This
8726          is significantly longer, but also executes faster as modern hardware
8727          can execute the moves in parallel, but can't do that for push/pop.
8728
8729          Be careful about choosing what prologue to emit:  When function takes
8730          many instructions to execute we may use slow version as well as in
8731          case function is known to be outside hot spot (this is known with
8732          feedback only).  Weight the size of function by number of registers
8733          to save as it is cheap to use one or two push instructions but very
8734          slow to use many of them.  */
8735       if (count)
8736         count = (count - 1) * FAST_PROLOGUE_INSN_COUNT;
8737       if (node->frequency < NODE_FREQUENCY_NORMAL
8738           || (flag_branch_probabilities
8739               && node->frequency < NODE_FREQUENCY_HOT))
8740         cfun->machine->use_fast_prologue_epilogue = false;
8741       else
8742         cfun->machine->use_fast_prologue_epilogue
8743            = !expensive_function_p (count);
8744     }
8745   if (TARGET_PROLOGUE_USING_MOVE
8746       && cfun->machine->use_fast_prologue_epilogue)
8747     frame->save_regs_using_mov = true;
8748   else
8749     frame->save_regs_using_mov = false;
8750
8751   /* If static stack checking is enabled and done with probes, the registers
8752      need to be saved before allocating the frame.  */
8753   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
8754     frame->save_regs_using_mov = false;
8755
8756   /* Skip return address.  */
8757   offset = UNITS_PER_WORD;
8758
8759   /* Skip pushed static chain.  */
8760   if (ix86_static_chain_on_stack)
8761     offset += UNITS_PER_WORD;
8762
8763   /* Skip saved base pointer.  */
8764   if (frame_pointer_needed)
8765     offset += UNITS_PER_WORD;
8766   frame->hfp_save_offset = offset;
8767
8768   /* The traditional frame pointer location is at the top of the frame.  */
8769   frame->hard_frame_pointer_offset = offset;
8770
8771   /* Register save area */
8772   offset += frame->nregs * UNITS_PER_WORD;
8773   frame->reg_save_offset = offset;
8774
8775   /* Align and set SSE register save area.  */
8776   if (frame->nsseregs)
8777     {
8778       /* The only ABI that has saved SSE registers (Win64) also has a
8779          16-byte aligned default stack, and thus we don't need to be
8780          within the re-aligned local stack frame to save them.  */
8781       gcc_assert (INCOMING_STACK_BOUNDARY >= 128);
8782       offset = (offset + 16 - 1) & -16;
8783       offset += frame->nsseregs * 16;
8784     }
8785   frame->sse_reg_save_offset = offset;
8786
8787   /* The re-aligned stack starts here.  Values before this point are not
8788      directly comparable with values below this point.  In order to make
8789      sure that no value happens to be the same before and after, force
8790      the alignment computation below to add a non-zero value.  */
8791   if (stack_realign_fp)
8792     offset = (offset + stack_alignment_needed) & -stack_alignment_needed;
8793
8794   /* Va-arg area */
8795   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
8796   offset += frame->va_arg_size;
8797
8798   /* Align start of frame for local function.  */
8799   if (stack_realign_fp
8800       || offset != frame->sse_reg_save_offset
8801       || size != 0
8802       || !current_function_is_leaf
8803       || cfun->calls_alloca
8804       || ix86_current_function_calls_tls_descriptor)
8805     offset = (offset + stack_alignment_needed - 1) & -stack_alignment_needed;
8806
8807   /* Frame pointer points here.  */
8808   frame->frame_pointer_offset = offset;
8809
8810   offset += size;
8811
8812   /* Add outgoing arguments area.  Can be skipped if we eliminated
8813      all the function calls as dead code.
8814      Skipping is however impossible when function calls alloca.  Alloca
8815      expander assumes that last crtl->outgoing_args_size
8816      of stack frame are unused.  */
8817   if (ACCUMULATE_OUTGOING_ARGS
8818       && (!current_function_is_leaf || cfun->calls_alloca
8819           || ix86_current_function_calls_tls_descriptor))
8820     {
8821       offset += crtl->outgoing_args_size;
8822       frame->outgoing_arguments_size = crtl->outgoing_args_size;
8823     }
8824   else
8825     frame->outgoing_arguments_size = 0;
8826
8827   /* Align stack boundary.  Only needed if we're calling another function
8828      or using alloca.  */
8829   if (!current_function_is_leaf || cfun->calls_alloca
8830       || ix86_current_function_calls_tls_descriptor)
8831     offset = (offset + preferred_alignment - 1) & -preferred_alignment;
8832
8833   /* We've reached end of stack frame.  */
8834   frame->stack_pointer_offset = offset;
8835
8836   /* Size prologue needs to allocate.  */
8837   to_allocate = offset - frame->sse_reg_save_offset;
8838
8839   if ((!to_allocate && frame->nregs <= 1)
8840       || (TARGET_64BIT && to_allocate >= (HOST_WIDE_INT) 0x80000000))
8841     frame->save_regs_using_mov = false;
8842
8843   if (ix86_using_red_zone ()
8844       && current_function_sp_is_unchanging
8845       && current_function_is_leaf
8846       && !ix86_current_function_calls_tls_descriptor)
8847     {
8848       frame->red_zone_size = to_allocate;
8849       if (frame->save_regs_using_mov)
8850         frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
8851       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
8852         frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
8853     }
8854   else
8855     frame->red_zone_size = 0;
8856   frame->stack_pointer_offset -= frame->red_zone_size;
8857
8858   /* The SEH frame pointer location is near the bottom of the frame.
8859      This is enforced by the fact that the difference between the
8860      stack pointer and the frame pointer is limited to 240 bytes in
8861      the unwind data structure.  */
8862   if (TARGET_SEH)
8863     {
8864       HOST_WIDE_INT diff;
8865
8866       /* If we can leave the frame pointer where it is, do so.  */
8867       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
8868       if (diff > 240 || (diff & 15) != 0)
8869         {
8870           /* Ideally we'd determine what portion of the local stack frame
8871              (within the constraint of the lowest 240) is most heavily used.
8872              But without that complication, simply bias the frame pointer
8873              by 128 bytes so as to maximize the amount of the local stack
8874              frame that is addressable with 8-bit offsets.  */
8875           frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
8876         }
8877     }
8878 }
8879
8880 /* This is semi-inlined memory_address_length, but simplified
8881    since we know that we're always dealing with reg+offset, and
8882    to avoid having to create and discard all that rtl.  */
8883
8884 static inline int
8885 choose_baseaddr_len (unsigned int regno, HOST_WIDE_INT offset)
8886 {
8887   int len = 4;
8888
8889   if (offset == 0)
8890     {
8891       /* EBP and R13 cannot be encoded without an offset.  */
8892       len = (regno == BP_REG || regno == R13_REG);
8893     }
8894   else if (IN_RANGE (offset, -128, 127))
8895     len = 1;
8896
8897   /* ESP and R12 must be encoded with a SIB byte.  */
8898   if (regno == SP_REG || regno == R12_REG)
8899     len++;
8900
8901   return len;
8902 }
8903
8904 /* Return an RTX that points to CFA_OFFSET within the stack frame.
8905    The valid base registers are taken from CFUN->MACHINE->FS.  */
8906
8907 static rtx
8908 choose_baseaddr (HOST_WIDE_INT cfa_offset)
8909 {
8910   const struct machine_function *m = cfun->machine;
8911   rtx base_reg = NULL;
8912   HOST_WIDE_INT base_offset = 0;
8913
8914   if (m->use_fast_prologue_epilogue)
8915     {
8916       /* Choose the base register most likely to allow the most scheduling
8917          opportunities.  Generally FP is valid througout the function,
8918          while DRAP must be reloaded within the epilogue.  But choose either
8919          over the SP due to increased encoding size.  */
8920
8921       if (m->fs.fp_valid)
8922         {
8923           base_reg = hard_frame_pointer_rtx;
8924           base_offset = m->fs.fp_offset - cfa_offset;
8925         }
8926       else if (m->fs.drap_valid)
8927         {
8928           base_reg = crtl->drap_reg;
8929           base_offset = 0 - cfa_offset;
8930         }
8931       else if (m->fs.sp_valid)
8932         {
8933           base_reg = stack_pointer_rtx;
8934           base_offset = m->fs.sp_offset - cfa_offset;
8935         }
8936     }
8937   else
8938     {
8939       HOST_WIDE_INT toffset;
8940       int len = 16, tlen;
8941
8942       /* Choose the base register with the smallest address encoding.
8943          With a tie, choose FP > DRAP > SP.  */
8944       if (m->fs.sp_valid)
8945         {
8946           base_reg = stack_pointer_rtx;
8947           base_offset = m->fs.sp_offset - cfa_offset;
8948           len = choose_baseaddr_len (STACK_POINTER_REGNUM, base_offset);
8949         }
8950       if (m->fs.drap_valid)
8951         {
8952           toffset = 0 - cfa_offset;
8953           tlen = choose_baseaddr_len (REGNO (crtl->drap_reg), toffset);
8954           if (tlen <= len)
8955             {
8956               base_reg = crtl->drap_reg;
8957               base_offset = toffset;
8958               len = tlen;
8959             }
8960         }
8961       if (m->fs.fp_valid)
8962         {
8963           toffset = m->fs.fp_offset - cfa_offset;
8964           tlen = choose_baseaddr_len (HARD_FRAME_POINTER_REGNUM, toffset);
8965           if (tlen <= len)
8966             {
8967               base_reg = hard_frame_pointer_rtx;
8968               base_offset = toffset;
8969               len = tlen;
8970             }
8971         }
8972     }
8973   gcc_assert (base_reg != NULL);
8974
8975   return plus_constant (base_reg, base_offset);
8976 }
8977
8978 /* Emit code to save registers in the prologue.  */
8979
8980 static void
8981 ix86_emit_save_regs (void)
8982 {
8983   unsigned int regno;
8984   rtx insn;
8985
8986   for (regno = FIRST_PSEUDO_REGISTER - 1; regno-- > 0; )
8987     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8988       {
8989         insn = emit_insn (gen_push (gen_rtx_REG (Pmode, regno)));
8990         RTX_FRAME_RELATED_P (insn) = 1;
8991       }
8992 }
8993
8994 /* Emit a single register save at CFA - CFA_OFFSET.  */
8995
8996 static void
8997 ix86_emit_save_reg_using_mov (enum machine_mode mode, unsigned int regno,
8998                               HOST_WIDE_INT cfa_offset)
8999 {
9000   struct machine_function *m = cfun->machine;
9001   rtx reg = gen_rtx_REG (mode, regno);
9002   rtx mem, addr, base, insn;
9003
9004   addr = choose_baseaddr (cfa_offset);
9005   mem = gen_frame_mem (mode, addr);
9006
9007   /* For SSE saves, we need to indicate the 128-bit alignment.  */
9008   set_mem_align (mem, GET_MODE_ALIGNMENT (mode));
9009
9010   insn = emit_move_insn (mem, reg);
9011   RTX_FRAME_RELATED_P (insn) = 1;
9012
9013   base = addr;
9014   if (GET_CODE (base) == PLUS)
9015     base = XEXP (base, 0);
9016   gcc_checking_assert (REG_P (base));
9017
9018   /* When saving registers into a re-aligned local stack frame, avoid
9019      any tricky guessing by dwarf2out.  */
9020   if (m->fs.realigned)
9021     {
9022       gcc_checking_assert (stack_realign_drap);
9023
9024       if (regno == REGNO (crtl->drap_reg))
9025         {
9026           /* A bit of a hack.  We force the DRAP register to be saved in
9027              the re-aligned stack frame, which provides us with a copy
9028              of the CFA that will last past the prologue.  Install it.  */
9029           gcc_checking_assert (cfun->machine->fs.fp_valid);
9030           addr = plus_constant (hard_frame_pointer_rtx,
9031                                 cfun->machine->fs.fp_offset - cfa_offset);
9032           mem = gen_rtx_MEM (mode, addr);
9033           add_reg_note (insn, REG_CFA_DEF_CFA, mem);
9034         }
9035       else
9036         {
9037           /* The frame pointer is a stable reference within the
9038              aligned frame.  Use it.  */
9039           gcc_checking_assert (cfun->machine->fs.fp_valid);
9040           addr = plus_constant (hard_frame_pointer_rtx,
9041                                 cfun->machine->fs.fp_offset - cfa_offset);
9042           mem = gen_rtx_MEM (mode, addr);
9043           add_reg_note (insn, REG_CFA_EXPRESSION,
9044                         gen_rtx_SET (VOIDmode, mem, reg));
9045         }
9046     }
9047
9048   /* The memory may not be relative to the current CFA register,
9049      which means that we may need to generate a new pattern for
9050      use by the unwind info.  */
9051   else if (base != m->fs.cfa_reg)
9052     {
9053       addr = plus_constant (m->fs.cfa_reg, m->fs.cfa_offset - cfa_offset);
9054       mem = gen_rtx_MEM (mode, addr);
9055       add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, mem, reg));
9056     }
9057 }
9058
9059 /* Emit code to save registers using MOV insns.
9060    First register is stored at CFA - CFA_OFFSET.  */
9061 static void
9062 ix86_emit_save_regs_using_mov (HOST_WIDE_INT cfa_offset)
9063 {
9064   unsigned int regno;
9065
9066   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9067     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9068       {
9069         ix86_emit_save_reg_using_mov (Pmode, regno, cfa_offset);
9070         cfa_offset -= UNITS_PER_WORD;
9071       }
9072 }
9073
9074 /* Emit code to save SSE registers using MOV insns.
9075    First register is stored at CFA - CFA_OFFSET.  */
9076 static void
9077 ix86_emit_save_sse_regs_using_mov (HOST_WIDE_INT cfa_offset)
9078 {
9079   unsigned int regno;
9080
9081   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9082     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9083       {
9084         ix86_emit_save_reg_using_mov (V4SFmode, regno, cfa_offset);
9085         cfa_offset -= 16;
9086       }
9087 }
9088
9089 static GTY(()) rtx queued_cfa_restores;
9090
9091 /* Add a REG_CFA_RESTORE REG note to INSN or queue them until next stack
9092    manipulation insn.  The value is on the stack at CFA - CFA_OFFSET.
9093    Don't add the note if the previously saved value will be left untouched
9094    within stack red-zone till return, as unwinders can find the same value
9095    in the register and on the stack.  */
9096
9097 static void
9098 ix86_add_cfa_restore_note (rtx insn, rtx reg, HOST_WIDE_INT cfa_offset)
9099 {
9100   if (cfa_offset <= cfun->machine->fs.red_zone_offset)
9101     return;
9102
9103   if (insn)
9104     {
9105       add_reg_note (insn, REG_CFA_RESTORE, reg);
9106       RTX_FRAME_RELATED_P (insn) = 1;
9107     }
9108   else
9109     queued_cfa_restores
9110       = alloc_reg_note (REG_CFA_RESTORE, reg, queued_cfa_restores);
9111 }
9112
9113 /* Add queued REG_CFA_RESTORE notes if any to INSN.  */
9114
9115 static void
9116 ix86_add_queued_cfa_restore_notes (rtx insn)
9117 {
9118   rtx last;
9119   if (!queued_cfa_restores)
9120     return;
9121   for (last = queued_cfa_restores; XEXP (last, 1); last = XEXP (last, 1))
9122     ;
9123   XEXP (last, 1) = REG_NOTES (insn);
9124   REG_NOTES (insn) = queued_cfa_restores;
9125   queued_cfa_restores = NULL_RTX;
9126   RTX_FRAME_RELATED_P (insn) = 1;
9127 }
9128
9129 /* Expand prologue or epilogue stack adjustment.
9130    The pattern exist to put a dependency on all ebp-based memory accesses.
9131    STYLE should be negative if instructions should be marked as frame related,
9132    zero if %r11 register is live and cannot be freely used and positive
9133    otherwise.  */
9134
9135 static void
9136 pro_epilogue_adjust_stack (rtx dest, rtx src, rtx offset,
9137                            int style, bool set_cfa)
9138 {
9139   struct machine_function *m = cfun->machine;
9140   rtx insn;
9141   bool add_frame_related_expr = false;
9142
9143   if (! TARGET_64BIT)
9144     insn = gen_pro_epilogue_adjust_stack_si_add (dest, src, offset);
9145   else if (x86_64_immediate_operand (offset, DImode))
9146     insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, offset);
9147   else
9148     {
9149       rtx tmp;
9150       /* r11 is used by indirect sibcall return as well, set before the
9151          epilogue and used after the epilogue.  */
9152       if (style)
9153         tmp = gen_rtx_REG (DImode, R11_REG);
9154       else
9155         {
9156           gcc_assert (src != hard_frame_pointer_rtx
9157                       && dest != hard_frame_pointer_rtx);
9158           tmp = hard_frame_pointer_rtx;
9159         }
9160       insn = emit_insn (gen_rtx_SET (DImode, tmp, offset));
9161       if (style < 0)
9162         add_frame_related_expr = true;
9163
9164       insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, tmp);
9165     }
9166
9167   insn = emit_insn (insn);
9168   if (style >= 0)
9169     ix86_add_queued_cfa_restore_notes (insn);
9170
9171   if (set_cfa)
9172     {
9173       rtx r;
9174
9175       gcc_assert (m->fs.cfa_reg == src);
9176       m->fs.cfa_offset += INTVAL (offset);
9177       m->fs.cfa_reg = dest;
9178
9179       r = gen_rtx_PLUS (Pmode, src, offset);
9180       r = gen_rtx_SET (VOIDmode, dest, r);
9181       add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
9182       RTX_FRAME_RELATED_P (insn) = 1;
9183     }
9184   else if (style < 0)
9185     {
9186       RTX_FRAME_RELATED_P (insn) = 1;
9187       if (add_frame_related_expr)
9188         {
9189           rtx r = gen_rtx_PLUS (Pmode, src, offset);
9190           r = gen_rtx_SET (VOIDmode, dest, r);
9191           add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
9192         }
9193     }
9194
9195   if (dest == stack_pointer_rtx)
9196     {
9197       HOST_WIDE_INT ooffset = m->fs.sp_offset;
9198       bool valid = m->fs.sp_valid;
9199
9200       if (src == hard_frame_pointer_rtx)
9201         {
9202           valid = m->fs.fp_valid;
9203           ooffset = m->fs.fp_offset;
9204         }
9205       else if (src == crtl->drap_reg)
9206         {
9207           valid = m->fs.drap_valid;
9208           ooffset = 0;
9209         }
9210       else
9211         {
9212           /* Else there are two possibilities: SP itself, which we set
9213              up as the default above.  Or EH_RETURN_STACKADJ_RTX, which is
9214              taken care of this by hand along the eh_return path.  */
9215           gcc_checking_assert (src == stack_pointer_rtx
9216                                || offset == const0_rtx);
9217         }
9218
9219       m->fs.sp_offset = ooffset - INTVAL (offset);
9220       m->fs.sp_valid = valid;
9221     }
9222 }
9223
9224 /* Find an available register to be used as dynamic realign argument
9225    pointer regsiter.  Such a register will be written in prologue and
9226    used in begin of body, so it must not be
9227         1. parameter passing register.
9228         2. GOT pointer.
9229    We reuse static-chain register if it is available.  Otherwise, we
9230    use DI for i386 and R13 for x86-64.  We chose R13 since it has
9231    shorter encoding.
9232
9233    Return: the regno of chosen register.  */
9234
9235 static unsigned int
9236 find_drap_reg (void)
9237 {
9238   tree decl = cfun->decl;
9239
9240   if (TARGET_64BIT)
9241     {
9242       /* Use R13 for nested function or function need static chain.
9243          Since function with tail call may use any caller-saved
9244          registers in epilogue, DRAP must not use caller-saved
9245          register in such case.  */
9246       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9247         return R13_REG;
9248
9249       return R10_REG;
9250     }
9251   else
9252     {
9253       /* Use DI for nested function or function need static chain.
9254          Since function with tail call may use any caller-saved
9255          registers in epilogue, DRAP must not use caller-saved
9256          register in such case.  */
9257       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9258         return DI_REG;
9259
9260       /* Reuse static chain register if it isn't used for parameter
9261          passing.  */
9262       if (ix86_function_regparm (TREE_TYPE (decl), decl) <= 2)
9263         {
9264           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl));
9265           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) == 0)
9266             return CX_REG;
9267         }
9268       return DI_REG;
9269     }
9270 }
9271
9272 /* Return minimum incoming stack alignment.  */
9273
9274 static unsigned int
9275 ix86_minimum_incoming_stack_boundary (bool sibcall)
9276 {
9277   unsigned int incoming_stack_boundary;
9278
9279   /* Prefer the one specified at command line. */
9280   if (ix86_user_incoming_stack_boundary)
9281     incoming_stack_boundary = ix86_user_incoming_stack_boundary;
9282   /* In 32bit, use MIN_STACK_BOUNDARY for incoming stack boundary
9283      if -mstackrealign is used, it isn't used for sibcall check and
9284      estimated stack alignment is 128bit.  */
9285   else if (!sibcall
9286            && !TARGET_64BIT
9287            && ix86_force_align_arg_pointer
9288            && crtl->stack_alignment_estimated == 128)
9289     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9290   else
9291     incoming_stack_boundary = ix86_default_incoming_stack_boundary;
9292
9293   /* Incoming stack alignment can be changed on individual functions
9294      via force_align_arg_pointer attribute.  We use the smallest
9295      incoming stack boundary.  */
9296   if (incoming_stack_boundary > MIN_STACK_BOUNDARY
9297       && lookup_attribute (ix86_force_align_arg_pointer_string,
9298                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
9299     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9300
9301   /* The incoming stack frame has to be aligned at least at
9302      parm_stack_boundary.  */
9303   if (incoming_stack_boundary < crtl->parm_stack_boundary)
9304     incoming_stack_boundary = crtl->parm_stack_boundary;
9305
9306   /* Stack at entrance of main is aligned by runtime.  We use the
9307      smallest incoming stack boundary. */
9308   if (incoming_stack_boundary > MAIN_STACK_BOUNDARY
9309       && DECL_NAME (current_function_decl)
9310       && MAIN_NAME_P (DECL_NAME (current_function_decl))
9311       && DECL_FILE_SCOPE_P (current_function_decl))
9312     incoming_stack_boundary = MAIN_STACK_BOUNDARY;
9313
9314   return incoming_stack_boundary;
9315 }
9316
9317 /* Update incoming stack boundary and estimated stack alignment.  */
9318
9319 static void
9320 ix86_update_stack_boundary (void)
9321 {
9322   ix86_incoming_stack_boundary
9323     = ix86_minimum_incoming_stack_boundary (false);
9324
9325   /* x86_64 vararg needs 16byte stack alignment for register save
9326      area.  */
9327   if (TARGET_64BIT
9328       && cfun->stdarg
9329       && crtl->stack_alignment_estimated < 128)
9330     crtl->stack_alignment_estimated = 128;
9331 }
9332
9333 /* Handle the TARGET_GET_DRAP_RTX hook.  Return NULL if no DRAP is
9334    needed or an rtx for DRAP otherwise.  */
9335
9336 static rtx
9337 ix86_get_drap_rtx (void)
9338 {
9339   if (ix86_force_drap || !ACCUMULATE_OUTGOING_ARGS)
9340     crtl->need_drap = true;
9341
9342   if (stack_realign_drap)
9343     {
9344       /* Assign DRAP to vDRAP and returns vDRAP */
9345       unsigned int regno = find_drap_reg ();
9346       rtx drap_vreg;
9347       rtx arg_ptr;
9348       rtx seq, insn;
9349
9350       arg_ptr = gen_rtx_REG (Pmode, regno);
9351       crtl->drap_reg = arg_ptr;
9352
9353       start_sequence ();
9354       drap_vreg = copy_to_reg (arg_ptr);
9355       seq = get_insns ();
9356       end_sequence ();
9357
9358       insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
9359       if (!optimize)
9360         {
9361           add_reg_note (insn, REG_CFA_SET_VDRAP, drap_vreg);
9362           RTX_FRAME_RELATED_P (insn) = 1;
9363         }
9364       return drap_vreg;
9365     }
9366   else
9367     return NULL;
9368 }
9369
9370 /* Handle the TARGET_INTERNAL_ARG_POINTER hook.  */
9371
9372 static rtx
9373 ix86_internal_arg_pointer (void)
9374 {
9375   return virtual_incoming_args_rtx;
9376 }
9377
9378 struct scratch_reg {
9379   rtx reg;
9380   bool saved;
9381 };
9382
9383 /* Return a short-lived scratch register for use on function entry.
9384    In 32-bit mode, it is valid only after the registers are saved
9385    in the prologue.  This register must be released by means of
9386    release_scratch_register_on_entry once it is dead.  */
9387
9388 static void
9389 get_scratch_register_on_entry (struct scratch_reg *sr)
9390 {
9391   int regno;
9392
9393   sr->saved = false;
9394
9395   if (TARGET_64BIT)
9396     {
9397       /* We always use R11 in 64-bit mode.  */
9398       regno = R11_REG;
9399     }
9400   else
9401     {
9402       tree decl = current_function_decl, fntype = TREE_TYPE (decl);
9403       bool fastcall_p
9404         = lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
9405       bool static_chain_p = DECL_STATIC_CHAIN (decl);
9406       int regparm = ix86_function_regparm (fntype, decl);
9407       int drap_regno
9408         = crtl->drap_reg ? REGNO (crtl->drap_reg) : INVALID_REGNUM;
9409
9410       /* 'fastcall' sets regparm to 2, uses ecx/edx for arguments and eax
9411           for the static chain register.  */
9412       if ((regparm < 1 || (fastcall_p && !static_chain_p))
9413           && drap_regno != AX_REG)
9414         regno = AX_REG;
9415       else if (regparm < 2 && drap_regno != DX_REG)
9416         regno = DX_REG;
9417       /* ecx is the static chain register.  */
9418       else if (regparm < 3 && !fastcall_p && !static_chain_p
9419                && drap_regno != CX_REG)
9420         regno = CX_REG;
9421       else if (ix86_save_reg (BX_REG, true))
9422         regno = BX_REG;
9423       /* esi is the static chain register.  */
9424       else if (!(regparm == 3 && static_chain_p)
9425                && ix86_save_reg (SI_REG, true))
9426         regno = SI_REG;
9427       else if (ix86_save_reg (DI_REG, true))
9428         regno = DI_REG;
9429       else
9430         {
9431           regno = (drap_regno == AX_REG ? DX_REG : AX_REG);
9432           sr->saved = true;
9433         }
9434     }
9435
9436   sr->reg = gen_rtx_REG (Pmode, regno);
9437   if (sr->saved)
9438     {
9439       rtx insn = emit_insn (gen_push (sr->reg));
9440       RTX_FRAME_RELATED_P (insn) = 1;
9441     }
9442 }
9443
9444 /* Release a scratch register obtained from the preceding function.  */
9445
9446 static void
9447 release_scratch_register_on_entry (struct scratch_reg *sr)
9448 {
9449   if (sr->saved)
9450     {
9451       rtx x, insn = emit_insn (gen_pop (sr->reg));
9452
9453       /* The RTX_FRAME_RELATED_P mechanism doesn't know about pop.  */
9454       RTX_FRAME_RELATED_P (insn) = 1;
9455       x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
9456       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
9457       add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
9458     }
9459 }
9460
9461 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
9462
9463 /* Emit code to adjust the stack pointer by SIZE bytes while probing it.  */
9464
9465 static void
9466 ix86_adjust_stack_and_probe (const HOST_WIDE_INT size)
9467 {
9468   /* We skip the probe for the first interval + a small dope of 4 words and
9469      probe that many bytes past the specified size to maintain a protection
9470      area at the botton of the stack.  */
9471   const int dope = 4 * UNITS_PER_WORD;
9472   rtx size_rtx = GEN_INT (size), last;
9473
9474   /* See if we have a constant small number of probes to generate.  If so,
9475      that's the easy case.  The run-time loop is made up of 11 insns in the
9476      generic case while the compile-time loop is made up of 3+2*(n-1) insns
9477      for n # of intervals.  */
9478   if (size <= 5 * PROBE_INTERVAL)
9479     {
9480       HOST_WIDE_INT i, adjust;
9481       bool first_probe = true;
9482
9483       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
9484          values of N from 1 until it exceeds SIZE.  If only one probe is
9485          needed, this will not generate any code.  Then adjust and probe
9486          to PROBE_INTERVAL + SIZE.  */
9487       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9488         {
9489           if (first_probe)
9490             {
9491               adjust = 2 * PROBE_INTERVAL + dope;
9492               first_probe = false;
9493             }
9494           else
9495             adjust = PROBE_INTERVAL;
9496
9497           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9498                                   plus_constant (stack_pointer_rtx, -adjust)));
9499           emit_stack_probe (stack_pointer_rtx);
9500         }
9501
9502       if (first_probe)
9503         adjust = size + PROBE_INTERVAL + dope;
9504       else
9505         adjust = size + PROBE_INTERVAL - i;
9506
9507       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9508                               plus_constant (stack_pointer_rtx, -adjust)));
9509       emit_stack_probe (stack_pointer_rtx);
9510
9511       /* Adjust back to account for the additional first interval.  */
9512       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9513                                      plus_constant (stack_pointer_rtx,
9514                                                     PROBE_INTERVAL + dope)));
9515     }
9516
9517   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9518      extra careful with variables wrapping around because we might be at
9519      the very top (or the very bottom) of the address space and we have
9520      to be able to handle this case properly; in particular, we use an
9521      equality test for the loop condition.  */
9522   else
9523     {
9524       HOST_WIDE_INT rounded_size;
9525       struct scratch_reg sr;
9526
9527       get_scratch_register_on_entry (&sr);
9528
9529
9530       /* Step 1: round SIZE to the previous multiple of the interval.  */
9531
9532       rounded_size = size & -PROBE_INTERVAL;
9533
9534
9535       /* Step 2: compute initial and final value of the loop counter.  */
9536
9537       /* SP = SP_0 + PROBE_INTERVAL.  */
9538       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9539                               plus_constant (stack_pointer_rtx,
9540                                              - (PROBE_INTERVAL + dope))));
9541
9542       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
9543       emit_move_insn (sr.reg, GEN_INT (-rounded_size));
9544       emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
9545                               gen_rtx_PLUS (Pmode, sr.reg,
9546                                             stack_pointer_rtx)));
9547
9548
9549       /* Step 3: the loop
9550
9551          while (SP != LAST_ADDR)
9552            {
9553              SP = SP + PROBE_INTERVAL
9554              probe at SP
9555            }
9556
9557          adjusts SP and probes to PROBE_INTERVAL + N * PROBE_INTERVAL for
9558          values of N from 1 until it is equal to ROUNDED_SIZE.  */
9559
9560       emit_insn (ix86_gen_adjust_stack_and_probe (sr.reg, sr.reg, size_rtx));
9561
9562
9563       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
9564          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
9565
9566       if (size != rounded_size)
9567         {
9568           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9569                                   plus_constant (stack_pointer_rtx,
9570                                                  rounded_size - size)));
9571           emit_stack_probe (stack_pointer_rtx);
9572         }
9573
9574       /* Adjust back to account for the additional first interval.  */
9575       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9576                                      plus_constant (stack_pointer_rtx,
9577                                                     PROBE_INTERVAL + dope)));
9578
9579       release_scratch_register_on_entry (&sr);
9580     }
9581
9582   gcc_assert (cfun->machine->fs.cfa_reg != stack_pointer_rtx);
9583
9584   /* Even if the stack pointer isn't the CFA register, we need to correctly
9585      describe the adjustments made to it, in particular differentiate the
9586      frame-related ones from the frame-unrelated ones.  */
9587   if (size > 0)
9588     {
9589       rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
9590       XVECEXP (expr, 0, 0)
9591         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9592                        plus_constant (stack_pointer_rtx, -size));
9593       XVECEXP (expr, 0, 1)
9594         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9595                        plus_constant (stack_pointer_rtx,
9596                                       PROBE_INTERVAL + dope + size));
9597       add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
9598       RTX_FRAME_RELATED_P (last) = 1;
9599
9600       cfun->machine->fs.sp_offset += size;
9601     }
9602
9603   /* Make sure nothing is scheduled before we are done.  */
9604   emit_insn (gen_blockage ());
9605 }
9606
9607 /* Adjust the stack pointer up to REG while probing it.  */
9608
9609 const char *
9610 output_adjust_stack_and_probe (rtx reg)
9611 {
9612   static int labelno = 0;
9613   char loop_lab[32], end_lab[32];
9614   rtx xops[2];
9615
9616   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9617   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9618
9619   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9620
9621   /* Jump to END_LAB if SP == LAST_ADDR.  */
9622   xops[0] = stack_pointer_rtx;
9623   xops[1] = reg;
9624   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9625   fputs ("\tje\t", asm_out_file);
9626   assemble_name_raw (asm_out_file, end_lab);
9627   fputc ('\n', asm_out_file);
9628
9629   /* SP = SP + PROBE_INTERVAL.  */
9630   xops[1] = GEN_INT (PROBE_INTERVAL);
9631   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9632
9633   /* Probe at SP.  */
9634   xops[1] = const0_rtx;
9635   output_asm_insn ("or%z0\t{%1, (%0)|DWORD PTR [%0], %1}", xops);
9636
9637   fprintf (asm_out_file, "\tjmp\t");
9638   assemble_name_raw (asm_out_file, loop_lab);
9639   fputc ('\n', asm_out_file);
9640
9641   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9642
9643   return "";
9644 }
9645
9646 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
9647    inclusive.  These are offsets from the current stack pointer.  */
9648
9649 static void
9650 ix86_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
9651 {
9652   /* See if we have a constant small number of probes to generate.  If so,
9653      that's the easy case.  The run-time loop is made up of 7 insns in the
9654      generic case while the compile-time loop is made up of n insns for n #
9655      of intervals.  */
9656   if (size <= 7 * PROBE_INTERVAL)
9657     {
9658       HOST_WIDE_INT i;
9659
9660       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
9661          it exceeds SIZE.  If only one probe is needed, this will not
9662          generate any code.  Then probe at FIRST + SIZE.  */
9663       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9664         emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + i)));
9665
9666       emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + size)));
9667     }
9668
9669   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9670      extra careful with variables wrapping around because we might be at
9671      the very top (or the very bottom) of the address space and we have
9672      to be able to handle this case properly; in particular, we use an
9673      equality test for the loop condition.  */
9674   else
9675     {
9676       HOST_WIDE_INT rounded_size, last;
9677       struct scratch_reg sr;
9678
9679       get_scratch_register_on_entry (&sr);
9680
9681
9682       /* Step 1: round SIZE to the previous multiple of the interval.  */
9683
9684       rounded_size = size & -PROBE_INTERVAL;
9685
9686
9687       /* Step 2: compute initial and final value of the loop counter.  */
9688
9689       /* TEST_OFFSET = FIRST.  */
9690       emit_move_insn (sr.reg, GEN_INT (-first));
9691
9692       /* LAST_OFFSET = FIRST + ROUNDED_SIZE.  */
9693       last = first + rounded_size;
9694
9695
9696       /* Step 3: the loop
9697
9698          while (TEST_ADDR != LAST_ADDR)
9699            {
9700              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
9701              probe at TEST_ADDR
9702            }
9703
9704          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
9705          until it is equal to ROUNDED_SIZE.  */
9706
9707       emit_insn (ix86_gen_probe_stack_range (sr.reg, sr.reg, GEN_INT (-last)));
9708
9709
9710       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
9711          that SIZE is equal to ROUNDED_SIZE.  */
9712
9713       if (size != rounded_size)
9714         emit_stack_probe (plus_constant (gen_rtx_PLUS (Pmode,
9715                                                        stack_pointer_rtx,
9716                                                        sr.reg),
9717                                          rounded_size - size));
9718
9719       release_scratch_register_on_entry (&sr);
9720     }
9721
9722   /* Make sure nothing is scheduled before we are done.  */
9723   emit_insn (gen_blockage ());
9724 }
9725
9726 /* Probe a range of stack addresses from REG to END, inclusive.  These are
9727    offsets from the current stack pointer.  */
9728
9729 const char *
9730 output_probe_stack_range (rtx reg, rtx end)
9731 {
9732   static int labelno = 0;
9733   char loop_lab[32], end_lab[32];
9734   rtx xops[3];
9735
9736   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9737   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9738
9739   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9740
9741   /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
9742   xops[0] = reg;
9743   xops[1] = end;
9744   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9745   fputs ("\tje\t", asm_out_file);
9746   assemble_name_raw (asm_out_file, end_lab);
9747   fputc ('\n', asm_out_file);
9748
9749   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
9750   xops[1] = GEN_INT (PROBE_INTERVAL);
9751   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9752
9753   /* Probe at TEST_ADDR.  */
9754   xops[0] = stack_pointer_rtx;
9755   xops[1] = reg;
9756   xops[2] = const0_rtx;
9757   output_asm_insn ("or%z0\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}", xops);
9758
9759   fprintf (asm_out_file, "\tjmp\t");
9760   assemble_name_raw (asm_out_file, loop_lab);
9761   fputc ('\n', asm_out_file);
9762
9763   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9764
9765   return "";
9766 }
9767
9768 /* Finalize stack_realign_needed flag, which will guide prologue/epilogue
9769    to be generated in correct form.  */
9770 static void
9771 ix86_finalize_stack_realign_flags (void)
9772 {
9773   /* Check if stack realign is really needed after reload, and
9774      stores result in cfun */
9775   unsigned int incoming_stack_boundary
9776     = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary
9777        ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary);
9778   unsigned int stack_realign = (incoming_stack_boundary
9779                                 < (current_function_is_leaf
9780                                    ? crtl->max_used_stack_slot_alignment
9781                                    : crtl->stack_alignment_needed));
9782
9783   if (crtl->stack_realign_finalized)
9784     {
9785       /* After stack_realign_needed is finalized, we can't no longer
9786          change it.  */
9787       gcc_assert (crtl->stack_realign_needed == stack_realign);
9788     }
9789   else
9790     {
9791       crtl->stack_realign_needed = stack_realign;
9792       crtl->stack_realign_finalized = true;
9793     }
9794 }
9795
9796 /* Expand the prologue into a bunch of separate insns.  */
9797
9798 void
9799 ix86_expand_prologue (void)
9800 {
9801   struct machine_function *m = cfun->machine;
9802   rtx insn, t;
9803   bool pic_reg_used;
9804   struct ix86_frame frame;
9805   HOST_WIDE_INT allocate;
9806   bool int_registers_saved;
9807
9808   ix86_finalize_stack_realign_flags ();
9809
9810   /* DRAP should not coexist with stack_realign_fp */
9811   gcc_assert (!(crtl->drap_reg && stack_realign_fp));
9812
9813   memset (&m->fs, 0, sizeof (m->fs));
9814
9815   /* Initialize CFA state for before the prologue.  */
9816   m->fs.cfa_reg = stack_pointer_rtx;
9817   m->fs.cfa_offset = INCOMING_FRAME_SP_OFFSET;
9818
9819   /* Track SP offset to the CFA.  We continue tracking this after we've
9820      swapped the CFA register away from SP.  In the case of re-alignment
9821      this is fudged; we're interested to offsets within the local frame.  */
9822   m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9823   m->fs.sp_valid = true;
9824
9825   ix86_compute_frame_layout (&frame);
9826
9827   if (!TARGET_64BIT && ix86_function_ms_hook_prologue (current_function_decl))
9828     {
9829       /* We should have already generated an error for any use of
9830          ms_hook on a nested function.  */
9831       gcc_checking_assert (!ix86_static_chain_on_stack);
9832
9833       /* Check if profiling is active and we shall use profiling before
9834          prologue variant. If so sorry.  */
9835       if (crtl->profile && flag_fentry != 0)
9836         sorry ("ms_hook_prologue attribute isn%'t compatible "
9837                "with -mfentry for 32-bit");
9838
9839       /* In ix86_asm_output_function_label we emitted:
9840          8b ff     movl.s %edi,%edi
9841          55        push   %ebp
9842          8b ec     movl.s %esp,%ebp
9843
9844          This matches the hookable function prologue in Win32 API
9845          functions in Microsoft Windows XP Service Pack 2 and newer.
9846          Wine uses this to enable Windows apps to hook the Win32 API
9847          functions provided by Wine.
9848
9849          What that means is that we've already set up the frame pointer.  */
9850
9851       if (frame_pointer_needed
9852           && !(crtl->drap_reg && crtl->stack_realign_needed))
9853         {
9854           rtx push, mov;
9855
9856           /* We've decided to use the frame pointer already set up.
9857              Describe this to the unwinder by pretending that both
9858              push and mov insns happen right here.
9859
9860              Putting the unwind info here at the end of the ms_hook
9861              is done so that we can make absolutely certain we get
9862              the required byte sequence at the start of the function,
9863              rather than relying on an assembler that can produce
9864              the exact encoding required.
9865
9866              However it does mean (in the unpatched case) that we have
9867              a 1 insn window where the asynchronous unwind info is
9868              incorrect.  However, if we placed the unwind info at
9869              its correct location we would have incorrect unwind info
9870              in the patched case.  Which is probably all moot since
9871              I don't expect Wine generates dwarf2 unwind info for the
9872              system libraries that use this feature.  */
9873
9874           insn = emit_insn (gen_blockage ());
9875
9876           push = gen_push (hard_frame_pointer_rtx);
9877           mov = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
9878                              stack_pointer_rtx);
9879           RTX_FRAME_RELATED_P (push) = 1;
9880           RTX_FRAME_RELATED_P (mov) = 1;
9881
9882           RTX_FRAME_RELATED_P (insn) = 1;
9883           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
9884                         gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, push, mov)));
9885
9886           /* Note that gen_push incremented m->fs.cfa_offset, even
9887              though we didn't emit the push insn here.  */
9888           m->fs.cfa_reg = hard_frame_pointer_rtx;
9889           m->fs.fp_offset = m->fs.cfa_offset;
9890           m->fs.fp_valid = true;
9891         }
9892       else
9893         {
9894           /* The frame pointer is not needed so pop %ebp again.
9895              This leaves us with a pristine state.  */
9896           emit_insn (gen_pop (hard_frame_pointer_rtx));
9897         }
9898     }
9899
9900   /* The first insn of a function that accepts its static chain on the
9901      stack is to push the register that would be filled in by a direct
9902      call.  This insn will be skipped by the trampoline.  */
9903   else if (ix86_static_chain_on_stack)
9904     {
9905       insn = emit_insn (gen_push (ix86_static_chain (cfun->decl, false)));
9906       emit_insn (gen_blockage ());
9907
9908       /* We don't want to interpret this push insn as a register save,
9909          only as a stack adjustment.  The real copy of the register as
9910          a save will be done later, if needed.  */
9911       t = plus_constant (stack_pointer_rtx, -UNITS_PER_WORD);
9912       t = gen_rtx_SET (VOIDmode, stack_pointer_rtx, t);
9913       add_reg_note (insn, REG_CFA_ADJUST_CFA, t);
9914       RTX_FRAME_RELATED_P (insn) = 1;
9915     }
9916
9917   /* Emit prologue code to adjust stack alignment and setup DRAP, in case
9918      of DRAP is needed and stack realignment is really needed after reload */
9919   if (stack_realign_drap)
9920     {
9921       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
9922
9923       /* Only need to push parameter pointer reg if it is caller saved.  */
9924       if (!call_used_regs[REGNO (crtl->drap_reg)])
9925         {
9926           /* Push arg pointer reg */
9927           insn = emit_insn (gen_push (crtl->drap_reg));
9928           RTX_FRAME_RELATED_P (insn) = 1;
9929         }
9930
9931       /* Grab the argument pointer.  */
9932       t = plus_constant (stack_pointer_rtx, m->fs.sp_offset);
9933       insn = emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
9934       RTX_FRAME_RELATED_P (insn) = 1;
9935       m->fs.cfa_reg = crtl->drap_reg;
9936       m->fs.cfa_offset = 0;
9937
9938       /* Align the stack.  */
9939       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
9940                                         stack_pointer_rtx,
9941                                         GEN_INT (-align_bytes)));
9942       RTX_FRAME_RELATED_P (insn) = 1;
9943
9944       /* Replicate the return address on the stack so that return
9945          address can be reached via (argp - 1) slot.  This is needed
9946          to implement macro RETURN_ADDR_RTX and intrinsic function
9947          expand_builtin_return_addr etc.  */
9948       t = plus_constant (crtl->drap_reg, -UNITS_PER_WORD);
9949       t = gen_frame_mem (Pmode, t);
9950       insn = emit_insn (gen_push (t));
9951       RTX_FRAME_RELATED_P (insn) = 1;
9952
9953       /* For the purposes of frame and register save area addressing,
9954          we've started over with a new frame.  */
9955       m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
9956       m->fs.realigned = true;
9957     }
9958
9959   if (frame_pointer_needed && !m->fs.fp_valid)
9960     {
9961       /* Note: AT&T enter does NOT have reversed args.  Enter is probably
9962          slower on all targets.  Also sdb doesn't like it.  */
9963       insn = emit_insn (gen_push (hard_frame_pointer_rtx));
9964       RTX_FRAME_RELATED_P (insn) = 1;
9965
9966       if (m->fs.sp_offset == frame.hard_frame_pointer_offset)
9967         {
9968           insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
9969           RTX_FRAME_RELATED_P (insn) = 1;
9970
9971           if (m->fs.cfa_reg == stack_pointer_rtx)
9972             m->fs.cfa_reg = hard_frame_pointer_rtx;
9973           m->fs.fp_offset = m->fs.sp_offset;
9974           m->fs.fp_valid = true;
9975         }
9976     }
9977
9978   int_registers_saved = (frame.nregs == 0);
9979
9980   if (!int_registers_saved)
9981     {
9982       /* If saving registers via PUSH, do so now.  */
9983       if (!frame.save_regs_using_mov)
9984         {
9985           ix86_emit_save_regs ();
9986           int_registers_saved = true;
9987           gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
9988         }
9989
9990       /* When using red zone we may start register saving before allocating
9991          the stack frame saving one cycle of the prologue.  However, avoid
9992          doing this if we have to probe the stack; at least on x86_64 the
9993          stack probe can turn into a call that clobbers a red zone location. */
9994       else if (ix86_using_red_zone ()
9995                && (! TARGET_STACK_PROBE
9996                    || frame.stack_pointer_offset < CHECK_STACK_LIMIT))
9997         {
9998           ix86_emit_save_regs_using_mov (frame.reg_save_offset);
9999           int_registers_saved = true;
10000         }
10001     }
10002
10003   if (stack_realign_fp)
10004     {
10005       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
10006       gcc_assert (align_bytes > MIN_STACK_BOUNDARY / BITS_PER_UNIT);
10007
10008       /* The computation of the size of the re-aligned stack frame means
10009          that we must allocate the size of the register save area before
10010          performing the actual alignment.  Otherwise we cannot guarantee
10011          that there's enough storage above the realignment point.  */
10012       if (m->fs.sp_offset != frame.sse_reg_save_offset)
10013         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10014                                    GEN_INT (m->fs.sp_offset
10015                                             - frame.sse_reg_save_offset),
10016                                    -1, false);
10017
10018       /* Align the stack.  */
10019       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
10020                                         stack_pointer_rtx,
10021                                         GEN_INT (-align_bytes)));
10022
10023       /* For the purposes of register save area addressing, the stack
10024          pointer is no longer valid.  As for the value of sp_offset,
10025          see ix86_compute_frame_layout, which we need to match in order
10026          to pass verification of stack_pointer_offset at the end.  */
10027       m->fs.sp_offset = (m->fs.sp_offset + align_bytes) & -align_bytes;
10028       m->fs.sp_valid = false;
10029     }
10030
10031   allocate = frame.stack_pointer_offset - m->fs.sp_offset;
10032
10033   if (flag_stack_usage_info)
10034     {
10035       /* We start to count from ARG_POINTER.  */
10036       HOST_WIDE_INT stack_size = frame.stack_pointer_offset;
10037
10038       /* If it was realigned, take into account the fake frame.  */
10039       if (stack_realign_drap)
10040         {
10041           if (ix86_static_chain_on_stack)
10042             stack_size += UNITS_PER_WORD;
10043
10044           if (!call_used_regs[REGNO (crtl->drap_reg)])
10045             stack_size += UNITS_PER_WORD;
10046
10047           /* This over-estimates by 1 minimal-stack-alignment-unit but
10048              mitigates that by counting in the new return address slot.  */
10049           current_function_dynamic_stack_size
10050             += crtl->stack_alignment_needed / BITS_PER_UNIT;
10051         }
10052
10053       current_function_static_stack_size = stack_size;
10054     }
10055
10056   /* The stack has already been decremented by the instruction calling us
10057      so probe if the size is non-negative to preserve the protection area.  */
10058   if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
10059     {
10060       /* We expect the registers to be saved when probes are used.  */
10061       gcc_assert (int_registers_saved);
10062
10063       if (STACK_CHECK_MOVING_SP)
10064         {
10065           ix86_adjust_stack_and_probe (allocate);
10066           allocate = 0;
10067         }
10068       else
10069         {
10070           HOST_WIDE_INT size = allocate;
10071
10072           if (TARGET_64BIT && size >= (HOST_WIDE_INT) 0x80000000)
10073             size = 0x80000000 - STACK_CHECK_PROTECT - 1;
10074
10075           if (TARGET_STACK_PROBE)
10076             ix86_emit_probe_stack_range (0, size + STACK_CHECK_PROTECT);
10077           else
10078             ix86_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
10079         }
10080     }
10081
10082   if (allocate == 0)
10083     ;
10084   else if (!ix86_target_stack_probe ()
10085            || frame.stack_pointer_offset < CHECK_STACK_LIMIT)
10086     {
10087       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10088                                  GEN_INT (-allocate), -1,
10089                                  m->fs.cfa_reg == stack_pointer_rtx);
10090     }
10091   else
10092     {
10093       rtx eax = gen_rtx_REG (Pmode, AX_REG);
10094       rtx r10 = NULL;
10095       rtx (*adjust_stack_insn)(rtx, rtx, rtx);
10096
10097       bool eax_live = false;
10098       bool r10_live = false;
10099
10100       if (TARGET_64BIT)
10101         r10_live = (DECL_STATIC_CHAIN (current_function_decl) != 0);
10102       if (!TARGET_64BIT_MS_ABI)
10103         eax_live = ix86_eax_live_at_start_p ();
10104
10105       if (eax_live)
10106         {
10107           emit_insn (gen_push (eax));
10108           allocate -= UNITS_PER_WORD;
10109         }
10110       if (r10_live)
10111         {
10112           r10 = gen_rtx_REG (Pmode, R10_REG);
10113           emit_insn (gen_push (r10));
10114           allocate -= UNITS_PER_WORD;
10115         }
10116
10117       emit_move_insn (eax, GEN_INT (allocate));
10118       emit_insn (ix86_gen_allocate_stack_worker (eax, eax));
10119
10120       /* Use the fact that AX still contains ALLOCATE.  */
10121       adjust_stack_insn = (TARGET_64BIT
10122                            ? gen_pro_epilogue_adjust_stack_di_sub
10123                            : gen_pro_epilogue_adjust_stack_si_sub);
10124
10125       insn = emit_insn (adjust_stack_insn (stack_pointer_rtx,
10126                                            stack_pointer_rtx, eax));
10127
10128       /* Note that SEH directives need to continue tracking the stack
10129          pointer even after the frame pointer has been set up.  */
10130       if (m->fs.cfa_reg == stack_pointer_rtx || TARGET_SEH)
10131         {
10132           if (m->fs.cfa_reg == stack_pointer_rtx)
10133             m->fs.cfa_offset += allocate;
10134
10135           RTX_FRAME_RELATED_P (insn) = 1;
10136           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
10137                         gen_rtx_SET (VOIDmode, stack_pointer_rtx,
10138                                      plus_constant (stack_pointer_rtx,
10139                                                     -allocate)));
10140         }
10141       m->fs.sp_offset += allocate;
10142
10143       if (r10_live && eax_live)
10144         {
10145           t = choose_baseaddr (m->fs.sp_offset - allocate);
10146           emit_move_insn (r10, gen_frame_mem (Pmode, t));
10147           t = choose_baseaddr (m->fs.sp_offset - allocate - UNITS_PER_WORD);
10148           emit_move_insn (eax, gen_frame_mem (Pmode, t));
10149         }
10150       else if (eax_live || r10_live)
10151         {
10152           t = choose_baseaddr (m->fs.sp_offset - allocate);
10153           emit_move_insn ((eax_live ? eax : r10), gen_frame_mem (Pmode, t));
10154         }
10155     }
10156   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
10157
10158   /* If we havn't already set up the frame pointer, do so now.  */
10159   if (frame_pointer_needed && !m->fs.fp_valid)
10160     {
10161       insn = ix86_gen_add3 (hard_frame_pointer_rtx, stack_pointer_rtx,
10162                             GEN_INT (frame.stack_pointer_offset
10163                                      - frame.hard_frame_pointer_offset));
10164       insn = emit_insn (insn);
10165       RTX_FRAME_RELATED_P (insn) = 1;
10166       add_reg_note (insn, REG_CFA_ADJUST_CFA, NULL);
10167
10168       if (m->fs.cfa_reg == stack_pointer_rtx)
10169         m->fs.cfa_reg = hard_frame_pointer_rtx;
10170       m->fs.fp_offset = frame.hard_frame_pointer_offset;
10171       m->fs.fp_valid = true;
10172     }
10173
10174   if (!int_registers_saved)
10175     ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10176   if (frame.nsseregs)
10177     ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
10178
10179   pic_reg_used = false;
10180   if (pic_offset_table_rtx
10181       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
10182           || crtl->profile))
10183     {
10184       unsigned int alt_pic_reg_used = ix86_select_alt_pic_regnum ();
10185
10186       if (alt_pic_reg_used != INVALID_REGNUM)
10187         SET_REGNO (pic_offset_table_rtx, alt_pic_reg_used);
10188
10189       pic_reg_used = true;
10190     }
10191
10192   if (pic_reg_used)
10193     {
10194       if (TARGET_64BIT)
10195         {
10196           if (ix86_cmodel == CM_LARGE_PIC)
10197             {
10198               rtx tmp_reg = gen_rtx_REG (DImode, R11_REG);
10199               rtx label = gen_label_rtx ();
10200               emit_label (label);
10201               LABEL_PRESERVE_P (label) = 1;
10202               gcc_assert (REGNO (pic_offset_table_rtx) != REGNO (tmp_reg));
10203               insn = emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx, label));
10204               insn = emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
10205               insn = emit_insn (gen_adddi3 (pic_offset_table_rtx,
10206                                             pic_offset_table_rtx, tmp_reg));
10207             }
10208           else
10209             insn = emit_insn (gen_set_got_rex64 (pic_offset_table_rtx));
10210         }
10211       else
10212         {
10213           insn = emit_insn (gen_set_got (pic_offset_table_rtx));
10214           RTX_FRAME_RELATED_P (insn) = 1;
10215           add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
10216         }
10217     }
10218
10219   /* In the pic_reg_used case, make sure that the got load isn't deleted
10220      when mcount needs it.  Blockage to avoid call movement across mcount
10221      call is emitted in generic code after the NOTE_INSN_PROLOGUE_END
10222      note.  */
10223   if (crtl->profile && !flag_fentry && pic_reg_used)
10224     emit_insn (gen_prologue_use (pic_offset_table_rtx));
10225
10226   if (crtl->drap_reg && !crtl->stack_realign_needed)
10227     {
10228       /* vDRAP is setup but after reload it turns out stack realign
10229          isn't necessary, here we will emit prologue to setup DRAP
10230          without stack realign adjustment */
10231       t = choose_baseaddr (0);
10232       emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
10233     }
10234
10235   /* Prevent instructions from being scheduled into register save push
10236      sequence when access to the redzone area is done through frame pointer.
10237      The offset between the frame pointer and the stack pointer is calculated
10238      relative to the value of the stack pointer at the end of the function
10239      prologue, and moving instructions that access redzone area via frame
10240      pointer inside push sequence violates this assumption.  */
10241   if (frame_pointer_needed && frame.red_zone_size)
10242     emit_insn (gen_memory_blockage ());
10243
10244   /* Emit cld instruction if stringops are used in the function.  */
10245   if (TARGET_CLD && ix86_current_function_needs_cld)
10246     emit_insn (gen_cld ());
10247
10248   /* SEH requires that the prologue end within 256 bytes of the start of
10249      the function.  Prevent instruction schedules that would extend that.  */
10250   if (TARGET_SEH)
10251     emit_insn (gen_blockage ());
10252 }
10253
10254 /* Emit code to restore REG using a POP insn.  */
10255
10256 static void
10257 ix86_emit_restore_reg_using_pop (rtx reg)
10258 {
10259   struct machine_function *m = cfun->machine;
10260   rtx insn = emit_insn (gen_pop (reg));
10261
10262   ix86_add_cfa_restore_note (insn, reg, m->fs.sp_offset);
10263   m->fs.sp_offset -= UNITS_PER_WORD;
10264
10265   if (m->fs.cfa_reg == crtl->drap_reg
10266       && REGNO (reg) == REGNO (crtl->drap_reg))
10267     {
10268       /* Previously we'd represented the CFA as an expression
10269          like *(%ebp - 8).  We've just popped that value from
10270          the stack, which means we need to reset the CFA to
10271          the drap register.  This will remain until we restore
10272          the stack pointer.  */
10273       add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10274       RTX_FRAME_RELATED_P (insn) = 1;
10275
10276       /* This means that the DRAP register is valid for addressing too.  */
10277       m->fs.drap_valid = true;
10278       return;
10279     }
10280
10281   if (m->fs.cfa_reg == stack_pointer_rtx)
10282     {
10283       rtx x = plus_constant (stack_pointer_rtx, UNITS_PER_WORD);
10284       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
10285       add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
10286       RTX_FRAME_RELATED_P (insn) = 1;
10287
10288       m->fs.cfa_offset -= UNITS_PER_WORD;
10289     }
10290
10291   /* When the frame pointer is the CFA, and we pop it, we are
10292      swapping back to the stack pointer as the CFA.  This happens
10293      for stack frames that don't allocate other data, so we assume
10294      the stack pointer is now pointing at the return address, i.e.
10295      the function entry state, which makes the offset be 1 word.  */
10296   if (reg == hard_frame_pointer_rtx)
10297     {
10298       m->fs.fp_valid = false;
10299       if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10300         {
10301           m->fs.cfa_reg = stack_pointer_rtx;
10302           m->fs.cfa_offset -= UNITS_PER_WORD;
10303
10304           add_reg_note (insn, REG_CFA_DEF_CFA,
10305                         gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10306                                       GEN_INT (m->fs.cfa_offset)));
10307           RTX_FRAME_RELATED_P (insn) = 1;
10308         }
10309     }
10310 }
10311
10312 /* Emit code to restore saved registers using POP insns.  */
10313
10314 static void
10315 ix86_emit_restore_regs_using_pop (void)
10316 {
10317   unsigned int regno;
10318
10319   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10320     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, false))
10321       ix86_emit_restore_reg_using_pop (gen_rtx_REG (Pmode, regno));
10322 }
10323
10324 /* Emit code and notes for the LEAVE instruction.  */
10325
10326 static void
10327 ix86_emit_leave (void)
10328 {
10329   struct machine_function *m = cfun->machine;
10330   rtx insn = emit_insn (ix86_gen_leave ());
10331
10332   ix86_add_queued_cfa_restore_notes (insn);
10333
10334   gcc_assert (m->fs.fp_valid);
10335   m->fs.sp_valid = true;
10336   m->fs.sp_offset = m->fs.fp_offset - UNITS_PER_WORD;
10337   m->fs.fp_valid = false;
10338
10339   if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10340     {
10341       m->fs.cfa_reg = stack_pointer_rtx;
10342       m->fs.cfa_offset = m->fs.sp_offset;
10343
10344       add_reg_note (insn, REG_CFA_DEF_CFA,
10345                     plus_constant (stack_pointer_rtx, m->fs.sp_offset));
10346       RTX_FRAME_RELATED_P (insn) = 1;
10347       ix86_add_cfa_restore_note (insn, hard_frame_pointer_rtx,
10348                                  m->fs.fp_offset);
10349     }
10350 }
10351
10352 /* Emit code to restore saved registers using MOV insns.
10353    First register is restored from CFA - CFA_OFFSET.  */
10354 static void
10355 ix86_emit_restore_regs_using_mov (HOST_WIDE_INT cfa_offset,
10356                                   bool maybe_eh_return)
10357 {
10358   struct machine_function *m = cfun->machine;
10359   unsigned int regno;
10360
10361   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10362     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10363       {
10364         rtx reg = gen_rtx_REG (Pmode, regno);
10365         rtx insn, mem;
10366
10367         mem = choose_baseaddr (cfa_offset);
10368         mem = gen_frame_mem (Pmode, mem);
10369         insn = emit_move_insn (reg, mem);
10370
10371         if (m->fs.cfa_reg == crtl->drap_reg && regno == REGNO (crtl->drap_reg))
10372           {
10373             /* Previously we'd represented the CFA as an expression
10374                like *(%ebp - 8).  We've just popped that value from
10375                the stack, which means we need to reset the CFA to
10376                the drap register.  This will remain until we restore
10377                the stack pointer.  */
10378             add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10379             RTX_FRAME_RELATED_P (insn) = 1;
10380
10381             /* This means that the DRAP register is valid for addressing.  */
10382             m->fs.drap_valid = true;
10383           }
10384         else
10385           ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10386
10387         cfa_offset -= UNITS_PER_WORD;
10388       }
10389 }
10390
10391 /* Emit code to restore saved registers using MOV insns.
10392    First register is restored from CFA - CFA_OFFSET.  */
10393 static void
10394 ix86_emit_restore_sse_regs_using_mov (HOST_WIDE_INT cfa_offset,
10395                                       bool maybe_eh_return)
10396 {
10397   unsigned int regno;
10398
10399   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10400     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10401       {
10402         rtx reg = gen_rtx_REG (V4SFmode, regno);
10403         rtx mem;
10404
10405         mem = choose_baseaddr (cfa_offset);
10406         mem = gen_rtx_MEM (V4SFmode, mem);
10407         set_mem_align (mem, 128);
10408         emit_move_insn (reg, mem);
10409
10410         ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10411
10412         cfa_offset -= 16;
10413       }
10414 }
10415
10416 /* Restore function stack, frame, and registers.  */
10417
10418 void
10419 ix86_expand_epilogue (int style)
10420 {
10421   struct machine_function *m = cfun->machine;
10422   struct machine_frame_state frame_state_save = m->fs;
10423   struct ix86_frame frame;
10424   bool restore_regs_via_mov;
10425   bool using_drap;
10426
10427   ix86_finalize_stack_realign_flags ();
10428   ix86_compute_frame_layout (&frame);
10429
10430   m->fs.sp_valid = (!frame_pointer_needed
10431                     || (current_function_sp_is_unchanging
10432                         && !stack_realign_fp));
10433   gcc_assert (!m->fs.sp_valid
10434               || m->fs.sp_offset == frame.stack_pointer_offset);
10435
10436   /* The FP must be valid if the frame pointer is present.  */
10437   gcc_assert (frame_pointer_needed == m->fs.fp_valid);
10438   gcc_assert (!m->fs.fp_valid
10439               || m->fs.fp_offset == frame.hard_frame_pointer_offset);
10440
10441   /* We must have *some* valid pointer to the stack frame.  */
10442   gcc_assert (m->fs.sp_valid || m->fs.fp_valid);
10443
10444   /* The DRAP is never valid at this point.  */
10445   gcc_assert (!m->fs.drap_valid);
10446
10447   /* See the comment about red zone and frame
10448      pointer usage in ix86_expand_prologue.  */
10449   if (frame_pointer_needed && frame.red_zone_size)
10450     emit_insn (gen_memory_blockage ());
10451
10452   using_drap = crtl->drap_reg && crtl->stack_realign_needed;
10453   gcc_assert (!using_drap || m->fs.cfa_reg == crtl->drap_reg);
10454
10455   /* Determine the CFA offset of the end of the red-zone.  */
10456   m->fs.red_zone_offset = 0;
10457   if (ix86_using_red_zone () && crtl->args.pops_args < 65536)
10458     {
10459       /* The red-zone begins below the return address.  */
10460       m->fs.red_zone_offset = RED_ZONE_SIZE + UNITS_PER_WORD;
10461
10462       /* When the register save area is in the aligned portion of
10463          the stack, determine the maximum runtime displacement that
10464          matches up with the aligned frame.  */
10465       if (stack_realign_drap)
10466         m->fs.red_zone_offset -= (crtl->stack_alignment_needed / BITS_PER_UNIT
10467                                   + UNITS_PER_WORD);
10468     }
10469
10470   /* Special care must be taken for the normal return case of a function
10471      using eh_return: the eax and edx registers are marked as saved, but
10472      not restored along this path.  Adjust the save location to match.  */
10473   if (crtl->calls_eh_return && style != 2)
10474     frame.reg_save_offset -= 2 * UNITS_PER_WORD;
10475
10476   /* EH_RETURN requires the use of moves to function properly.  */
10477   if (crtl->calls_eh_return)
10478     restore_regs_via_mov = true;
10479   /* SEH requires the use of pops to identify the epilogue.  */
10480   else if (TARGET_SEH)
10481     restore_regs_via_mov = false;
10482   /* If we're only restoring one register and sp is not valid then
10483      using a move instruction to restore the register since it's
10484      less work than reloading sp and popping the register.  */
10485   else if (!m->fs.sp_valid && frame.nregs <= 1)
10486     restore_regs_via_mov = true;
10487   else if (TARGET_EPILOGUE_USING_MOVE
10488            && cfun->machine->use_fast_prologue_epilogue
10489            && (frame.nregs > 1
10490                || m->fs.sp_offset != frame.reg_save_offset))
10491     restore_regs_via_mov = true;
10492   else if (frame_pointer_needed
10493            && !frame.nregs
10494            && m->fs.sp_offset != frame.reg_save_offset)
10495     restore_regs_via_mov = true;
10496   else if (frame_pointer_needed
10497            && TARGET_USE_LEAVE
10498            && cfun->machine->use_fast_prologue_epilogue
10499            && frame.nregs == 1)
10500     restore_regs_via_mov = true;
10501   else
10502     restore_regs_via_mov = false;
10503
10504   if (restore_regs_via_mov || frame.nsseregs)
10505     {
10506       /* Ensure that the entire register save area is addressable via
10507          the stack pointer, if we will restore via sp.  */
10508       if (TARGET_64BIT
10509           && m->fs.sp_offset > 0x7fffffff
10510           && !(m->fs.fp_valid || m->fs.drap_valid)
10511           && (frame.nsseregs + frame.nregs) != 0)
10512         {
10513           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10514                                      GEN_INT (m->fs.sp_offset
10515                                               - frame.sse_reg_save_offset),
10516                                      style,
10517                                      m->fs.cfa_reg == stack_pointer_rtx);
10518         }
10519     }
10520
10521   /* If there are any SSE registers to restore, then we have to do it
10522      via moves, since there's obviously no pop for SSE regs.  */
10523   if (frame.nsseregs)
10524     ix86_emit_restore_sse_regs_using_mov (frame.sse_reg_save_offset,
10525                                           style == 2);
10526
10527   if (restore_regs_via_mov)
10528     {
10529       rtx t;
10530
10531       if (frame.nregs)
10532         ix86_emit_restore_regs_using_mov (frame.reg_save_offset, style == 2);
10533
10534       /* eh_return epilogues need %ecx added to the stack pointer.  */
10535       if (style == 2)
10536         {
10537           rtx insn, sa = EH_RETURN_STACKADJ_RTX;
10538
10539           /* Stack align doesn't work with eh_return.  */
10540           gcc_assert (!stack_realign_drap);
10541           /* Neither does regparm nested functions.  */
10542           gcc_assert (!ix86_static_chain_on_stack);
10543
10544           if (frame_pointer_needed)
10545             {
10546               t = gen_rtx_PLUS (Pmode, hard_frame_pointer_rtx, sa);
10547               t = plus_constant (t, m->fs.fp_offset - UNITS_PER_WORD);
10548               emit_insn (gen_rtx_SET (VOIDmode, sa, t));
10549
10550               t = gen_frame_mem (Pmode, hard_frame_pointer_rtx);
10551               insn = emit_move_insn (hard_frame_pointer_rtx, t);
10552
10553               /* Note that we use SA as a temporary CFA, as the return
10554                  address is at the proper place relative to it.  We
10555                  pretend this happens at the FP restore insn because
10556                  prior to this insn the FP would be stored at the wrong
10557                  offset relative to SA, and after this insn we have no
10558                  other reasonable register to use for the CFA.  We don't
10559                  bother resetting the CFA to the SP for the duration of
10560                  the return insn.  */
10561               add_reg_note (insn, REG_CFA_DEF_CFA,
10562                             plus_constant (sa, UNITS_PER_WORD));
10563               ix86_add_queued_cfa_restore_notes (insn);
10564               add_reg_note (insn, REG_CFA_RESTORE, hard_frame_pointer_rtx);
10565               RTX_FRAME_RELATED_P (insn) = 1;
10566
10567               m->fs.cfa_reg = sa;
10568               m->fs.cfa_offset = UNITS_PER_WORD;
10569               m->fs.fp_valid = false;
10570
10571               pro_epilogue_adjust_stack (stack_pointer_rtx, sa,
10572                                          const0_rtx, style, false);
10573             }
10574           else
10575             {
10576               t = gen_rtx_PLUS (Pmode, stack_pointer_rtx, sa);
10577               t = plus_constant (t, m->fs.sp_offset - UNITS_PER_WORD);
10578               insn = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx, t));
10579               ix86_add_queued_cfa_restore_notes (insn);
10580
10581               gcc_assert (m->fs.cfa_reg == stack_pointer_rtx);
10582               if (m->fs.cfa_offset != UNITS_PER_WORD)
10583                 {
10584                   m->fs.cfa_offset = UNITS_PER_WORD;
10585                   add_reg_note (insn, REG_CFA_DEF_CFA,
10586                                 plus_constant (stack_pointer_rtx,
10587                                                UNITS_PER_WORD));
10588                   RTX_FRAME_RELATED_P (insn) = 1;
10589                 }
10590             }
10591           m->fs.sp_offset = UNITS_PER_WORD;
10592           m->fs.sp_valid = true;
10593         }
10594     }
10595   else
10596     {
10597       /* SEH requires that the function end with (1) a stack adjustment
10598          if necessary, (2) a sequence of pops, and (3) a return or
10599          jump instruction.  Prevent insns from the function body from
10600          being scheduled into this sequence.  */
10601       if (TARGET_SEH)
10602         {
10603           /* Prevent a catch region from being adjacent to the standard
10604              epilogue sequence.  Unfortuantely crtl->uses_eh_lsda nor
10605              several other flags that would be interesting to test are
10606              not yet set up.  */
10607           if (flag_non_call_exceptions)
10608             emit_insn (gen_nops (const1_rtx));
10609           else
10610             emit_insn (gen_blockage ());
10611         }
10612
10613       /* First step is to deallocate the stack frame so that we can
10614          pop the registers.  */
10615       if (!m->fs.sp_valid)
10616         {
10617           pro_epilogue_adjust_stack (stack_pointer_rtx, hard_frame_pointer_rtx,
10618                                      GEN_INT (m->fs.fp_offset
10619                                               - frame.reg_save_offset),
10620                                      style, false);
10621         }
10622       else if (m->fs.sp_offset != frame.reg_save_offset)
10623         {
10624           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10625                                      GEN_INT (m->fs.sp_offset
10626                                               - frame.reg_save_offset),
10627                                      style,
10628                                      m->fs.cfa_reg == stack_pointer_rtx);
10629         }
10630
10631       ix86_emit_restore_regs_using_pop ();
10632     }
10633
10634   /* If we used a stack pointer and haven't already got rid of it,
10635      then do so now.  */
10636   if (m->fs.fp_valid)
10637     {
10638       /* If the stack pointer is valid and pointing at the frame
10639          pointer store address, then we only need a pop.  */
10640       if (m->fs.sp_valid && m->fs.sp_offset == frame.hfp_save_offset)
10641         ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10642       /* Leave results in shorter dependency chains on CPUs that are
10643          able to grok it fast.  */
10644       else if (TARGET_USE_LEAVE
10645                || optimize_function_for_size_p (cfun)
10646                || !cfun->machine->use_fast_prologue_epilogue)
10647         ix86_emit_leave ();
10648       else
10649         {
10650           pro_epilogue_adjust_stack (stack_pointer_rtx,
10651                                      hard_frame_pointer_rtx,
10652                                      const0_rtx, style, !using_drap);
10653           ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10654         }
10655     }
10656
10657   if (using_drap)
10658     {
10659       int param_ptr_offset = UNITS_PER_WORD;
10660       rtx insn;
10661
10662       gcc_assert (stack_realign_drap);
10663
10664       if (ix86_static_chain_on_stack)
10665         param_ptr_offset += UNITS_PER_WORD;
10666       if (!call_used_regs[REGNO (crtl->drap_reg)])
10667         param_ptr_offset += UNITS_PER_WORD;
10668
10669       insn = emit_insn (gen_rtx_SET
10670                         (VOIDmode, stack_pointer_rtx,
10671                          gen_rtx_PLUS (Pmode,
10672                                        crtl->drap_reg,
10673                                        GEN_INT (-param_ptr_offset))));
10674       m->fs.cfa_reg = stack_pointer_rtx;
10675       m->fs.cfa_offset = param_ptr_offset;
10676       m->fs.sp_offset = param_ptr_offset;
10677       m->fs.realigned = false;
10678
10679       add_reg_note (insn, REG_CFA_DEF_CFA,
10680                     gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10681                                   GEN_INT (param_ptr_offset)));
10682       RTX_FRAME_RELATED_P (insn) = 1;
10683
10684       if (!call_used_regs[REGNO (crtl->drap_reg)])
10685         ix86_emit_restore_reg_using_pop (crtl->drap_reg);
10686     }
10687
10688   /* At this point the stack pointer must be valid, and we must have
10689      restored all of the registers.  We may not have deallocated the
10690      entire stack frame.  We've delayed this until now because it may
10691      be possible to merge the local stack deallocation with the
10692      deallocation forced by ix86_static_chain_on_stack.   */
10693   gcc_assert (m->fs.sp_valid);
10694   gcc_assert (!m->fs.fp_valid);
10695   gcc_assert (!m->fs.realigned);
10696   if (m->fs.sp_offset != UNITS_PER_WORD)
10697     {
10698       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10699                                  GEN_INT (m->fs.sp_offset - UNITS_PER_WORD),
10700                                  style, true);
10701     }
10702
10703   /* Sibcall epilogues don't want a return instruction.  */
10704   if (style == 0)
10705     {
10706       m->fs = frame_state_save;
10707       return;
10708     }
10709
10710   /* Emit vzeroupper if needed.  */
10711   if (TARGET_VZEROUPPER
10712       && !TREE_THIS_VOLATILE (cfun->decl)
10713       && !cfun->machine->caller_return_avx256_p)
10714     emit_insn (gen_avx_vzeroupper (GEN_INT (call_no_avx256)));
10715
10716   if (crtl->args.pops_args && crtl->args.size)
10717     {
10718       rtx popc = GEN_INT (crtl->args.pops_args);
10719
10720       /* i386 can only pop 64K bytes.  If asked to pop more, pop return
10721          address, do explicit add, and jump indirectly to the caller.  */
10722
10723       if (crtl->args.pops_args >= 65536)
10724         {
10725           rtx ecx = gen_rtx_REG (SImode, CX_REG);
10726           rtx insn;
10727
10728           /* There is no "pascal" calling convention in any 64bit ABI.  */
10729           gcc_assert (!TARGET_64BIT);
10730
10731           insn = emit_insn (gen_pop (ecx));
10732           m->fs.cfa_offset -= UNITS_PER_WORD;
10733           m->fs.sp_offset -= UNITS_PER_WORD;
10734
10735           add_reg_note (insn, REG_CFA_ADJUST_CFA,
10736                         copy_rtx (XVECEXP (PATTERN (insn), 0, 1)));
10737           add_reg_note (insn, REG_CFA_REGISTER,
10738                         gen_rtx_SET (VOIDmode, ecx, pc_rtx));
10739           RTX_FRAME_RELATED_P (insn) = 1;
10740
10741           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10742                                      popc, -1, true);
10743           emit_jump_insn (gen_return_indirect_internal (ecx));
10744         }
10745       else
10746         emit_jump_insn (gen_return_pop_internal (popc));
10747     }
10748   else
10749     emit_jump_insn (gen_return_internal ());
10750
10751   /* Restore the state back to the state from the prologue,
10752      so that it's correct for the next epilogue.  */
10753   m->fs = frame_state_save;
10754 }
10755
10756 /* Reset from the function's potential modifications.  */
10757
10758 static void
10759 ix86_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
10760                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
10761 {
10762   if (pic_offset_table_rtx)
10763     SET_REGNO (pic_offset_table_rtx, REAL_PIC_OFFSET_TABLE_REGNUM);
10764 #if TARGET_MACHO
10765   /* Mach-O doesn't support labels at the end of objects, so if
10766      it looks like we might want one, insert a NOP.  */
10767   {
10768     rtx insn = get_last_insn ();
10769     while (insn
10770            && NOTE_P (insn)
10771            && NOTE_KIND (insn) != NOTE_INSN_DELETED_LABEL)
10772       insn = PREV_INSN (insn);
10773     if (insn
10774         && (LABEL_P (insn)
10775             || (NOTE_P (insn)
10776                 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))
10777       fputs ("\tnop\n", file);
10778   }
10779 #endif
10780
10781 }
10782
10783 /* Return a scratch register to use in the split stack prologue.  The
10784    split stack prologue is used for -fsplit-stack.  It is the first
10785    instructions in the function, even before the regular prologue.
10786    The scratch register can be any caller-saved register which is not
10787    used for parameters or for the static chain.  */
10788
10789 static unsigned int
10790 split_stack_prologue_scratch_regno (void)
10791 {
10792   if (TARGET_64BIT)
10793     return R11_REG;
10794   else
10795     {
10796       bool is_fastcall;
10797       int regparm;
10798
10799       is_fastcall = (lookup_attribute ("fastcall",
10800                                        TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl)))
10801                      != NULL);
10802       regparm = ix86_function_regparm (TREE_TYPE (cfun->decl), cfun->decl);
10803
10804       if (is_fastcall)
10805         {
10806           if (DECL_STATIC_CHAIN (cfun->decl))
10807             {
10808               sorry ("-fsplit-stack does not support fastcall with "
10809                      "nested function");
10810               return INVALID_REGNUM;
10811             }
10812           return AX_REG;
10813         }
10814       else if (regparm < 3)
10815         {
10816           if (!DECL_STATIC_CHAIN (cfun->decl))
10817             return CX_REG;
10818           else
10819             {
10820               if (regparm >= 2)
10821                 {
10822                   sorry ("-fsplit-stack does not support 2 register "
10823                          " parameters for a nested function");
10824                   return INVALID_REGNUM;
10825                 }
10826               return DX_REG;
10827             }
10828         }
10829       else
10830         {
10831           /* FIXME: We could make this work by pushing a register
10832              around the addition and comparison.  */
10833           sorry ("-fsplit-stack does not support 3 register parameters");
10834           return INVALID_REGNUM;
10835         }
10836     }
10837 }
10838
10839 /* A SYMBOL_REF for the function which allocates new stackspace for
10840    -fsplit-stack.  */
10841
10842 static GTY(()) rtx split_stack_fn;
10843
10844 /* A SYMBOL_REF for the more stack function when using the large
10845    model.  */
10846
10847 static GTY(()) rtx split_stack_fn_large;
10848
10849 /* Handle -fsplit-stack.  These are the first instructions in the
10850    function, even before the regular prologue.  */
10851
10852 void
10853 ix86_expand_split_stack_prologue (void)
10854 {
10855   struct ix86_frame frame;
10856   HOST_WIDE_INT allocate;
10857   unsigned HOST_WIDE_INT args_size;
10858   rtx label, limit, current, jump_insn, allocate_rtx, call_insn, call_fusage;
10859   rtx scratch_reg = NULL_RTX;
10860   rtx varargs_label = NULL_RTX;
10861   rtx fn;
10862
10863   gcc_assert (flag_split_stack && reload_completed);
10864
10865   ix86_finalize_stack_realign_flags ();
10866   ix86_compute_frame_layout (&frame);
10867   allocate = frame.stack_pointer_offset - INCOMING_FRAME_SP_OFFSET;
10868
10869   /* This is the label we will branch to if we have enough stack
10870      space.  We expect the basic block reordering pass to reverse this
10871      branch if optimizing, so that we branch in the unlikely case.  */
10872   label = gen_label_rtx ();
10873
10874   /* We need to compare the stack pointer minus the frame size with
10875      the stack boundary in the TCB.  The stack boundary always gives
10876      us SPLIT_STACK_AVAILABLE bytes, so if we need less than that we
10877      can compare directly.  Otherwise we need to do an addition.  */
10878
10879   limit = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
10880                           UNSPEC_STACK_CHECK);
10881   limit = gen_rtx_CONST (Pmode, limit);
10882   limit = gen_rtx_MEM (Pmode, limit);
10883   if (allocate < SPLIT_STACK_AVAILABLE)
10884     current = stack_pointer_rtx;
10885   else
10886     {
10887       unsigned int scratch_regno;
10888       rtx offset;
10889
10890       /* We need a scratch register to hold the stack pointer minus
10891          the required frame size.  Since this is the very start of the
10892          function, the scratch register can be any caller-saved
10893          register which is not used for parameters.  */
10894       offset = GEN_INT (- allocate);
10895       scratch_regno = split_stack_prologue_scratch_regno ();
10896       if (scratch_regno == INVALID_REGNUM)
10897         return;
10898       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
10899       if (!TARGET_64BIT || x86_64_immediate_operand (offset, Pmode))
10900         {
10901           /* We don't use ix86_gen_add3 in this case because it will
10902              want to split to lea, but when not optimizing the insn
10903              will not be split after this point.  */
10904           emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
10905                                   gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10906                                                 offset)));
10907         }
10908       else
10909         {
10910           emit_move_insn (scratch_reg, offset);
10911           emit_insn (gen_adddi3 (scratch_reg, scratch_reg,
10912                                  stack_pointer_rtx));
10913         }
10914       current = scratch_reg;
10915     }
10916
10917   ix86_expand_branch (GEU, current, limit, label);
10918   jump_insn = get_last_insn ();
10919   JUMP_LABEL (jump_insn) = label;
10920
10921   /* Mark the jump as very likely to be taken.  */
10922   add_reg_note (jump_insn, REG_BR_PROB,
10923                 GEN_INT (REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100));
10924
10925   if (split_stack_fn == NULL_RTX)
10926     split_stack_fn = gen_rtx_SYMBOL_REF (Pmode, "__morestack");
10927   fn = split_stack_fn;
10928
10929   /* Get more stack space.  We pass in the desired stack space and the
10930      size of the arguments to copy to the new stack.  In 32-bit mode
10931      we push the parameters; __morestack will return on a new stack
10932      anyhow.  In 64-bit mode we pass the parameters in r10 and
10933      r11.  */
10934   allocate_rtx = GEN_INT (allocate);
10935   args_size = crtl->args.size >= 0 ? crtl->args.size : 0;
10936   call_fusage = NULL_RTX;
10937   if (TARGET_64BIT)
10938     {
10939       rtx reg10, reg11;
10940
10941       reg10 = gen_rtx_REG (Pmode, R10_REG);
10942       reg11 = gen_rtx_REG (Pmode, R11_REG);
10943
10944       /* If this function uses a static chain, it will be in %r10.
10945          Preserve it across the call to __morestack.  */
10946       if (DECL_STATIC_CHAIN (cfun->decl))
10947         {
10948           rtx rax;
10949
10950           rax = gen_rtx_REG (Pmode, AX_REG);
10951           emit_move_insn (rax, reg10);
10952           use_reg (&call_fusage, rax);
10953         }
10954
10955       if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
10956         {
10957           HOST_WIDE_INT argval;
10958
10959           /* When using the large model we need to load the address
10960              into a register, and we've run out of registers.  So we
10961              switch to a different calling convention, and we call a
10962              different function: __morestack_large.  We pass the
10963              argument size in the upper 32 bits of r10 and pass the
10964              frame size in the lower 32 bits.  */
10965           gcc_assert ((allocate & (HOST_WIDE_INT) 0xffffffff) == allocate);
10966           gcc_assert ((args_size & 0xffffffff) == args_size);
10967
10968           if (split_stack_fn_large == NULL_RTX)
10969             split_stack_fn_large =
10970               gen_rtx_SYMBOL_REF (Pmode, "__morestack_large_model");
10971
10972           if (ix86_cmodel == CM_LARGE_PIC)
10973             {
10974               rtx label, x;
10975
10976               label = gen_label_rtx ();
10977               emit_label (label);
10978               LABEL_PRESERVE_P (label) = 1;
10979               emit_insn (gen_set_rip_rex64 (reg10, label));
10980               emit_insn (gen_set_got_offset_rex64 (reg11, label));
10981               emit_insn (gen_adddi3 (reg10, reg10, reg11));
10982               x = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, split_stack_fn_large),
10983                                   UNSPEC_GOT);
10984               x = gen_rtx_CONST (Pmode, x);
10985               emit_move_insn (reg11, x);
10986               x = gen_rtx_PLUS (Pmode, reg10, reg11);
10987               x = gen_const_mem (Pmode, x);
10988               emit_move_insn (reg11, x);
10989             }
10990           else
10991             emit_move_insn (reg11, split_stack_fn_large);
10992
10993           fn = reg11;
10994
10995           argval = ((args_size << 16) << 16) + allocate;
10996           emit_move_insn (reg10, GEN_INT (argval));
10997         }
10998       else
10999         {
11000           emit_move_insn (reg10, allocate_rtx);
11001           emit_move_insn (reg11, GEN_INT (args_size));
11002           use_reg (&call_fusage, reg11);
11003         }
11004
11005       use_reg (&call_fusage, reg10);
11006     }
11007   else
11008     {
11009       emit_insn (gen_push (GEN_INT (args_size)));
11010       emit_insn (gen_push (allocate_rtx));
11011     }
11012   call_insn = ix86_expand_call (NULL_RTX, gen_rtx_MEM (QImode, fn),
11013                                 GEN_INT (UNITS_PER_WORD), constm1_rtx,
11014                                 NULL_RTX, false);
11015   add_function_usage_to (call_insn, call_fusage);
11016
11017   /* In order to make call/return prediction work right, we now need
11018      to execute a return instruction.  See
11019      libgcc/config/i386/morestack.S for the details on how this works.
11020
11021      For flow purposes gcc must not see this as a return
11022      instruction--we need control flow to continue at the subsequent
11023      label.  Therefore, we use an unspec.  */
11024   gcc_assert (crtl->args.pops_args < 65536);
11025   emit_insn (gen_split_stack_return (GEN_INT (crtl->args.pops_args)));
11026
11027   /* If we are in 64-bit mode and this function uses a static chain,
11028      we saved %r10 in %rax before calling _morestack.  */
11029   if (TARGET_64BIT && DECL_STATIC_CHAIN (cfun->decl))
11030     emit_move_insn (gen_rtx_REG (Pmode, R10_REG),
11031                     gen_rtx_REG (Pmode, AX_REG));
11032
11033   /* If this function calls va_start, we need to store a pointer to
11034      the arguments on the old stack, because they may not have been
11035      all copied to the new stack.  At this point the old stack can be
11036      found at the frame pointer value used by __morestack, because
11037      __morestack has set that up before calling back to us.  Here we
11038      store that pointer in a scratch register, and in
11039      ix86_expand_prologue we store the scratch register in a stack
11040      slot.  */
11041   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11042     {
11043       unsigned int scratch_regno;
11044       rtx frame_reg;
11045       int words;
11046
11047       scratch_regno = split_stack_prologue_scratch_regno ();
11048       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
11049       frame_reg = gen_rtx_REG (Pmode, BP_REG);
11050
11051       /* 64-bit:
11052          fp -> old fp value
11053                return address within this function
11054                return address of caller of this function
11055                stack arguments
11056          So we add three words to get to the stack arguments.
11057
11058          32-bit:
11059          fp -> old fp value
11060                return address within this function
11061                first argument to __morestack
11062                second argument to __morestack
11063                return address of caller of this function
11064                stack arguments
11065          So we add five words to get to the stack arguments.
11066       */
11067       words = TARGET_64BIT ? 3 : 5;
11068       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11069                               gen_rtx_PLUS (Pmode, frame_reg,
11070                                             GEN_INT (words * UNITS_PER_WORD))));
11071
11072       varargs_label = gen_label_rtx ();
11073       emit_jump_insn (gen_jump (varargs_label));
11074       JUMP_LABEL (get_last_insn ()) = varargs_label;
11075
11076       emit_barrier ();
11077     }
11078
11079   emit_label (label);
11080   LABEL_NUSES (label) = 1;
11081
11082   /* If this function calls va_start, we now have to set the scratch
11083      register for the case where we do not call __morestack.  In this
11084      case we need to set it based on the stack pointer.  */
11085   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11086     {
11087       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11088                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
11089                                             GEN_INT (UNITS_PER_WORD))));
11090
11091       emit_label (varargs_label);
11092       LABEL_NUSES (varargs_label) = 1;
11093     }
11094 }
11095
11096 /* We may have to tell the dataflow pass that the split stack prologue
11097    is initializing a scratch register.  */
11098
11099 static void
11100 ix86_live_on_entry (bitmap regs)
11101 {
11102   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11103     {
11104       gcc_assert (flag_split_stack);
11105       bitmap_set_bit (regs, split_stack_prologue_scratch_regno ());
11106     }
11107 }
11108 \f
11109 /* Determine if op is suitable SUBREG RTX for address.  */
11110
11111 static bool
11112 ix86_address_subreg_operand (rtx op)
11113 {
11114   enum machine_mode mode;
11115
11116   if (!REG_P (op))
11117     return false;
11118
11119   mode = GET_MODE (op);
11120
11121   if (GET_MODE_CLASS (mode) != MODE_INT)
11122     return false;
11123
11124   /* Don't allow SUBREGs that span more than a word.  It can lead to spill
11125      failures when the register is one word out of a two word structure.  */
11126   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
11127     return false;
11128
11129   /* Allow only SUBREGs of non-eliminable hard registers.  */
11130   return register_no_elim_operand (op, mode);
11131 }
11132
11133 /* Extract the parts of an RTL expression that is a valid memory address
11134    for an instruction.  Return 0 if the structure of the address is
11135    grossly off.  Return -1 if the address contains ASHIFT, so it is not
11136    strictly valid, but still used for computing length of lea instruction.  */
11137
11138 int
11139 ix86_decompose_address (rtx addr, struct ix86_address *out)
11140 {
11141   rtx base = NULL_RTX, index = NULL_RTX, disp = NULL_RTX;
11142   rtx base_reg, index_reg;
11143   HOST_WIDE_INT scale = 1;
11144   rtx scale_rtx = NULL_RTX;
11145   rtx tmp;
11146   int retval = 1;
11147   enum ix86_address_seg seg = SEG_DEFAULT;
11148
11149   if (REG_P (addr))
11150     base = addr;
11151   else if (GET_CODE (addr) == SUBREG)
11152     {
11153       if (ix86_address_subreg_operand (SUBREG_REG (addr)))
11154         base = addr;
11155       else
11156         return 0;
11157     }
11158   else if (GET_CODE (addr) == PLUS)
11159     {
11160       rtx addends[4], op;
11161       int n = 0, i;
11162
11163       op = addr;
11164       do
11165         {
11166           if (n >= 4)
11167             return 0;
11168           addends[n++] = XEXP (op, 1);
11169           op = XEXP (op, 0);
11170         }
11171       while (GET_CODE (op) == PLUS);
11172       if (n >= 4)
11173         return 0;
11174       addends[n] = op;
11175
11176       for (i = n; i >= 0; --i)
11177         {
11178           op = addends[i];
11179           switch (GET_CODE (op))
11180             {
11181             case MULT:
11182               if (index)
11183                 return 0;
11184               index = XEXP (op, 0);
11185               scale_rtx = XEXP (op, 1);
11186               break;
11187
11188             case ASHIFT:
11189               if (index)
11190                 return 0;
11191               index = XEXP (op, 0);
11192               tmp = XEXP (op, 1);
11193               if (!CONST_INT_P (tmp))
11194                 return 0;
11195               scale = INTVAL (tmp);
11196               if ((unsigned HOST_WIDE_INT) scale > 3)
11197                 return 0;
11198               scale = 1 << scale;
11199               break;
11200
11201             case UNSPEC:
11202               if (XINT (op, 1) == UNSPEC_TP
11203                   && TARGET_TLS_DIRECT_SEG_REFS
11204                   && seg == SEG_DEFAULT)
11205                 seg = TARGET_64BIT ? SEG_FS : SEG_GS;
11206               else
11207                 return 0;
11208               break;
11209
11210             case SUBREG:
11211               if (!ix86_address_subreg_operand (SUBREG_REG (op)))
11212                 return 0;
11213               /* FALLTHRU */
11214
11215             case REG:
11216               if (!base)
11217                 base = op;
11218               else if (!index)
11219                 index = op;
11220               else
11221                 return 0;
11222               break;
11223
11224             case CONST:
11225             case CONST_INT:
11226             case SYMBOL_REF:
11227             case LABEL_REF:
11228               if (disp)
11229                 return 0;
11230               disp = op;
11231               break;
11232
11233             default:
11234               return 0;
11235             }
11236         }
11237     }
11238   else if (GET_CODE (addr) == MULT)
11239     {
11240       index = XEXP (addr, 0);           /* index*scale */
11241       scale_rtx = XEXP (addr, 1);
11242     }
11243   else if (GET_CODE (addr) == ASHIFT)
11244     {
11245       /* We're called for lea too, which implements ashift on occasion.  */
11246       index = XEXP (addr, 0);
11247       tmp = XEXP (addr, 1);
11248       if (!CONST_INT_P (tmp))
11249         return 0;
11250       scale = INTVAL (tmp);
11251       if ((unsigned HOST_WIDE_INT) scale > 3)
11252         return 0;
11253       scale = 1 << scale;
11254       retval = -1;
11255     }
11256   else
11257     disp = addr;                        /* displacement */
11258
11259   if (index)
11260     {
11261       if (REG_P (index))
11262         ;
11263       else if (GET_CODE (index) == SUBREG
11264                && ix86_address_subreg_operand (SUBREG_REG (index)))
11265         ;
11266       else
11267         return 0;
11268     }
11269
11270   /* Extract the integral value of scale.  */
11271   if (scale_rtx)
11272     {
11273       if (!CONST_INT_P (scale_rtx))
11274         return 0;
11275       scale = INTVAL (scale_rtx);
11276     }
11277
11278   base_reg = base && GET_CODE (base) == SUBREG ? SUBREG_REG (base) : base;
11279   index_reg = index && GET_CODE (index) == SUBREG ? SUBREG_REG (index) : index;
11280
11281   /* Avoid useless 0 displacement.  */
11282   if (disp == const0_rtx && (base || index))
11283     disp = NULL_RTX;
11284
11285   /* Allow arg pointer and stack pointer as index if there is not scaling.  */
11286   if (base_reg && index_reg && scale == 1
11287       && (index_reg == arg_pointer_rtx
11288           || index_reg == frame_pointer_rtx
11289           || (REG_P (index_reg) && REGNO (index_reg) == STACK_POINTER_REGNUM)))
11290     {
11291       rtx tmp;
11292       tmp = base, base = index, index = tmp;
11293       tmp = base_reg, base_reg = index_reg, index_reg = tmp;
11294     }
11295
11296   /* Special case: %ebp cannot be encoded as a base without a displacement.
11297      Similarly %r13.  */
11298   if (!disp
11299       && base_reg
11300       && (base_reg == hard_frame_pointer_rtx
11301           || base_reg == frame_pointer_rtx
11302           || base_reg == arg_pointer_rtx
11303           || (REG_P (base_reg)
11304               && (REGNO (base_reg) == HARD_FRAME_POINTER_REGNUM
11305                   || REGNO (base_reg) == R13_REG))))
11306     disp = const0_rtx;
11307
11308   /* Special case: on K6, [%esi] makes the instruction vector decoded.
11309      Avoid this by transforming to [%esi+0].
11310      Reload calls address legitimization without cfun defined, so we need
11311      to test cfun for being non-NULL. */
11312   if (TARGET_K6 && cfun && optimize_function_for_speed_p (cfun)
11313       && base_reg && !index_reg && !disp
11314       && REG_P (base_reg) && REGNO (base_reg) == SI_REG)
11315     disp = const0_rtx;
11316
11317   /* Special case: encode reg+reg instead of reg*2.  */
11318   if (!base && index && scale == 2)
11319     base = index, base_reg = index_reg, scale = 1;
11320
11321   /* Special case: scaling cannot be encoded without base or displacement.  */
11322   if (!base && !disp && index && scale != 1)
11323     disp = const0_rtx;
11324
11325   out->base = base;
11326   out->index = index;
11327   out->disp = disp;
11328   out->scale = scale;
11329   out->seg = seg;
11330
11331   return retval;
11332 }
11333 \f
11334 /* Return cost of the memory address x.
11335    For i386, it is better to use a complex address than let gcc copy
11336    the address into a reg and make a new pseudo.  But not if the address
11337    requires to two regs - that would mean more pseudos with longer
11338    lifetimes.  */
11339 static int
11340 ix86_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
11341 {
11342   struct ix86_address parts;
11343   int cost = 1;
11344   int ok = ix86_decompose_address (x, &parts);
11345
11346   gcc_assert (ok);
11347
11348   if (parts.base && GET_CODE (parts.base) == SUBREG)
11349     parts.base = SUBREG_REG (parts.base);
11350   if (parts.index && GET_CODE (parts.index) == SUBREG)
11351     parts.index = SUBREG_REG (parts.index);
11352
11353   /* Attempt to minimize number of registers in the address.  */
11354   if ((parts.base
11355        && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER))
11356       || (parts.index
11357           && (!REG_P (parts.index)
11358               || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)))
11359     cost++;
11360
11361   if (parts.base
11362       && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER)
11363       && parts.index
11364       && (!REG_P (parts.index) || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)
11365       && parts.base != parts.index)
11366     cost++;
11367
11368   /* AMD-K6 don't like addresses with ModR/M set to 00_xxx_100b,
11369      since it's predecode logic can't detect the length of instructions
11370      and it degenerates to vector decoded.  Increase cost of such
11371      addresses here.  The penalty is minimally 2 cycles.  It may be worthwhile
11372      to split such addresses or even refuse such addresses at all.
11373
11374      Following addressing modes are affected:
11375       [base+scale*index]
11376       [scale*index+disp]
11377       [base+index]
11378
11379      The first and last case  may be avoidable by explicitly coding the zero in
11380      memory address, but I don't have AMD-K6 machine handy to check this
11381      theory.  */
11382
11383   if (TARGET_K6
11384       && ((!parts.disp && parts.base && parts.index && parts.scale != 1)
11385           || (parts.disp && !parts.base && parts.index && parts.scale != 1)
11386           || (!parts.disp && parts.base && parts.index && parts.scale == 1)))
11387     cost += 10;
11388
11389   return cost;
11390 }
11391 \f
11392 /* Allow {LABEL | SYMBOL}_REF - SYMBOL_REF-FOR-PICBASE for Mach-O as
11393    this is used for to form addresses to local data when -fPIC is in
11394    use.  */
11395
11396 static bool
11397 darwin_local_data_pic (rtx disp)
11398 {
11399   return (GET_CODE (disp) == UNSPEC
11400           && XINT (disp, 1) == UNSPEC_MACHOPIC_OFFSET);
11401 }
11402
11403 /* Determine if a given RTX is a valid constant.  We already know this
11404    satisfies CONSTANT_P.  */
11405
11406 static bool
11407 ix86_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
11408 {
11409   switch (GET_CODE (x))
11410     {
11411     case CONST:
11412       x = XEXP (x, 0);
11413
11414       if (GET_CODE (x) == PLUS)
11415         {
11416           if (!CONST_INT_P (XEXP (x, 1)))
11417             return false;
11418           x = XEXP (x, 0);
11419         }
11420
11421       if (TARGET_MACHO && darwin_local_data_pic (x))
11422         return true;
11423
11424       /* Only some unspecs are valid as "constants".  */
11425       if (GET_CODE (x) == UNSPEC)
11426         switch (XINT (x, 1))
11427           {
11428           case UNSPEC_GOT:
11429           case UNSPEC_GOTOFF:
11430           case UNSPEC_PLTOFF:
11431             return TARGET_64BIT;
11432           case UNSPEC_TPOFF:
11433           case UNSPEC_NTPOFF:
11434             x = XVECEXP (x, 0, 0);
11435             return (GET_CODE (x) == SYMBOL_REF
11436                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11437           case UNSPEC_DTPOFF:
11438             x = XVECEXP (x, 0, 0);
11439             return (GET_CODE (x) == SYMBOL_REF
11440                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC);
11441           default:
11442             return false;
11443           }
11444
11445       /* We must have drilled down to a symbol.  */
11446       if (GET_CODE (x) == LABEL_REF)
11447         return true;
11448       if (GET_CODE (x) != SYMBOL_REF)
11449         return false;
11450       /* FALLTHRU */
11451
11452     case SYMBOL_REF:
11453       /* TLS symbols are never valid.  */
11454       if (SYMBOL_REF_TLS_MODEL (x))
11455         return false;
11456
11457       /* DLLIMPORT symbols are never valid.  */
11458       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
11459           && SYMBOL_REF_DLLIMPORT_P (x))
11460         return false;
11461
11462 #if TARGET_MACHO
11463       /* mdynamic-no-pic */
11464       if (MACHO_DYNAMIC_NO_PIC_P)
11465         return machopic_symbol_defined_p (x);
11466 #endif
11467       break;
11468
11469     case CONST_DOUBLE:
11470       if (GET_MODE (x) == TImode
11471           && x != CONST0_RTX (TImode)
11472           && !TARGET_64BIT)
11473         return false;
11474       break;
11475
11476     case CONST_VECTOR:
11477       if (!standard_sse_constant_p (x))
11478         return false;
11479
11480     default:
11481       break;
11482     }
11483
11484   /* Otherwise we handle everything else in the move patterns.  */
11485   return true;
11486 }
11487
11488 /* Determine if it's legal to put X into the constant pool.  This
11489    is not possible for the address of thread-local symbols, which
11490    is checked above.  */
11491
11492 static bool
11493 ix86_cannot_force_const_mem (enum machine_mode mode, rtx x)
11494 {
11495   /* We can always put integral constants and vectors in memory.  */
11496   switch (GET_CODE (x))
11497     {
11498     case CONST_INT:
11499     case CONST_DOUBLE:
11500     case CONST_VECTOR:
11501       return false;
11502
11503     default:
11504       break;
11505     }
11506   return !ix86_legitimate_constant_p (mode, x);
11507 }
11508
11509
11510 /* Nonzero if the constant value X is a legitimate general operand
11511    when generating PIC code.  It is given that flag_pic is on and
11512    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
11513
11514 bool
11515 legitimate_pic_operand_p (rtx x)
11516 {
11517   rtx inner;
11518
11519   switch (GET_CODE (x))
11520     {
11521     case CONST:
11522       inner = XEXP (x, 0);
11523       if (GET_CODE (inner) == PLUS
11524           && CONST_INT_P (XEXP (inner, 1)))
11525         inner = XEXP (inner, 0);
11526
11527       /* Only some unspecs are valid as "constants".  */
11528       if (GET_CODE (inner) == UNSPEC)
11529         switch (XINT (inner, 1))
11530           {
11531           case UNSPEC_GOT:
11532           case UNSPEC_GOTOFF:
11533           case UNSPEC_PLTOFF:
11534             return TARGET_64BIT;
11535           case UNSPEC_TPOFF:
11536             x = XVECEXP (inner, 0, 0);
11537             return (GET_CODE (x) == SYMBOL_REF
11538                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11539           case UNSPEC_MACHOPIC_OFFSET:
11540             return legitimate_pic_address_disp_p (x);
11541           default:
11542             return false;
11543           }
11544       /* FALLTHRU */
11545
11546     case SYMBOL_REF:
11547     case LABEL_REF:
11548       return legitimate_pic_address_disp_p (x);
11549
11550     default:
11551       return true;
11552     }
11553 }
11554
11555 /* Determine if a given CONST RTX is a valid memory displacement
11556    in PIC mode.  */
11557
11558 bool
11559 legitimate_pic_address_disp_p (rtx disp)
11560 {
11561   bool saw_plus;
11562
11563   /* In 64bit mode we can allow direct addresses of symbols and labels
11564      when they are not dynamic symbols.  */
11565   if (TARGET_64BIT)
11566     {
11567       rtx op0 = disp, op1;
11568
11569       switch (GET_CODE (disp))
11570         {
11571         case LABEL_REF:
11572           return true;
11573
11574         case CONST:
11575           if (GET_CODE (XEXP (disp, 0)) != PLUS)
11576             break;
11577           op0 = XEXP (XEXP (disp, 0), 0);
11578           op1 = XEXP (XEXP (disp, 0), 1);
11579           if (!CONST_INT_P (op1)
11580               || INTVAL (op1) >= 16*1024*1024
11581               || INTVAL (op1) < -16*1024*1024)
11582             break;
11583           if (GET_CODE (op0) == LABEL_REF)
11584             return true;
11585           if (GET_CODE (op0) != SYMBOL_REF)
11586             break;
11587           /* FALLTHRU */
11588
11589         case SYMBOL_REF:
11590           /* TLS references should always be enclosed in UNSPEC.  */
11591           if (SYMBOL_REF_TLS_MODEL (op0))
11592             return false;
11593           if (!SYMBOL_REF_FAR_ADDR_P (op0) && SYMBOL_REF_LOCAL_P (op0)
11594               && ix86_cmodel != CM_LARGE_PIC)
11595             return true;
11596           break;
11597
11598         default:
11599           break;
11600         }
11601     }
11602   if (GET_CODE (disp) != CONST)
11603     return false;
11604   disp = XEXP (disp, 0);
11605
11606   if (TARGET_64BIT)
11607     {
11608       /* We are unsafe to allow PLUS expressions.  This limit allowed distance
11609          of GOT tables.  We should not need these anyway.  */
11610       if (GET_CODE (disp) != UNSPEC
11611           || (XINT (disp, 1) != UNSPEC_GOTPCREL
11612               && XINT (disp, 1) != UNSPEC_GOTOFF
11613               && XINT (disp, 1) != UNSPEC_PCREL
11614               && XINT (disp, 1) != UNSPEC_PLTOFF))
11615         return false;
11616
11617       if (GET_CODE (XVECEXP (disp, 0, 0)) != SYMBOL_REF
11618           && GET_CODE (XVECEXP (disp, 0, 0)) != LABEL_REF)
11619         return false;
11620       return true;
11621     }
11622
11623   saw_plus = false;
11624   if (GET_CODE (disp) == PLUS)
11625     {
11626       if (!CONST_INT_P (XEXP (disp, 1)))
11627         return false;
11628       disp = XEXP (disp, 0);
11629       saw_plus = true;
11630     }
11631
11632   if (TARGET_MACHO && darwin_local_data_pic (disp))
11633     return true;
11634
11635   if (GET_CODE (disp) != UNSPEC)
11636     return false;
11637
11638   switch (XINT (disp, 1))
11639     {
11640     case UNSPEC_GOT:
11641       if (saw_plus)
11642         return false;
11643       /* We need to check for both symbols and labels because VxWorks loads
11644          text labels with @GOT rather than @GOTOFF.  See gotoff_operand for
11645          details.  */
11646       return (GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11647               || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF);
11648     case UNSPEC_GOTOFF:
11649       /* Refuse GOTOFF in 64bit mode since it is always 64bit when used.
11650          While ABI specify also 32bit relocation but we don't produce it in
11651          small PIC model at all.  */
11652       if ((GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11653            || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF)
11654           && !TARGET_64BIT)
11655         return gotoff_operand (XVECEXP (disp, 0, 0), Pmode);
11656       return false;
11657     case UNSPEC_GOTTPOFF:
11658     case UNSPEC_GOTNTPOFF:
11659     case UNSPEC_INDNTPOFF:
11660       if (saw_plus)
11661         return false;
11662       disp = XVECEXP (disp, 0, 0);
11663       return (GET_CODE (disp) == SYMBOL_REF
11664               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_INITIAL_EXEC);
11665     case UNSPEC_NTPOFF:
11666       disp = XVECEXP (disp, 0, 0);
11667       return (GET_CODE (disp) == SYMBOL_REF
11668               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_EXEC);
11669     case UNSPEC_DTPOFF:
11670       disp = XVECEXP (disp, 0, 0);
11671       return (GET_CODE (disp) == SYMBOL_REF
11672               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_DYNAMIC);
11673     }
11674
11675   return false;
11676 }
11677
11678 /* Recognizes RTL expressions that are valid memory addresses for an
11679    instruction.  The MODE argument is the machine mode for the MEM
11680    expression that wants to use this address.
11681
11682    It only recognizes address in canonical form.  LEGITIMIZE_ADDRESS should
11683    convert common non-canonical forms to canonical form so that they will
11684    be recognized.  */
11685
11686 static bool
11687 ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
11688                            rtx addr, bool strict)
11689 {
11690   struct ix86_address parts;
11691   rtx base, index, disp;
11692   HOST_WIDE_INT scale;
11693
11694   if (ix86_decompose_address (addr, &parts) <= 0)
11695     /* Decomposition failed.  */
11696     return false;
11697
11698   base = parts.base;
11699   index = parts.index;
11700   disp = parts.disp;
11701   scale = parts.scale;
11702
11703   /* Validate base register.  */
11704   if (base)
11705     {
11706       rtx reg;
11707
11708       if (REG_P (base))
11709         reg = base;
11710       else if (GET_CODE (base) == SUBREG && REG_P (SUBREG_REG (base)))
11711         reg = SUBREG_REG (base);
11712       else
11713         /* Base is not a register.  */
11714         return false;
11715
11716       if (GET_MODE (base) != SImode && GET_MODE (base) != DImode)
11717         return false;
11718
11719       if ((strict && ! REG_OK_FOR_BASE_STRICT_P (reg))
11720           || (! strict && ! REG_OK_FOR_BASE_NONSTRICT_P (reg)))
11721         /* Base is not valid.  */
11722         return false;
11723     }
11724
11725   /* Validate index register.  */
11726   if (index)
11727     {
11728       rtx reg;
11729
11730       if (REG_P (index))
11731         reg = index;
11732       else if (GET_CODE (index) == SUBREG && REG_P (SUBREG_REG (index)))
11733         reg = SUBREG_REG (index);
11734       else
11735         /* Index is not a register.  */
11736         return false;
11737
11738       if (GET_MODE (index) != SImode && GET_MODE (index) != DImode)
11739         return false;
11740
11741       if ((strict && ! REG_OK_FOR_INDEX_STRICT_P (reg))
11742           || (! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P (reg)))
11743         /* Index is not valid.  */
11744         return false;
11745     }
11746
11747   /* Index and base should have the same mode.  */
11748   if (base && index
11749       && GET_MODE (base) != GET_MODE (index))
11750     return false;
11751
11752   /* Validate scale factor.  */
11753   if (scale != 1)
11754     {
11755       if (!index)
11756         /* Scale without index.  */
11757         return false;
11758
11759       if (scale != 2 && scale != 4 && scale != 8)
11760         /* Scale is not a valid multiplier.  */
11761         return false;
11762     }
11763
11764   /* Validate displacement.  */
11765   if (disp)
11766     {
11767       if (GET_CODE (disp) == CONST
11768           && GET_CODE (XEXP (disp, 0)) == UNSPEC
11769           && XINT (XEXP (disp, 0), 1) != UNSPEC_MACHOPIC_OFFSET)
11770         switch (XINT (XEXP (disp, 0), 1))
11771           {
11772           /* Refuse GOTOFF and GOT in 64bit mode since it is always 64bit when
11773              used.  While ABI specify also 32bit relocations, we don't produce
11774              them at all and use IP relative instead.  */
11775           case UNSPEC_GOT:
11776           case UNSPEC_GOTOFF:
11777             gcc_assert (flag_pic);
11778             if (!TARGET_64BIT)
11779               goto is_legitimate_pic;
11780
11781             /* 64bit address unspec.  */
11782             return false;
11783
11784           case UNSPEC_GOTPCREL:
11785           case UNSPEC_PCREL:
11786             gcc_assert (flag_pic);
11787             goto is_legitimate_pic;
11788
11789           case UNSPEC_GOTTPOFF:
11790           case UNSPEC_GOTNTPOFF:
11791           case UNSPEC_INDNTPOFF:
11792           case UNSPEC_NTPOFF:
11793           case UNSPEC_DTPOFF:
11794             break;
11795
11796           case UNSPEC_STACK_CHECK:
11797             gcc_assert (flag_split_stack);
11798             break;
11799
11800           default:
11801             /* Invalid address unspec.  */
11802             return false;
11803           }
11804
11805       else if (SYMBOLIC_CONST (disp)
11806                && (flag_pic
11807                    || (TARGET_MACHO
11808 #if TARGET_MACHO
11809                        && MACHOPIC_INDIRECT
11810                        && !machopic_operand_p (disp)
11811 #endif
11812                )))
11813         {
11814
11815         is_legitimate_pic:
11816           if (TARGET_64BIT && (index || base))
11817             {
11818               /* foo@dtpoff(%rX) is ok.  */
11819               if (GET_CODE (disp) != CONST
11820                   || GET_CODE (XEXP (disp, 0)) != PLUS
11821                   || GET_CODE (XEXP (XEXP (disp, 0), 0)) != UNSPEC
11822                   || !CONST_INT_P (XEXP (XEXP (disp, 0), 1))
11823                   || (XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_DTPOFF
11824                       && XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_NTPOFF))
11825                 /* Non-constant pic memory reference.  */
11826                 return false;
11827             }
11828           else if ((!TARGET_MACHO || flag_pic)
11829                     && ! legitimate_pic_address_disp_p (disp))
11830             /* Displacement is an invalid pic construct.  */
11831             return false;
11832 #if TARGET_MACHO
11833           else if (MACHO_DYNAMIC_NO_PIC_P
11834                    && !ix86_legitimate_constant_p (Pmode, disp))
11835             /* displacment must be referenced via non_lazy_pointer */
11836             return false;
11837 #endif
11838
11839           /* This code used to verify that a symbolic pic displacement
11840              includes the pic_offset_table_rtx register.
11841
11842              While this is good idea, unfortunately these constructs may
11843              be created by "adds using lea" optimization for incorrect
11844              code like:
11845
11846              int a;
11847              int foo(int i)
11848                {
11849                  return *(&a+i);
11850                }
11851
11852              This code is nonsensical, but results in addressing
11853              GOT table with pic_offset_table_rtx base.  We can't
11854              just refuse it easily, since it gets matched by
11855              "addsi3" pattern, that later gets split to lea in the
11856              case output register differs from input.  While this
11857              can be handled by separate addsi pattern for this case
11858              that never results in lea, this seems to be easier and
11859              correct fix for crash to disable this test.  */
11860         }
11861       else if (GET_CODE (disp) != LABEL_REF
11862                && !CONST_INT_P (disp)
11863                && (GET_CODE (disp) != CONST
11864                    || !ix86_legitimate_constant_p (Pmode, disp))
11865                && (GET_CODE (disp) != SYMBOL_REF
11866                    || !ix86_legitimate_constant_p (Pmode, disp)))
11867         /* Displacement is not constant.  */
11868         return false;
11869       else if (TARGET_64BIT
11870                && !x86_64_immediate_operand (disp, VOIDmode))
11871         /* Displacement is out of range.  */
11872         return false;
11873     }
11874
11875   /* Everything looks valid.  */
11876   return true;
11877 }
11878
11879 /* Determine if a given RTX is a valid constant address.  */
11880
11881 bool
11882 constant_address_p (rtx x)
11883 {
11884   return CONSTANT_P (x) && ix86_legitimate_address_p (Pmode, x, 1);
11885 }
11886 \f
11887 /* Return a unique alias set for the GOT.  */
11888
11889 static alias_set_type
11890 ix86_GOT_alias_set (void)
11891 {
11892   static alias_set_type set = -1;
11893   if (set == -1)
11894     set = new_alias_set ();
11895   return set;
11896 }
11897
11898 /* Return a legitimate reference for ORIG (an address) using the
11899    register REG.  If REG is 0, a new pseudo is generated.
11900
11901    There are two types of references that must be handled:
11902
11903    1. Global data references must load the address from the GOT, via
11904       the PIC reg.  An insn is emitted to do this load, and the reg is
11905       returned.
11906
11907    2. Static data references, constant pool addresses, and code labels
11908       compute the address as an offset from the GOT, whose base is in
11909       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
11910       differentiate them from global data objects.  The returned
11911       address is the PIC reg + an unspec constant.
11912
11913    TARGET_LEGITIMATE_ADDRESS_P rejects symbolic references unless the PIC
11914    reg also appears in the address.  */
11915
11916 static rtx
11917 legitimize_pic_address (rtx orig, rtx reg)
11918 {
11919   rtx addr = orig;
11920   rtx new_rtx = orig;
11921   rtx base;
11922
11923 #if TARGET_MACHO
11924   if (TARGET_MACHO && !TARGET_64BIT)
11925     {
11926       if (reg == 0)
11927         reg = gen_reg_rtx (Pmode);
11928       /* Use the generic Mach-O PIC machinery.  */
11929       return machopic_legitimize_pic_address (orig, GET_MODE (orig), reg);
11930     }
11931 #endif
11932
11933   if (TARGET_64BIT && legitimate_pic_address_disp_p (addr))
11934     new_rtx = addr;
11935   else if (TARGET_64BIT
11936            && ix86_cmodel != CM_SMALL_PIC
11937            && gotoff_operand (addr, Pmode))
11938     {
11939       rtx tmpreg;
11940       /* This symbol may be referenced via a displacement from the PIC
11941          base address (@GOTOFF).  */
11942
11943       if (reload_in_progress)
11944         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
11945       if (GET_CODE (addr) == CONST)
11946         addr = XEXP (addr, 0);
11947       if (GET_CODE (addr) == PLUS)
11948           {
11949             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
11950                                       UNSPEC_GOTOFF);
11951             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
11952           }
11953         else
11954           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
11955       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11956       if (!reg)
11957         tmpreg = gen_reg_rtx (Pmode);
11958       else
11959         tmpreg = reg;
11960       emit_move_insn (tmpreg, new_rtx);
11961
11962       if (reg != 0)
11963         {
11964           new_rtx = expand_simple_binop (Pmode, PLUS, reg, pic_offset_table_rtx,
11965                                          tmpreg, 1, OPTAB_DIRECT);
11966           new_rtx = reg;
11967         }
11968       else new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmpreg);
11969     }
11970   else if (!TARGET_64BIT && gotoff_operand (addr, Pmode))
11971     {
11972       /* This symbol may be referenced via a displacement from the PIC
11973          base address (@GOTOFF).  */
11974
11975       if (reload_in_progress)
11976         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
11977       if (GET_CODE (addr) == CONST)
11978         addr = XEXP (addr, 0);
11979       if (GET_CODE (addr) == PLUS)
11980           {
11981             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
11982                                       UNSPEC_GOTOFF);
11983             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
11984           }
11985         else
11986           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
11987       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
11988       new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
11989
11990       if (reg != 0)
11991         {
11992           emit_move_insn (reg, new_rtx);
11993           new_rtx = reg;
11994         }
11995     }
11996   else if ((GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (addr) == 0)
11997            /* We can't use @GOTOFF for text labels on VxWorks;
11998               see gotoff_operand.  */
11999            || (TARGET_VXWORKS_RTP && GET_CODE (addr) == LABEL_REF))
12000     {
12001       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12002         {
12003           if (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (addr))
12004             return legitimize_dllimport_symbol (addr, true);
12005           if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
12006               && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF
12007               && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (addr, 0), 0)))
12008             {
12009               rtx t = legitimize_dllimport_symbol (XEXP (XEXP (addr, 0), 0), true);
12010               return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (addr, 0), 1));
12011             }
12012         }
12013
12014       /* For x64 PE-COFF there is no GOT table.  So we use address
12015          directly.  */
12016       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12017       {
12018           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_PCREL);
12019           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12020
12021           if (reg == 0)
12022             reg = gen_reg_rtx (Pmode);
12023           emit_move_insn (reg, new_rtx);
12024           new_rtx = reg;
12025       }
12026       else if (TARGET_64BIT && ix86_cmodel != CM_LARGE_PIC)
12027         {
12028           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTPCREL);
12029           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12030           new_rtx = gen_const_mem (Pmode, new_rtx);
12031           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12032
12033           if (reg == 0)
12034             reg = gen_reg_rtx (Pmode);
12035           /* Use directly gen_movsi, otherwise the address is loaded
12036              into register for CSE.  We don't want to CSE this addresses,
12037              instead we CSE addresses from the GOT table, so skip this.  */
12038           emit_insn (gen_movsi (reg, new_rtx));
12039           new_rtx = reg;
12040         }
12041       else
12042         {
12043           /* This symbol must be referenced via a load from the
12044              Global Offset Table (@GOT).  */
12045
12046           if (reload_in_progress)
12047             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12048           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
12049           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12050           if (TARGET_64BIT)
12051             new_rtx = force_reg (Pmode, new_rtx);
12052           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12053           new_rtx = gen_const_mem (Pmode, new_rtx);
12054           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12055
12056           if (reg == 0)
12057             reg = gen_reg_rtx (Pmode);
12058           emit_move_insn (reg, new_rtx);
12059           new_rtx = reg;
12060         }
12061     }
12062   else
12063     {
12064       if (CONST_INT_P (addr)
12065           && !x86_64_immediate_operand (addr, VOIDmode))
12066         {
12067           if (reg)
12068             {
12069               emit_move_insn (reg, addr);
12070               new_rtx = reg;
12071             }
12072           else
12073             new_rtx = force_reg (Pmode, addr);
12074         }
12075       else if (GET_CODE (addr) == CONST)
12076         {
12077           addr = XEXP (addr, 0);
12078
12079           /* We must match stuff we generate before.  Assume the only
12080              unspecs that can get here are ours.  Not that we could do
12081              anything with them anyway....  */
12082           if (GET_CODE (addr) == UNSPEC
12083               || (GET_CODE (addr) == PLUS
12084                   && GET_CODE (XEXP (addr, 0)) == UNSPEC))
12085             return orig;
12086           gcc_assert (GET_CODE (addr) == PLUS);
12087         }
12088       if (GET_CODE (addr) == PLUS)
12089         {
12090           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
12091
12092           /* Check first to see if this is a constant offset from a @GOTOFF
12093              symbol reference.  */
12094           if (gotoff_operand (op0, Pmode)
12095               && CONST_INT_P (op1))
12096             {
12097               if (!TARGET_64BIT)
12098                 {
12099                   if (reload_in_progress)
12100                     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12101                   new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
12102                                             UNSPEC_GOTOFF);
12103                   new_rtx = gen_rtx_PLUS (Pmode, new_rtx, op1);
12104                   new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12105                   new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12106
12107                   if (reg != 0)
12108                     {
12109                       emit_move_insn (reg, new_rtx);
12110                       new_rtx = reg;
12111                     }
12112                 }
12113               else
12114                 {
12115                   if (INTVAL (op1) < -16*1024*1024
12116                       || INTVAL (op1) >= 16*1024*1024)
12117                     {
12118                       if (!x86_64_immediate_operand (op1, Pmode))
12119                         op1 = force_reg (Pmode, op1);
12120                       new_rtx = gen_rtx_PLUS (Pmode, force_reg (Pmode, op0), op1);
12121                     }
12122                 }
12123             }
12124           else
12125             {
12126               base = legitimize_pic_address (XEXP (addr, 0), reg);
12127               new_rtx  = legitimize_pic_address (XEXP (addr, 1),
12128                                                  base == reg ? NULL_RTX : reg);
12129
12130               if (CONST_INT_P (new_rtx))
12131                 new_rtx = plus_constant (base, INTVAL (new_rtx));
12132               else
12133                 {
12134                   if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1)))
12135                     {
12136                       base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0));
12137                       new_rtx = XEXP (new_rtx, 1);
12138                     }
12139                   new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx);
12140                 }
12141             }
12142         }
12143     }
12144   return new_rtx;
12145 }
12146 \f
12147 /* Load the thread pointer.  If TO_REG is true, force it into a register.  */
12148
12149 static rtx
12150 get_thread_pointer (bool to_reg)
12151 {
12152   rtx tp = gen_rtx_UNSPEC (ptr_mode, gen_rtvec (1, const0_rtx), UNSPEC_TP);
12153
12154   if (GET_MODE (tp) != Pmode)
12155     tp = convert_to_mode (Pmode, tp, 1);
12156
12157   if (to_reg)
12158     tp = copy_addr_to_reg (tp);
12159
12160   return tp;
12161 }
12162
12163 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
12164
12165 static GTY(()) rtx ix86_tls_symbol;
12166
12167 static rtx
12168 ix86_tls_get_addr (void)
12169 {
12170   if (!ix86_tls_symbol)
12171     {
12172       const char *sym
12173         = ((TARGET_ANY_GNU_TLS && !TARGET_64BIT)
12174            ? "___tls_get_addr" : "__tls_get_addr");
12175
12176       ix86_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, sym);
12177     }
12178
12179   return ix86_tls_symbol;
12180 }
12181
12182 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol.  */
12183
12184 static GTY(()) rtx ix86_tls_module_base_symbol;
12185
12186 rtx
12187 ix86_tls_module_base (void)
12188 {
12189   if (!ix86_tls_module_base_symbol)
12190     {
12191       ix86_tls_module_base_symbol
12192         = gen_rtx_SYMBOL_REF (Pmode, "_TLS_MODULE_BASE_");
12193
12194       SYMBOL_REF_FLAGS (ix86_tls_module_base_symbol)
12195         |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT;
12196     }
12197
12198   return ix86_tls_module_base_symbol;
12199 }
12200
12201 /* A subroutine of ix86_legitimize_address and ix86_expand_move.  FOR_MOV is
12202    false if we expect this to be used for a memory address and true if
12203    we expect to load the address into a register.  */
12204
12205 static rtx
12206 legitimize_tls_address (rtx x, enum tls_model model, bool for_mov)
12207 {
12208   rtx dest, base, off;
12209   rtx pic = NULL_RTX, tp = NULL_RTX;
12210   int type;
12211
12212   switch (model)
12213     {
12214     case TLS_MODEL_GLOBAL_DYNAMIC:
12215       dest = gen_reg_rtx (Pmode);
12216
12217       if (!TARGET_64BIT)
12218         {
12219           if (flag_pic)
12220             pic = pic_offset_table_rtx;
12221           else
12222             {
12223               pic = gen_reg_rtx (Pmode);
12224               emit_insn (gen_set_got (pic));
12225             }
12226         }
12227
12228       if (TARGET_GNU2_TLS)
12229         {
12230           if (TARGET_64BIT)
12231             emit_insn (gen_tls_dynamic_gnu2_64 (dest, x));
12232           else
12233             emit_insn (gen_tls_dynamic_gnu2_32 (dest, x, pic));
12234
12235           tp = get_thread_pointer (true);
12236           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, tp, dest));
12237
12238           set_unique_reg_note (get_last_insn (), REG_EQUIV, x);
12239         }
12240       else
12241         {
12242           rtx caddr = ix86_tls_get_addr ();
12243
12244           if (TARGET_64BIT)
12245             {
12246               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns;
12247
12248               start_sequence ();
12249               emit_call_insn (gen_tls_global_dynamic_64 (rax, x, caddr));
12250               insns = get_insns ();
12251               end_sequence ();
12252
12253               RTL_CONST_CALL_P (insns) = 1;
12254               emit_libcall_block (insns, dest, rax, x);
12255             }
12256           else
12257             emit_insn (gen_tls_global_dynamic_32 (dest, x, pic, caddr));
12258         }
12259       break;
12260
12261     case TLS_MODEL_LOCAL_DYNAMIC:
12262       base = gen_reg_rtx (Pmode);
12263
12264       if (!TARGET_64BIT)
12265         {
12266           if (flag_pic)
12267             pic = pic_offset_table_rtx;
12268           else
12269             {
12270               pic = gen_reg_rtx (Pmode);
12271               emit_insn (gen_set_got (pic));
12272             }
12273         }
12274
12275       if (TARGET_GNU2_TLS)
12276         {
12277           rtx tmp = ix86_tls_module_base ();
12278
12279           if (TARGET_64BIT)
12280             emit_insn (gen_tls_dynamic_gnu2_64 (base, tmp));
12281           else
12282             emit_insn (gen_tls_dynamic_gnu2_32 (base, tmp, pic));
12283
12284           tp = get_thread_pointer (true);
12285           set_unique_reg_note (get_last_insn (), REG_EQUIV,
12286                                gen_rtx_MINUS (Pmode, tmp, tp));
12287         }
12288       else
12289         {
12290           rtx caddr = ix86_tls_get_addr ();
12291
12292           if (TARGET_64BIT)
12293             {
12294               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns, eqv;
12295
12296               start_sequence ();
12297               emit_call_insn (gen_tls_local_dynamic_base_64 (rax, caddr));
12298               insns = get_insns ();
12299               end_sequence ();
12300
12301               /* Attach a unique REG_EQUIV, to allow the RTL optimizers to
12302                  share the LD_BASE result with other LD model accesses.  */
12303               eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
12304                                     UNSPEC_TLS_LD_BASE);
12305
12306               RTL_CONST_CALL_P (insns) = 1;
12307               emit_libcall_block (insns, base, rax, eqv);
12308             }
12309           else
12310             emit_insn (gen_tls_local_dynamic_base_32 (base, pic, caddr));
12311         }
12312
12313       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPOFF);
12314       off = gen_rtx_CONST (Pmode, off);
12315
12316       dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, off));
12317
12318       if (TARGET_GNU2_TLS)
12319         {
12320           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, dest, tp));
12321
12322           set_unique_reg_note (get_last_insn (), REG_EQUIV, x);
12323         }
12324       break;
12325
12326     case TLS_MODEL_INITIAL_EXEC:
12327       if (TARGET_64BIT)
12328         {
12329           if (TARGET_SUN_TLS)
12330             {
12331               /* The Sun linker took the AMD64 TLS spec literally
12332                  and can only handle %rax as destination of the
12333                  initial executable code sequence.  */
12334
12335               dest = gen_reg_rtx (Pmode);
12336               emit_insn (gen_tls_initial_exec_64_sun (dest, x));
12337               return dest;
12338             }
12339
12340           pic = NULL;
12341           type = UNSPEC_GOTNTPOFF;
12342         }
12343       else if (flag_pic)
12344         {
12345           if (reload_in_progress)
12346             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12347           pic = pic_offset_table_rtx;
12348           type = TARGET_ANY_GNU_TLS ? UNSPEC_GOTNTPOFF : UNSPEC_GOTTPOFF;
12349         }
12350       else if (!TARGET_ANY_GNU_TLS)
12351         {
12352           pic = gen_reg_rtx (Pmode);
12353           emit_insn (gen_set_got (pic));
12354           type = UNSPEC_GOTTPOFF;
12355         }
12356       else
12357         {
12358           pic = NULL;
12359           type = UNSPEC_INDNTPOFF;
12360         }
12361
12362       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), type);
12363       off = gen_rtx_CONST (Pmode, off);
12364       if (pic)
12365         off = gen_rtx_PLUS (Pmode, pic, off);
12366       off = gen_const_mem (Pmode, off);
12367       set_mem_alias_set (off, ix86_GOT_alias_set ());
12368
12369       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12370         {
12371           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12372           off = force_reg (Pmode, off);
12373           return gen_rtx_PLUS (Pmode, base, off);
12374         }
12375       else
12376         {
12377           base = get_thread_pointer (true);
12378           dest = gen_reg_rtx (Pmode);
12379           emit_insn (gen_subsi3 (dest, base, off));
12380         }
12381       break;
12382
12383     case TLS_MODEL_LOCAL_EXEC:
12384       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x),
12385                             (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12386                             ? UNSPEC_NTPOFF : UNSPEC_TPOFF);
12387       off = gen_rtx_CONST (Pmode, off);
12388
12389       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12390         {
12391           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12392           return gen_rtx_PLUS (Pmode, base, off);
12393         }
12394       else
12395         {
12396           base = get_thread_pointer (true);
12397           dest = gen_reg_rtx (Pmode);
12398           emit_insn (gen_subsi3 (dest, base, off));
12399         }
12400       break;
12401
12402     default:
12403       gcc_unreachable ();
12404     }
12405
12406   return dest;
12407 }
12408
12409 /* Create or return the unique __imp_DECL dllimport symbol corresponding
12410    to symbol DECL.  */
12411
12412 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
12413   htab_t dllimport_map;
12414
12415 static tree
12416 get_dllimport_decl (tree decl)
12417 {
12418   struct tree_map *h, in;
12419   void **loc;
12420   const char *name;
12421   const char *prefix;
12422   size_t namelen, prefixlen;
12423   char *imp_name;
12424   tree to;
12425   rtx rtl;
12426
12427   if (!dllimport_map)
12428     dllimport_map = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
12429
12430   in.hash = htab_hash_pointer (decl);
12431   in.base.from = decl;
12432   loc = htab_find_slot_with_hash (dllimport_map, &in, in.hash, INSERT);
12433   h = (struct tree_map *) *loc;
12434   if (h)
12435     return h->to;
12436
12437   *loc = h = ggc_alloc_tree_map ();
12438   h->hash = in.hash;
12439   h->base.from = decl;
12440   h->to = to = build_decl (DECL_SOURCE_LOCATION (decl),
12441                            VAR_DECL, NULL, ptr_type_node);
12442   DECL_ARTIFICIAL (to) = 1;
12443   DECL_IGNORED_P (to) = 1;
12444   DECL_EXTERNAL (to) = 1;
12445   TREE_READONLY (to) = 1;
12446
12447   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
12448   name = targetm.strip_name_encoding (name);
12449   prefix = name[0] == FASTCALL_PREFIX || user_label_prefix[0] == 0
12450     ? "*__imp_" : "*__imp__";
12451   namelen = strlen (name);
12452   prefixlen = strlen (prefix);
12453   imp_name = (char *) alloca (namelen + prefixlen + 1);
12454   memcpy (imp_name, prefix, prefixlen);
12455   memcpy (imp_name + prefixlen, name, namelen + 1);
12456
12457   name = ggc_alloc_string (imp_name, namelen + prefixlen);
12458   rtl = gen_rtx_SYMBOL_REF (Pmode, name);
12459   SET_SYMBOL_REF_DECL (rtl, to);
12460   SYMBOL_REF_FLAGS (rtl) = SYMBOL_FLAG_LOCAL;
12461
12462   rtl = gen_const_mem (Pmode, rtl);
12463   set_mem_alias_set (rtl, ix86_GOT_alias_set ());
12464
12465   SET_DECL_RTL (to, rtl);
12466   SET_DECL_ASSEMBLER_NAME (to, get_identifier (name));
12467
12468   return to;
12469 }
12470
12471 /* Expand SYMBOL into its corresponding dllimport symbol.  WANT_REG is
12472    true if we require the result be a register.  */
12473
12474 static rtx
12475 legitimize_dllimport_symbol (rtx symbol, bool want_reg)
12476 {
12477   tree imp_decl;
12478   rtx x;
12479
12480   gcc_assert (SYMBOL_REF_DECL (symbol));
12481   imp_decl = get_dllimport_decl (SYMBOL_REF_DECL (symbol));
12482
12483   x = DECL_RTL (imp_decl);
12484   if (want_reg)
12485     x = force_reg (Pmode, x);
12486   return x;
12487 }
12488
12489 /* Try machine-dependent ways of modifying an illegitimate address
12490    to be legitimate.  If we find one, return the new, valid address.
12491    This macro is used in only one place: `memory_address' in explow.c.
12492
12493    OLDX is the address as it was before break_out_memory_refs was called.
12494    In some cases it is useful to look at this to decide what needs to be done.
12495
12496    It is always safe for this macro to do nothing.  It exists to recognize
12497    opportunities to optimize the output.
12498
12499    For the 80386, we handle X+REG by loading X into a register R and
12500    using R+REG.  R will go in a general reg and indexing will be used.
12501    However, if REG is a broken-out memory address or multiplication,
12502    nothing needs to be done because REG can certainly go in a general reg.
12503
12504    When -fpic is used, special handling is needed for symbolic references.
12505    See comments by legitimize_pic_address in i386.c for details.  */
12506
12507 static rtx
12508 ix86_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
12509                          enum machine_mode mode)
12510 {
12511   int changed = 0;
12512   unsigned log;
12513
12514   log = GET_CODE (x) == SYMBOL_REF ? SYMBOL_REF_TLS_MODEL (x) : 0;
12515   if (log)
12516     return legitimize_tls_address (x, (enum tls_model) log, false);
12517   if (GET_CODE (x) == CONST
12518       && GET_CODE (XEXP (x, 0)) == PLUS
12519       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12520       && (log = SYMBOL_REF_TLS_MODEL (XEXP (XEXP (x, 0), 0))))
12521     {
12522       rtx t = legitimize_tls_address (XEXP (XEXP (x, 0), 0),
12523                                       (enum tls_model) log, false);
12524       return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12525     }
12526
12527   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12528     {
12529       if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (x))
12530         return legitimize_dllimport_symbol (x, true);
12531       if (GET_CODE (x) == CONST
12532           && GET_CODE (XEXP (x, 0)) == PLUS
12533           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12534           && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (x, 0), 0)))
12535         {
12536           rtx t = legitimize_dllimport_symbol (XEXP (XEXP (x, 0), 0), true);
12537           return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12538         }
12539     }
12540
12541   if (flag_pic && SYMBOLIC_CONST (x))
12542     return legitimize_pic_address (x, 0);
12543
12544 #if TARGET_MACHO
12545   if (MACHO_DYNAMIC_NO_PIC_P && SYMBOLIC_CONST (x))
12546     return machopic_indirect_data_reference (x, 0);
12547 #endif
12548
12549   /* Canonicalize shifts by 0, 1, 2, 3 into multiply */
12550   if (GET_CODE (x) == ASHIFT
12551       && CONST_INT_P (XEXP (x, 1))
12552       && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) < 4)
12553     {
12554       changed = 1;
12555       log = INTVAL (XEXP (x, 1));
12556       x = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (x, 0)),
12557                         GEN_INT (1 << log));
12558     }
12559
12560   if (GET_CODE (x) == PLUS)
12561     {
12562       /* Canonicalize shifts by 0, 1, 2, 3 into multiply.  */
12563
12564       if (GET_CODE (XEXP (x, 0)) == ASHIFT
12565           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
12566           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 0), 1)) < 4)
12567         {
12568           changed = 1;
12569           log = INTVAL (XEXP (XEXP (x, 0), 1));
12570           XEXP (x, 0) = gen_rtx_MULT (Pmode,
12571                                       force_reg (Pmode, XEXP (XEXP (x, 0), 0)),
12572                                       GEN_INT (1 << log));
12573         }
12574
12575       if (GET_CODE (XEXP (x, 1)) == ASHIFT
12576           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
12577           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 1), 1)) < 4)
12578         {
12579           changed = 1;
12580           log = INTVAL (XEXP (XEXP (x, 1), 1));
12581           XEXP (x, 1) = gen_rtx_MULT (Pmode,
12582                                       force_reg (Pmode, XEXP (XEXP (x, 1), 0)),
12583                                       GEN_INT (1 << log));
12584         }
12585
12586       /* Put multiply first if it isn't already.  */
12587       if (GET_CODE (XEXP (x, 1)) == MULT)
12588         {
12589           rtx tmp = XEXP (x, 0);
12590           XEXP (x, 0) = XEXP (x, 1);
12591           XEXP (x, 1) = tmp;
12592           changed = 1;
12593         }
12594
12595       /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
12596          into (plus (plus (mult (reg) (const)) (reg)) (const)).  This can be
12597          created by virtual register instantiation, register elimination, and
12598          similar optimizations.  */
12599       if (GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == PLUS)
12600         {
12601           changed = 1;
12602           x = gen_rtx_PLUS (Pmode,
12603                             gen_rtx_PLUS (Pmode, XEXP (x, 0),
12604                                           XEXP (XEXP (x, 1), 0)),
12605                             XEXP (XEXP (x, 1), 1));
12606         }
12607
12608       /* Canonicalize
12609          (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
12610          into (plus (plus (mult (reg) (const)) (reg)) (const)).  */
12611       else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS
12612                && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
12613                && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS
12614                && CONSTANT_P (XEXP (x, 1)))
12615         {
12616           rtx constant;
12617           rtx other = NULL_RTX;
12618
12619           if (CONST_INT_P (XEXP (x, 1)))
12620             {
12621               constant = XEXP (x, 1);
12622               other = XEXP (XEXP (XEXP (x, 0), 1), 1);
12623             }
12624           else if (CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 1), 1)))
12625             {
12626               constant = XEXP (XEXP (XEXP (x, 0), 1), 1);
12627               other = XEXP (x, 1);
12628             }
12629           else
12630             constant = 0;
12631
12632           if (constant)
12633             {
12634               changed = 1;
12635               x = gen_rtx_PLUS (Pmode,
12636                                 gen_rtx_PLUS (Pmode, XEXP (XEXP (x, 0), 0),
12637                                               XEXP (XEXP (XEXP (x, 0), 1), 0)),
12638                                 plus_constant (other, INTVAL (constant)));
12639             }
12640         }
12641
12642       if (changed && ix86_legitimate_address_p (mode, x, false))
12643         return x;
12644
12645       if (GET_CODE (XEXP (x, 0)) == MULT)
12646         {
12647           changed = 1;
12648           XEXP (x, 0) = force_operand (XEXP (x, 0), 0);
12649         }
12650
12651       if (GET_CODE (XEXP (x, 1)) == MULT)
12652         {
12653           changed = 1;
12654           XEXP (x, 1) = force_operand (XEXP (x, 1), 0);
12655         }
12656
12657       if (changed
12658           && REG_P (XEXP (x, 1))
12659           && REG_P (XEXP (x, 0)))
12660         return x;
12661
12662       if (flag_pic && SYMBOLIC_CONST (XEXP (x, 1)))
12663         {
12664           changed = 1;
12665           x = legitimize_pic_address (x, 0);
12666         }
12667
12668       if (changed && ix86_legitimate_address_p (mode, x, false))
12669         return x;
12670
12671       if (REG_P (XEXP (x, 0)))
12672         {
12673           rtx temp = gen_reg_rtx (Pmode);
12674           rtx val  = force_operand (XEXP (x, 1), temp);
12675           if (val != temp)
12676             {
12677               if (GET_MODE (val) != Pmode)
12678                 val = convert_to_mode (Pmode, val, 1);
12679               emit_move_insn (temp, val);
12680             }
12681
12682           XEXP (x, 1) = temp;
12683           return x;
12684         }
12685
12686       else if (REG_P (XEXP (x, 1)))
12687         {
12688           rtx temp = gen_reg_rtx (Pmode);
12689           rtx val  = force_operand (XEXP (x, 0), temp);
12690           if (val != temp)
12691             {
12692               if (GET_MODE (val) != Pmode)
12693                 val = convert_to_mode (Pmode, val, 1);
12694               emit_move_insn (temp, val);
12695             }
12696
12697           XEXP (x, 0) = temp;
12698           return x;
12699         }
12700     }
12701
12702   return x;
12703 }
12704 \f
12705 /* Print an integer constant expression in assembler syntax.  Addition
12706    and subtraction are the only arithmetic that may appear in these
12707    expressions.  FILE is the stdio stream to write to, X is the rtx, and
12708    CODE is the operand print code from the output string.  */
12709
12710 static void
12711 output_pic_addr_const (FILE *file, rtx x, int code)
12712 {
12713   char buf[256];
12714
12715   switch (GET_CODE (x))
12716     {
12717     case PC:
12718       gcc_assert (flag_pic);
12719       putc ('.', file);
12720       break;
12721
12722     case SYMBOL_REF:
12723       if (TARGET_64BIT || ! TARGET_MACHO_BRANCH_ISLANDS)
12724         output_addr_const (file, x);
12725       else
12726         {
12727           const char *name = XSTR (x, 0);
12728
12729           /* Mark the decl as referenced so that cgraph will
12730              output the function.  */
12731           if (SYMBOL_REF_DECL (x))
12732             mark_decl_referenced (SYMBOL_REF_DECL (x));
12733
12734 #if TARGET_MACHO
12735           if (MACHOPIC_INDIRECT
12736               && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
12737             name = machopic_indirection_name (x, /*stub_p=*/true);
12738 #endif
12739           assemble_name (file, name);
12740         }
12741       if (!TARGET_MACHO && !(TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12742           && code == 'P' && ! SYMBOL_REF_LOCAL_P (x))
12743         fputs ("@PLT", file);
12744       break;
12745
12746     case LABEL_REF:
12747       x = XEXP (x, 0);
12748       /* FALLTHRU */
12749     case CODE_LABEL:
12750       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
12751       assemble_name (asm_out_file, buf);
12752       break;
12753
12754     case CONST_INT:
12755       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
12756       break;
12757
12758     case CONST:
12759       /* This used to output parentheses around the expression,
12760          but that does not work on the 386 (either ATT or BSD assembler).  */
12761       output_pic_addr_const (file, XEXP (x, 0), code);
12762       break;
12763
12764     case CONST_DOUBLE:
12765       if (GET_MODE (x) == VOIDmode)
12766         {
12767           /* We can use %d if the number is <32 bits and positive.  */
12768           if (CONST_DOUBLE_HIGH (x) || CONST_DOUBLE_LOW (x) < 0)
12769             fprintf (file, "0x%lx%08lx",
12770                      (unsigned long) CONST_DOUBLE_HIGH (x),
12771                      (unsigned long) CONST_DOUBLE_LOW (x));
12772           else
12773             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
12774         }
12775       else
12776         /* We can't handle floating point constants;
12777            TARGET_PRINT_OPERAND must handle them.  */
12778         output_operand_lossage ("floating constant misused");
12779       break;
12780
12781     case PLUS:
12782       /* Some assemblers need integer constants to appear first.  */
12783       if (CONST_INT_P (XEXP (x, 0)))
12784         {
12785           output_pic_addr_const (file, XEXP (x, 0), code);
12786           putc ('+', file);
12787           output_pic_addr_const (file, XEXP (x, 1), code);
12788         }
12789       else
12790         {
12791           gcc_assert (CONST_INT_P (XEXP (x, 1)));
12792           output_pic_addr_const (file, XEXP (x, 1), code);
12793           putc ('+', file);
12794           output_pic_addr_const (file, XEXP (x, 0), code);
12795         }
12796       break;
12797
12798     case MINUS:
12799       if (!TARGET_MACHO)
12800         putc (ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[', file);
12801       output_pic_addr_const (file, XEXP (x, 0), code);
12802       putc ('-', file);
12803       output_pic_addr_const (file, XEXP (x, 1), code);
12804       if (!TARGET_MACHO)
12805         putc (ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']', file);
12806       break;
12807
12808      case UNSPEC:
12809        if (XINT (x, 1) == UNSPEC_STACK_CHECK)
12810          {
12811            bool f = i386_asm_output_addr_const_extra (file, x);
12812            gcc_assert (f);
12813            break;
12814          }
12815
12816        gcc_assert (XVECLEN (x, 0) == 1);
12817        output_pic_addr_const (file, XVECEXP (x, 0, 0), code);
12818        switch (XINT (x, 1))
12819         {
12820         case UNSPEC_GOT:
12821           fputs ("@GOT", file);
12822           break;
12823         case UNSPEC_GOTOFF:
12824           fputs ("@GOTOFF", file);
12825           break;
12826         case UNSPEC_PLTOFF:
12827           fputs ("@PLTOFF", file);
12828           break;
12829         case UNSPEC_PCREL:
12830           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12831                  "(%rip)" : "[rip]", file);
12832           break;
12833         case UNSPEC_GOTPCREL:
12834           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12835                  "@GOTPCREL(%rip)" : "@GOTPCREL[rip]", file);
12836           break;
12837         case UNSPEC_GOTTPOFF:
12838           /* FIXME: This might be @TPOFF in Sun ld too.  */
12839           fputs ("@gottpoff", file);
12840           break;
12841         case UNSPEC_TPOFF:
12842           fputs ("@tpoff", file);
12843           break;
12844         case UNSPEC_NTPOFF:
12845           if (TARGET_64BIT)
12846             fputs ("@tpoff", file);
12847           else
12848             fputs ("@ntpoff", file);
12849           break;
12850         case UNSPEC_DTPOFF:
12851           fputs ("@dtpoff", file);
12852           break;
12853         case UNSPEC_GOTNTPOFF:
12854           if (TARGET_64BIT)
12855             fputs (ASSEMBLER_DIALECT == ASM_ATT ?
12856                    "@gottpoff(%rip)": "@gottpoff[rip]", file);
12857           else
12858             fputs ("@gotntpoff", file);
12859           break;
12860         case UNSPEC_INDNTPOFF:
12861           fputs ("@indntpoff", file);
12862           break;
12863 #if TARGET_MACHO
12864         case UNSPEC_MACHOPIC_OFFSET:
12865           putc ('-', file);
12866           machopic_output_function_base_name (file);
12867           break;
12868 #endif
12869         default:
12870           output_operand_lossage ("invalid UNSPEC as operand");
12871           break;
12872         }
12873        break;
12874
12875     default:
12876       output_operand_lossage ("invalid expression as operand");
12877     }
12878 }
12879
12880 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
12881    We need to emit DTP-relative relocations.  */
12882
12883 static void ATTRIBUTE_UNUSED
12884 i386_output_dwarf_dtprel (FILE *file, int size, rtx x)
12885 {
12886   fputs (ASM_LONG, file);
12887   output_addr_const (file, x);
12888   fputs ("@dtpoff", file);
12889   switch (size)
12890     {
12891     case 4:
12892       break;
12893     case 8:
12894       fputs (", 0", file);
12895       break;
12896     default:
12897       gcc_unreachable ();
12898    }
12899 }
12900
12901 /* Return true if X is a representation of the PIC register.  This copes
12902    with calls from ix86_find_base_term, where the register might have
12903    been replaced by a cselib value.  */
12904
12905 static bool
12906 ix86_pic_register_p (rtx x)
12907 {
12908   if (GET_CODE (x) == VALUE && CSELIB_VAL_PTR (x))
12909     return (pic_offset_table_rtx
12910             && rtx_equal_for_cselib_p (x, pic_offset_table_rtx));
12911   else
12912     return REG_P (x) && REGNO (x) == PIC_OFFSET_TABLE_REGNUM;
12913 }
12914
12915 /* Helper function for ix86_delegitimize_address.
12916    Attempt to delegitimize TLS local-exec accesses.  */
12917
12918 static rtx
12919 ix86_delegitimize_tls_address (rtx orig_x)
12920 {
12921   rtx x = orig_x, unspec;
12922   struct ix86_address addr;
12923
12924   if (!TARGET_TLS_DIRECT_SEG_REFS)
12925     return orig_x;
12926   if (MEM_P (x))
12927     x = XEXP (x, 0);
12928   if (GET_CODE (x) != PLUS || GET_MODE (x) != Pmode)
12929     return orig_x;
12930   if (ix86_decompose_address (x, &addr) == 0
12931       || addr.seg != (TARGET_64BIT ? SEG_FS : SEG_GS)
12932       || addr.disp == NULL_RTX
12933       || GET_CODE (addr.disp) != CONST)
12934     return orig_x;
12935   unspec = XEXP (addr.disp, 0);
12936   if (GET_CODE (unspec) == PLUS && CONST_INT_P (XEXP (unspec, 1)))
12937     unspec = XEXP (unspec, 0);
12938   if (GET_CODE (unspec) != UNSPEC || XINT (unspec, 1) != UNSPEC_NTPOFF)
12939     return orig_x;
12940   x = XVECEXP (unspec, 0, 0);
12941   gcc_assert (GET_CODE (x) == SYMBOL_REF);
12942   if (unspec != XEXP (addr.disp, 0))
12943     x = gen_rtx_PLUS (Pmode, x, XEXP (XEXP (addr.disp, 0), 1));
12944   if (addr.index)
12945     {
12946       rtx idx = addr.index;
12947       if (addr.scale != 1)
12948         idx = gen_rtx_MULT (Pmode, idx, GEN_INT (addr.scale));
12949       x = gen_rtx_PLUS (Pmode, idx, x);
12950     }
12951   if (addr.base)
12952     x = gen_rtx_PLUS (Pmode, addr.base, x);
12953   if (MEM_P (orig_x))
12954     x = replace_equiv_address_nv (orig_x, x);
12955   return x;
12956 }
12957
12958 /* In the name of slightly smaller debug output, and to cater to
12959    general assembler lossage, recognize PIC+GOTOFF and turn it back
12960    into a direct symbol reference.
12961
12962    On Darwin, this is necessary to avoid a crash, because Darwin
12963    has a different PIC label for each routine but the DWARF debugging
12964    information is not associated with any particular routine, so it's
12965    necessary to remove references to the PIC label from RTL stored by
12966    the DWARF output code.  */
12967
12968 static rtx
12969 ix86_delegitimize_address (rtx x)
12970 {
12971   rtx orig_x = delegitimize_mem_from_attrs (x);
12972   /* addend is NULL or some rtx if x is something+GOTOFF where
12973      something doesn't include the PIC register.  */
12974   rtx addend = NULL_RTX;
12975   /* reg_addend is NULL or a multiple of some register.  */
12976   rtx reg_addend = NULL_RTX;
12977   /* const_addend is NULL or a const_int.  */
12978   rtx const_addend = NULL_RTX;
12979   /* This is the result, or NULL.  */
12980   rtx result = NULL_RTX;
12981
12982   x = orig_x;
12983
12984   if (MEM_P (x))
12985     x = XEXP (x, 0);
12986
12987   if (TARGET_64BIT)
12988     {
12989       if (GET_CODE (x) != CONST
12990           || GET_CODE (XEXP (x, 0)) != UNSPEC
12991           || (XINT (XEXP (x, 0), 1) != UNSPEC_GOTPCREL
12992               && XINT (XEXP (x, 0), 1) != UNSPEC_PCREL)
12993           || !MEM_P (orig_x))
12994         return ix86_delegitimize_tls_address (orig_x);
12995       x = XVECEXP (XEXP (x, 0), 0, 0);
12996       if (GET_MODE (orig_x) != GET_MODE (x))
12997         {
12998           x = simplify_gen_subreg (GET_MODE (orig_x), x,
12999                                    GET_MODE (x), 0);
13000           if (x == NULL_RTX)
13001             return orig_x;
13002         }
13003       return x;
13004     }
13005
13006   if (GET_CODE (x) != PLUS
13007       || GET_CODE (XEXP (x, 1)) != CONST)
13008     return ix86_delegitimize_tls_address (orig_x);
13009
13010   if (ix86_pic_register_p (XEXP (x, 0)))
13011     /* %ebx + GOT/GOTOFF */
13012     ;
13013   else if (GET_CODE (XEXP (x, 0)) == PLUS)
13014     {
13015       /* %ebx + %reg * scale + GOT/GOTOFF */
13016       reg_addend = XEXP (x, 0);
13017       if (ix86_pic_register_p (XEXP (reg_addend, 0)))
13018         reg_addend = XEXP (reg_addend, 1);
13019       else if (ix86_pic_register_p (XEXP (reg_addend, 1)))
13020         reg_addend = XEXP (reg_addend, 0);
13021       else
13022         {
13023           reg_addend = NULL_RTX;
13024           addend = XEXP (x, 0);
13025         }
13026     }
13027   else
13028     addend = XEXP (x, 0);
13029
13030   x = XEXP (XEXP (x, 1), 0);
13031   if (GET_CODE (x) == PLUS
13032       && CONST_INT_P (XEXP (x, 1)))
13033     {
13034       const_addend = XEXP (x, 1);
13035       x = XEXP (x, 0);
13036     }
13037
13038   if (GET_CODE (x) == UNSPEC
13039       && ((XINT (x, 1) == UNSPEC_GOT && MEM_P (orig_x) && !addend)
13040           || (XINT (x, 1) == UNSPEC_GOTOFF && !MEM_P (orig_x))))
13041     result = XVECEXP (x, 0, 0);
13042
13043   if (TARGET_MACHO && darwin_local_data_pic (x)
13044       && !MEM_P (orig_x))
13045     result = XVECEXP (x, 0, 0);
13046
13047   if (! result)
13048     return ix86_delegitimize_tls_address (orig_x);
13049
13050   if (const_addend)
13051     result = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, result, const_addend));
13052   if (reg_addend)
13053     result = gen_rtx_PLUS (Pmode, reg_addend, result);
13054   if (addend)
13055     {
13056       /* If the rest of original X doesn't involve the PIC register, add
13057          addend and subtract pic_offset_table_rtx.  This can happen e.g.
13058          for code like:
13059          leal (%ebx, %ecx, 4), %ecx
13060          ...
13061          movl foo@GOTOFF(%ecx), %edx
13062          in which case we return (%ecx - %ebx) + foo.  */
13063       if (pic_offset_table_rtx)
13064         result = gen_rtx_PLUS (Pmode, gen_rtx_MINUS (Pmode, copy_rtx (addend),
13065                                                      pic_offset_table_rtx),
13066                                result);
13067       else
13068         return orig_x;
13069     }
13070   if (GET_MODE (orig_x) != Pmode && MEM_P (orig_x))
13071     {
13072       result = simplify_gen_subreg (GET_MODE (orig_x), result, Pmode, 0);
13073       if (result == NULL_RTX)
13074         return orig_x;
13075     }
13076   return result;
13077 }
13078
13079 /* If X is a machine specific address (i.e. a symbol or label being
13080    referenced as a displacement from the GOT implemented using an
13081    UNSPEC), then return the base term.  Otherwise return X.  */
13082
13083 rtx
13084 ix86_find_base_term (rtx x)
13085 {
13086   rtx term;
13087
13088   if (TARGET_64BIT)
13089     {
13090       if (GET_CODE (x) != CONST)
13091         return x;
13092       term = XEXP (x, 0);
13093       if (GET_CODE (term) == PLUS
13094           && (CONST_INT_P (XEXP (term, 1))
13095               || GET_CODE (XEXP (term, 1)) == CONST_DOUBLE))
13096         term = XEXP (term, 0);
13097       if (GET_CODE (term) != UNSPEC
13098           || (XINT (term, 1) != UNSPEC_GOTPCREL
13099               && XINT (term, 1) != UNSPEC_PCREL))
13100         return x;
13101
13102       return XVECEXP (term, 0, 0);
13103     }
13104
13105   return ix86_delegitimize_address (x);
13106 }
13107 \f
13108 static void
13109 put_condition_code (enum rtx_code code, enum machine_mode mode, int reverse,
13110                     int fp, FILE *file)
13111 {
13112   const char *suffix;
13113
13114   if (mode == CCFPmode || mode == CCFPUmode)
13115     {
13116       code = ix86_fp_compare_code_to_integer (code);
13117       mode = CCmode;
13118     }
13119   if (reverse)
13120     code = reverse_condition (code);
13121
13122   switch (code)
13123     {
13124     case EQ:
13125       switch (mode)
13126         {
13127         case CCAmode:
13128           suffix = "a";
13129           break;
13130
13131         case CCCmode:
13132           suffix = "c";
13133           break;
13134
13135         case CCOmode:
13136           suffix = "o";
13137           break;
13138
13139         case CCSmode:
13140           suffix = "s";
13141           break;
13142
13143         default:
13144           suffix = "e";
13145         }
13146       break;
13147     case NE:
13148       switch (mode)
13149         {
13150         case CCAmode:
13151           suffix = "na";
13152           break;
13153
13154         case CCCmode:
13155           suffix = "nc";
13156           break;
13157
13158         case CCOmode:
13159           suffix = "no";
13160           break;
13161
13162         case CCSmode:
13163           suffix = "ns";
13164           break;
13165
13166         default:
13167           suffix = "ne";
13168         }
13169       break;
13170     case GT:
13171       gcc_assert (mode == CCmode || mode == CCNOmode || mode == CCGCmode);
13172       suffix = "g";
13173       break;
13174     case GTU:
13175       /* ??? Use "nbe" instead of "a" for fcmov lossage on some assemblers.
13176          Those same assemblers have the same but opposite lossage on cmov.  */
13177       if (mode == CCmode)
13178         suffix = fp ? "nbe" : "a";
13179       else if (mode == CCCmode)
13180         suffix = "b";
13181       else
13182         gcc_unreachable ();
13183       break;
13184     case LT:
13185       switch (mode)
13186         {
13187         case CCNOmode:
13188         case CCGOCmode:
13189           suffix = "s";
13190           break;
13191
13192         case CCmode:
13193         case CCGCmode:
13194           suffix = "l";
13195           break;
13196
13197         default:
13198           gcc_unreachable ();
13199         }
13200       break;
13201     case LTU:
13202       gcc_assert (mode == CCmode || mode == CCCmode);
13203       suffix = "b";
13204       break;
13205     case GE:
13206       switch (mode)
13207         {
13208         case CCNOmode:
13209         case CCGOCmode:
13210           suffix = "ns";
13211           break;
13212
13213         case CCmode:
13214         case CCGCmode:
13215           suffix = "ge";
13216           break;
13217
13218         default:
13219           gcc_unreachable ();
13220         }
13221       break;
13222     case GEU:
13223       /* ??? As above.  */
13224       gcc_assert (mode == CCmode || mode == CCCmode);
13225       suffix = fp ? "nb" : "ae";
13226       break;
13227     case LE:
13228       gcc_assert (mode == CCmode || mode == CCGCmode || mode == CCNOmode);
13229       suffix = "le";
13230       break;
13231     case LEU:
13232       /* ??? As above.  */
13233       if (mode == CCmode)
13234         suffix = "be";
13235       else if (mode == CCCmode)
13236         suffix = fp ? "nb" : "ae";
13237       else
13238         gcc_unreachable ();
13239       break;
13240     case UNORDERED:
13241       suffix = fp ? "u" : "p";
13242       break;
13243     case ORDERED:
13244       suffix = fp ? "nu" : "np";
13245       break;
13246     default:
13247       gcc_unreachable ();
13248     }
13249   fputs (suffix, file);
13250 }
13251
13252 /* Print the name of register X to FILE based on its machine mode and number.
13253    If CODE is 'w', pretend the mode is HImode.
13254    If CODE is 'b', pretend the mode is QImode.
13255    If CODE is 'k', pretend the mode is SImode.
13256    If CODE is 'q', pretend the mode is DImode.
13257    If CODE is 'x', pretend the mode is V4SFmode.
13258    If CODE is 't', pretend the mode is V8SFmode.
13259    If CODE is 'h', pretend the reg is the 'high' byte register.
13260    If CODE is 'y', print "st(0)" instead of "st", if the reg is stack op.
13261    If CODE is 'd', duplicate the operand for AVX instruction.
13262  */
13263
13264 void
13265 print_reg (rtx x, int code, FILE *file)
13266 {
13267   const char *reg;
13268   bool duplicated = code == 'd' && TARGET_AVX;
13269
13270   gcc_assert (x == pc_rtx
13271               || (REGNO (x) != ARG_POINTER_REGNUM
13272                   && REGNO (x) != FRAME_POINTER_REGNUM
13273                   && REGNO (x) != FLAGS_REG
13274                   && REGNO (x) != FPSR_REG
13275                   && REGNO (x) != FPCR_REG));
13276
13277   if (ASSEMBLER_DIALECT == ASM_ATT)
13278     putc ('%', file);
13279
13280   if (x == pc_rtx)
13281     {
13282       gcc_assert (TARGET_64BIT);
13283       fputs ("rip", file);
13284       return;
13285     }
13286
13287   if (code == 'w' || MMX_REG_P (x))
13288     code = 2;
13289   else if (code == 'b')
13290     code = 1;
13291   else if (code == 'k')
13292     code = 4;
13293   else if (code == 'q')
13294     code = 8;
13295   else if (code == 'y')
13296     code = 3;
13297   else if (code == 'h')
13298     code = 0;
13299   else if (code == 'x')
13300     code = 16;
13301   else if (code == 't')
13302     code = 32;
13303   else
13304     code = GET_MODE_SIZE (GET_MODE (x));
13305
13306   /* Irritatingly, AMD extended registers use different naming convention
13307      from the normal registers.  */
13308   if (REX_INT_REG_P (x))
13309     {
13310       gcc_assert (TARGET_64BIT);
13311       switch (code)
13312         {
13313           case 0:
13314             error ("extended registers have no high halves");
13315             break;
13316           case 1:
13317             fprintf (file, "r%ib", REGNO (x) - FIRST_REX_INT_REG + 8);
13318             break;
13319           case 2:
13320             fprintf (file, "r%iw", REGNO (x) - FIRST_REX_INT_REG + 8);
13321             break;
13322           case 4:
13323             fprintf (file, "r%id", REGNO (x) - FIRST_REX_INT_REG + 8);
13324             break;
13325           case 8:
13326             fprintf (file, "r%i", REGNO (x) - FIRST_REX_INT_REG + 8);
13327             break;
13328           default:
13329             error ("unsupported operand size for extended register");
13330             break;
13331         }
13332       return;
13333     }
13334
13335   reg = NULL;
13336   switch (code)
13337     {
13338     case 3:
13339       if (STACK_TOP_P (x))
13340         {
13341           reg = "st(0)";
13342           break;
13343         }
13344       /* FALLTHRU */
13345     case 8:
13346     case 4:
13347     case 12:
13348       if (! ANY_FP_REG_P (x))
13349         putc (code == 8 && TARGET_64BIT ? 'r' : 'e', file);
13350       /* FALLTHRU */
13351     case 16:
13352     case 2:
13353     normal:
13354       reg = hi_reg_name[REGNO (x)];
13355       break;
13356     case 1:
13357       if (REGNO (x) >= ARRAY_SIZE (qi_reg_name))
13358         goto normal;
13359       reg = qi_reg_name[REGNO (x)];
13360       break;
13361     case 0:
13362       if (REGNO (x) >= ARRAY_SIZE (qi_high_reg_name))
13363         goto normal;
13364       reg = qi_high_reg_name[REGNO (x)];
13365       break;
13366     case 32:
13367       if (SSE_REG_P (x))
13368         {
13369           gcc_assert (!duplicated);
13370           putc ('y', file);
13371           fputs (hi_reg_name[REGNO (x)] + 1, file);
13372           return;
13373         }
13374       break;
13375     default:
13376       gcc_unreachable ();
13377     }
13378
13379   fputs (reg, file);
13380   if (duplicated)
13381     {
13382       if (ASSEMBLER_DIALECT == ASM_ATT)
13383         fprintf (file, ", %%%s", reg);
13384       else
13385         fprintf (file, ", %s", reg);
13386     }
13387 }
13388
13389 /* Locate some local-dynamic symbol still in use by this function
13390    so that we can print its name in some tls_local_dynamic_base
13391    pattern.  */
13392
13393 static int
13394 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
13395 {
13396   rtx x = *px;
13397
13398   if (GET_CODE (x) == SYMBOL_REF
13399       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
13400     {
13401       cfun->machine->some_ld_name = XSTR (x, 0);
13402       return 1;
13403     }
13404
13405   return 0;
13406 }
13407
13408 static const char *
13409 get_some_local_dynamic_name (void)
13410 {
13411   rtx insn;
13412
13413   if (cfun->machine->some_ld_name)
13414     return cfun->machine->some_ld_name;
13415
13416   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
13417     if (NONDEBUG_INSN_P (insn)
13418         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
13419       return cfun->machine->some_ld_name;
13420
13421   return NULL;
13422 }
13423
13424 /* Meaning of CODE:
13425    L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
13426    C -- print opcode suffix for set/cmov insn.
13427    c -- like C, but print reversed condition
13428    F,f -- likewise, but for floating-point.
13429    O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
13430         otherwise nothing
13431    R -- print the prefix for register names.
13432    z -- print the opcode suffix for the size of the current operand.
13433    Z -- likewise, with special suffixes for x87 instructions.
13434    * -- print a star (in certain assembler syntax)
13435    A -- print an absolute memory reference.
13436    w -- print the operand as if it's a "word" (HImode) even if it isn't.
13437    s -- print a shift double count, followed by the assemblers argument
13438         delimiter.
13439    b -- print the QImode name of the register for the indicated operand.
13440         %b0 would print %al if operands[0] is reg 0.
13441    w --  likewise, print the HImode name of the register.
13442    k --  likewise, print the SImode name of the register.
13443    q --  likewise, print the DImode name of the register.
13444    x --  likewise, print the V4SFmode name of the register.
13445    t --  likewise, print the V8SFmode name of the register.
13446    h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
13447    y -- print "st(0)" instead of "st" as a register.
13448    d -- print duplicated register operand for AVX instruction.
13449    D -- print condition for SSE cmp instruction.
13450    P -- if PIC, print an @PLT suffix.
13451    p -- print raw symbol name.
13452    X -- don't print any sort of PIC '@' suffix for a symbol.
13453    & -- print some in-use local-dynamic symbol name.
13454    H -- print a memory address offset by 8; used for sse high-parts
13455    Y -- print condition for XOP pcom* instruction.
13456    + -- print a branch hint as 'cs' or 'ds' prefix
13457    ; -- print a semicolon (after prefixes due to bug in older gas).
13458    @ -- print a segment register of thread base pointer load
13459  */
13460
13461 void
13462 ix86_print_operand (FILE *file, rtx x, int code)
13463 {
13464   if (code)
13465     {
13466       switch (code)
13467         {
13468         case '*':
13469           if (ASSEMBLER_DIALECT == ASM_ATT)
13470             putc ('*', file);
13471           return;
13472
13473         case '&':
13474           {
13475             const char *name = get_some_local_dynamic_name ();
13476             if (name == NULL)
13477               output_operand_lossage ("'%%&' used without any "
13478                                       "local dynamic TLS references");
13479             else
13480               assemble_name (file, name);
13481             return;
13482           }
13483
13484         case 'A':
13485           switch (ASSEMBLER_DIALECT)
13486             {
13487             case ASM_ATT:
13488               putc ('*', file);
13489               break;
13490
13491             case ASM_INTEL:
13492               /* Intel syntax. For absolute addresses, registers should not
13493                  be surrounded by braces.  */
13494               if (!REG_P (x))
13495                 {
13496                   putc ('[', file);
13497                   ix86_print_operand (file, x, 0);
13498                   putc (']', file);
13499                   return;
13500                 }
13501               break;
13502
13503             default:
13504               gcc_unreachable ();
13505             }
13506
13507           ix86_print_operand (file, x, 0);
13508           return;
13509
13510
13511         case 'L':
13512           if (ASSEMBLER_DIALECT == ASM_ATT)
13513             putc ('l', file);
13514           return;
13515
13516         case 'W':
13517           if (ASSEMBLER_DIALECT == ASM_ATT)
13518             putc ('w', file);
13519           return;
13520
13521         case 'B':
13522           if (ASSEMBLER_DIALECT == ASM_ATT)
13523             putc ('b', file);
13524           return;
13525
13526         case 'Q':
13527           if (ASSEMBLER_DIALECT == ASM_ATT)
13528             putc ('l', file);
13529           return;
13530
13531         case 'S':
13532           if (ASSEMBLER_DIALECT == ASM_ATT)
13533             putc ('s', file);
13534           return;
13535
13536         case 'T':
13537           if (ASSEMBLER_DIALECT == ASM_ATT)
13538             putc ('t', file);
13539           return;
13540
13541         case 'z':
13542           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13543             {
13544               /* Opcodes don't get size suffixes if using Intel opcodes.  */
13545               if (ASSEMBLER_DIALECT == ASM_INTEL)
13546                 return;
13547
13548               switch (GET_MODE_SIZE (GET_MODE (x)))
13549                 {
13550                 case 1:
13551                   putc ('b', file);
13552                   return;
13553
13554                 case 2:
13555                   putc ('w', file);
13556                   return;
13557
13558                 case 4:
13559                   putc ('l', file);
13560                   return;
13561
13562                 case 8:
13563                   putc ('q', file);
13564                   return;
13565
13566                 default:
13567                   output_operand_lossage
13568                     ("invalid operand size for operand code '%c'", code);
13569                   return;
13570                 }
13571             }
13572
13573           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13574             warning
13575               (0, "non-integer operand used with operand code '%c'", code);
13576           /* FALLTHRU */
13577
13578         case 'Z':
13579           /* 387 opcodes don't get size suffixes if using Intel opcodes.  */
13580           if (ASSEMBLER_DIALECT == ASM_INTEL)
13581             return;
13582
13583           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13584             {
13585               switch (GET_MODE_SIZE (GET_MODE (x)))
13586                 {
13587                 case 2:
13588 #ifdef HAVE_AS_IX86_FILDS
13589                   putc ('s', file);
13590 #endif
13591                   return;
13592
13593                 case 4:
13594                   putc ('l', file);
13595                   return;
13596
13597                 case 8:
13598 #ifdef HAVE_AS_IX86_FILDQ
13599                   putc ('q', file);
13600 #else
13601                   fputs ("ll", file);
13602 #endif
13603                   return;
13604
13605                 default:
13606                   break;
13607                 }
13608             }
13609           else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13610             {
13611               /* 387 opcodes don't get size suffixes
13612                  if the operands are registers.  */
13613               if (STACK_REG_P (x))
13614                 return;
13615
13616               switch (GET_MODE_SIZE (GET_MODE (x)))
13617                 {
13618                 case 4:
13619                   putc ('s', file);
13620                   return;
13621
13622                 case 8:
13623                   putc ('l', file);
13624                   return;
13625
13626                 case 12:
13627                 case 16:
13628                   putc ('t', file);
13629                   return;
13630
13631                 default:
13632                   break;
13633                 }
13634             }
13635           else
13636             {
13637               output_operand_lossage
13638                 ("invalid operand type used with operand code '%c'", code);
13639               return;
13640             }
13641
13642           output_operand_lossage
13643             ("invalid operand size for operand code '%c'", code);
13644           return;
13645
13646         case 'd':
13647         case 'b':
13648         case 'w':
13649         case 'k':
13650         case 'q':
13651         case 'h':
13652         case 't':
13653         case 'y':
13654         case 'x':
13655         case 'X':
13656         case 'P':
13657         case 'p':
13658           break;
13659
13660         case 's':
13661           if (CONST_INT_P (x) || ! SHIFT_DOUBLE_OMITS_COUNT)
13662             {
13663               ix86_print_operand (file, x, 0);
13664               fputs (", ", file);
13665             }
13666           return;
13667
13668         case 'D':
13669           /* Little bit of braindamage here.  The SSE compare instructions
13670              does use completely different names for the comparisons that the
13671              fp conditional moves.  */
13672           if (TARGET_AVX)
13673             {
13674               switch (GET_CODE (x))
13675                 {
13676                 case EQ:
13677                   fputs ("eq", file);
13678                   break;
13679                 case UNEQ:
13680                   fputs ("eq_us", file);
13681                   break;
13682                 case LT:
13683                   fputs ("lt", file);
13684                   break;
13685                 case UNLT:
13686                   fputs ("nge", file);
13687                   break;
13688                 case LE:
13689                   fputs ("le", file);
13690                   break;
13691                 case UNLE:
13692                   fputs ("ngt", file);
13693                   break;
13694                 case UNORDERED:
13695                   fputs ("unord", file);
13696                   break;
13697                 case NE:
13698                   fputs ("neq", file);
13699                   break;
13700                 case LTGT:
13701                   fputs ("neq_oq", file);
13702                   break;
13703                 case GE:
13704                   fputs ("ge", file);
13705                   break;
13706                 case UNGE:
13707                   fputs ("nlt", file);
13708                   break;
13709                 case GT:
13710                   fputs ("gt", file);
13711                   break;
13712                 case UNGT:
13713                   fputs ("nle", file);
13714                   break;
13715                 case ORDERED:
13716                   fputs ("ord", file);
13717                   break;
13718                 default:
13719                   output_operand_lossage ("operand is not a condition code, "
13720                                           "invalid operand code 'D'");
13721                   return;
13722                 }
13723             }
13724           else
13725             {
13726               switch (GET_CODE (x))
13727                 {
13728                 case EQ:
13729                 case UNEQ:
13730                   fputs ("eq", file);
13731                   break;
13732                 case LT:
13733                 case UNLT:
13734                   fputs ("lt", file);
13735                   break;
13736                 case LE:
13737                 case UNLE:
13738                   fputs ("le", file);
13739                   break;
13740                 case UNORDERED:
13741                   fputs ("unord", file);
13742                   break;
13743                 case NE:
13744                 case LTGT:
13745                   fputs ("neq", file);
13746                   break;
13747                 case UNGE:
13748                 case GE:
13749                   fputs ("nlt", file);
13750                   break;
13751                 case UNGT:
13752                 case GT:
13753                   fputs ("nle", file);
13754                   break;
13755                 case ORDERED:
13756                   fputs ("ord", file);
13757                   break;
13758                 default:
13759                   output_operand_lossage ("operand is not a condition code, "
13760                                           "invalid operand code 'D'");
13761                   return;
13762                 }
13763             }
13764           return;
13765         case 'O':
13766 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13767           if (ASSEMBLER_DIALECT == ASM_ATT)
13768             {
13769               switch (GET_MODE (x))
13770                 {
13771                 case HImode: putc ('w', file); break;
13772                 case SImode:
13773                 case SFmode: putc ('l', file); break;
13774                 case DImode:
13775                 case DFmode: putc ('q', file); break;
13776                 default: gcc_unreachable ();
13777                 }
13778               putc ('.', file);
13779             }
13780 #endif
13781           return;
13782         case 'C':
13783           if (!COMPARISON_P (x))
13784             {
13785               output_operand_lossage ("operand is neither a constant nor a "
13786                                       "condition code, invalid operand code "
13787                                       "'C'");
13788               return;
13789             }
13790           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 0, file);
13791           return;
13792         case 'F':
13793           if (!COMPARISON_P (x))
13794             {
13795               output_operand_lossage ("operand is neither a constant nor a "
13796                                       "condition code, invalid operand code "
13797                                       "'F'");
13798               return;
13799             }
13800 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13801           if (ASSEMBLER_DIALECT == ASM_ATT)
13802             putc ('.', file);
13803 #endif
13804           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 1, file);
13805           return;
13806
13807           /* Like above, but reverse condition */
13808         case 'c':
13809           /* Check to see if argument to %c is really a constant
13810              and not a condition code which needs to be reversed.  */
13811           if (!COMPARISON_P (x))
13812             {
13813               output_operand_lossage ("operand is neither a constant nor a "
13814                                       "condition code, invalid operand "
13815                                       "code 'c'");
13816               return;
13817             }
13818           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 0, file);
13819           return;
13820         case 'f':
13821           if (!COMPARISON_P (x))
13822             {
13823               output_operand_lossage ("operand is neither a constant nor a "
13824                                       "condition code, invalid operand "
13825                                       "code 'f'");
13826               return;
13827             }
13828 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
13829           if (ASSEMBLER_DIALECT == ASM_ATT)
13830             putc ('.', file);
13831 #endif
13832           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 1, file);
13833           return;
13834
13835         case 'H':
13836           /* It doesn't actually matter what mode we use here, as we're
13837              only going to use this for printing.  */
13838           x = adjust_address_nv (x, DImode, 8);
13839           break;
13840
13841         case '+':
13842           {
13843             rtx x;
13844
13845             if (!optimize
13846                 || optimize_function_for_size_p (cfun) || !TARGET_BRANCH_PREDICTION_HINTS)
13847               return;
13848
13849             x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
13850             if (x)
13851               {
13852                 int pred_val = INTVAL (XEXP (x, 0));
13853
13854                 if (pred_val < REG_BR_PROB_BASE * 45 / 100
13855                     || pred_val > REG_BR_PROB_BASE * 55 / 100)
13856                   {
13857                     int taken = pred_val > REG_BR_PROB_BASE / 2;
13858                     int cputaken = final_forward_branch_p (current_output_insn) == 0;
13859
13860                     /* Emit hints only in the case default branch prediction
13861                        heuristics would fail.  */
13862                     if (taken != cputaken)
13863                       {
13864                         /* We use 3e (DS) prefix for taken branches and
13865                            2e (CS) prefix for not taken branches.  */
13866                         if (taken)
13867                           fputs ("ds ; ", file);
13868                         else
13869                           fputs ("cs ; ", file);
13870                       }
13871                   }
13872               }
13873             return;
13874           }
13875
13876         case 'Y':
13877           switch (GET_CODE (x))
13878             {
13879             case NE:
13880               fputs ("neq", file);
13881               break;
13882             case EQ:
13883               fputs ("eq", file);
13884               break;
13885             case GE:
13886             case GEU:
13887               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "ge" : "unlt", file);
13888               break;
13889             case GT:
13890             case GTU:
13891               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "gt" : "unle", file);
13892               break;
13893             case LE:
13894             case LEU:
13895               fputs ("le", file);
13896               break;
13897             case LT:
13898             case LTU:
13899               fputs ("lt", file);
13900               break;
13901             case UNORDERED:
13902               fputs ("unord", file);
13903               break;
13904             case ORDERED:
13905               fputs ("ord", file);
13906               break;
13907             case UNEQ:
13908               fputs ("ueq", file);
13909               break;
13910             case UNGE:
13911               fputs ("nlt", file);
13912               break;
13913             case UNGT:
13914               fputs ("nle", file);
13915               break;
13916             case UNLE:
13917               fputs ("ule", file);
13918               break;
13919             case UNLT:
13920               fputs ("ult", file);
13921               break;
13922             case LTGT:
13923               fputs ("une", file);
13924               break;
13925             default:
13926               output_operand_lossage ("operand is not a condition code, "
13927                                       "invalid operand code 'Y'");
13928               return;
13929             }
13930           return;
13931
13932         case ';':
13933 #ifndef HAVE_AS_IX86_REP_LOCK_PREFIX
13934           putc (';', file);
13935 #endif
13936           return;
13937
13938         case '@':
13939           if (ASSEMBLER_DIALECT == ASM_ATT)
13940             putc ('%', file);
13941
13942           /* The kernel uses a different segment register for performance
13943              reasons; a system call would not have to trash the userspace
13944              segment register, which would be expensive.  */
13945           if (TARGET_64BIT && ix86_cmodel != CM_KERNEL)
13946             fputs ("fs", file);
13947           else
13948             fputs ("gs", file);
13949           return;
13950
13951         default:
13952             output_operand_lossage ("invalid operand code '%c'", code);
13953         }
13954     }
13955
13956   if (REG_P (x))
13957     print_reg (x, code, file);
13958
13959   else if (MEM_P (x))
13960     {
13961       /* No `byte ptr' prefix for call instructions or BLKmode operands.  */
13962       if (ASSEMBLER_DIALECT == ASM_INTEL && code != 'X' && code != 'P'
13963           && GET_MODE (x) != BLKmode)
13964         {
13965           const char * size;
13966           switch (GET_MODE_SIZE (GET_MODE (x)))
13967             {
13968             case 1: size = "BYTE"; break;
13969             case 2: size = "WORD"; break;
13970             case 4: size = "DWORD"; break;
13971             case 8: size = "QWORD"; break;
13972             case 12: size = "TBYTE"; break;
13973             case 16:
13974               if (GET_MODE (x) == XFmode)
13975                 size = "TBYTE";
13976               else
13977                 size = "XMMWORD";
13978               break;
13979             case 32: size = "YMMWORD"; break;
13980             default:
13981               gcc_unreachable ();
13982             }
13983
13984           /* Check for explicit size override (codes 'b', 'w' and 'k')  */
13985           if (code == 'b')
13986             size = "BYTE";
13987           else if (code == 'w')
13988             size = "WORD";
13989           else if (code == 'k')
13990             size = "DWORD";
13991
13992           fputs (size, file);
13993           fputs (" PTR ", file);
13994         }
13995
13996       x = XEXP (x, 0);
13997       /* Avoid (%rip) for call operands.  */
13998       if (CONSTANT_ADDRESS_P (x) && code == 'P'
13999           && !CONST_INT_P (x))
14000         output_addr_const (file, x);
14001       else if (this_is_asm_operands && ! address_operand (x, VOIDmode))
14002         output_operand_lossage ("invalid constraints for operand");
14003       else
14004         output_address (x);
14005     }
14006
14007   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == SFmode)
14008     {
14009       REAL_VALUE_TYPE r;
14010       long l;
14011
14012       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14013       REAL_VALUE_TO_TARGET_SINGLE (r, l);
14014
14015       if (ASSEMBLER_DIALECT == ASM_ATT)
14016         putc ('$', file);
14017       /* Sign extend 32bit SFmode immediate to 8 bytes.  */
14018       if (code == 'q')
14019         fprintf (file, "0x%08llx", (unsigned long long) (int) l);
14020       else
14021         fprintf (file, "0x%08x", (unsigned int) l);
14022     }
14023
14024   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == DFmode)
14025     {
14026       REAL_VALUE_TYPE r;
14027       long l[2];
14028
14029       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14030       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
14031
14032       if (ASSEMBLER_DIALECT == ASM_ATT)
14033         putc ('$', file);
14034       fprintf (file, "0x%lx%08lx", l[1] & 0xffffffff, l[0] & 0xffffffff);
14035     }
14036
14037   /* These float cases don't actually occur as immediate operands.  */
14038   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == XFmode)
14039     {
14040       char dstr[30];
14041
14042       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (x), sizeof (dstr), 0, 1);
14043       fputs (dstr, file);
14044     }
14045
14046   else
14047     {
14048       /* We have patterns that allow zero sets of memory, for instance.
14049          In 64-bit mode, we should probably support all 8-byte vectors,
14050          since we can in fact encode that into an immediate.  */
14051       if (GET_CODE (x) == CONST_VECTOR)
14052         {
14053           gcc_assert (x == CONST0_RTX (GET_MODE (x)));
14054           x = const0_rtx;
14055         }
14056
14057       if (code != 'P' && code != 'p')
14058         {
14059           if (CONST_INT_P (x) || GET_CODE (x) == CONST_DOUBLE)
14060             {
14061               if (ASSEMBLER_DIALECT == ASM_ATT)
14062                 putc ('$', file);
14063             }
14064           else if (GET_CODE (x) == CONST || GET_CODE (x) == SYMBOL_REF
14065                    || GET_CODE (x) == LABEL_REF)
14066             {
14067               if (ASSEMBLER_DIALECT == ASM_ATT)
14068                 putc ('$', file);
14069               else
14070                 fputs ("OFFSET FLAT:", file);
14071             }
14072         }
14073       if (CONST_INT_P (x))
14074         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
14075       else if (flag_pic || MACHOPIC_INDIRECT)
14076         output_pic_addr_const (file, x, code);
14077       else
14078         output_addr_const (file, x);
14079     }
14080 }
14081
14082 static bool
14083 ix86_print_operand_punct_valid_p (unsigned char code)
14084 {
14085   return (code == '@' || code == '*' || code == '+'
14086           || code == '&' || code == ';');
14087 }
14088 \f
14089 /* Print a memory operand whose address is ADDR.  */
14090
14091 static void
14092 ix86_print_operand_address (FILE *file, rtx addr)
14093 {
14094   struct ix86_address parts;
14095   rtx base, index, disp;
14096   int scale;
14097   int ok = ix86_decompose_address (addr, &parts);
14098
14099   gcc_assert (ok);
14100
14101   if (parts.base && GET_CODE (parts.base) == SUBREG)
14102     {
14103       rtx tmp = SUBREG_REG (parts.base);
14104       parts.base = simplify_subreg (GET_MODE (parts.base),
14105                                     tmp, GET_MODE (tmp), 0);
14106     }
14107
14108   if (parts.index && GET_CODE (parts.index) == SUBREG)
14109     {
14110       rtx tmp = SUBREG_REG (parts.index);
14111       parts.index = simplify_subreg (GET_MODE (parts.index),
14112                                      tmp, GET_MODE (tmp), 0);
14113     }
14114
14115   base = parts.base;
14116   index = parts.index;
14117   disp = parts.disp;
14118   scale = parts.scale;
14119
14120   switch (parts.seg)
14121     {
14122     case SEG_DEFAULT:
14123       break;
14124     case SEG_FS:
14125     case SEG_GS:
14126       if (ASSEMBLER_DIALECT == ASM_ATT)
14127         putc ('%', file);
14128       fputs ((parts.seg == SEG_FS ? "fs:" : "gs:"), file);
14129       break;
14130     default:
14131       gcc_unreachable ();
14132     }
14133
14134   /* Use one byte shorter RIP relative addressing for 64bit mode.  */
14135   if (TARGET_64BIT && !base && !index)
14136     {
14137       rtx symbol = disp;
14138
14139       if (GET_CODE (disp) == CONST
14140           && GET_CODE (XEXP (disp, 0)) == PLUS
14141           && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14142         symbol = XEXP (XEXP (disp, 0), 0);
14143
14144       if (GET_CODE (symbol) == LABEL_REF
14145           || (GET_CODE (symbol) == SYMBOL_REF
14146               && SYMBOL_REF_TLS_MODEL (symbol) == 0))
14147         base = pc_rtx;
14148     }
14149   if (!base && !index)
14150     {
14151       /* Displacement only requires special attention.  */
14152
14153       if (CONST_INT_P (disp))
14154         {
14155           if (ASSEMBLER_DIALECT == ASM_INTEL && parts.seg == SEG_DEFAULT)
14156             fputs ("ds:", file);
14157           fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (disp));
14158         }
14159       else if (flag_pic)
14160         output_pic_addr_const (file, disp, 0);
14161       else
14162         output_addr_const (file, disp);
14163     }
14164   else
14165     {
14166       /* Print DImode registers on 64bit targets to avoid addr32 prefixes.  */
14167       int code = TARGET_64BIT ? 'q' : 0;
14168
14169       if (ASSEMBLER_DIALECT == ASM_ATT)
14170         {
14171           if (disp)
14172             {
14173               if (flag_pic)
14174                 output_pic_addr_const (file, disp, 0);
14175               else if (GET_CODE (disp) == LABEL_REF)
14176                 output_asm_label (disp);
14177               else
14178                 output_addr_const (file, disp);
14179             }
14180
14181           putc ('(', file);
14182           if (base)
14183             print_reg (base, code, file);
14184           if (index)
14185             {
14186               putc (',', file);
14187               print_reg (index, code, file);
14188               if (scale != 1)
14189                 fprintf (file, ",%d", scale);
14190             }
14191           putc (')', file);
14192         }
14193       else
14194         {
14195           rtx offset = NULL_RTX;
14196
14197           if (disp)
14198             {
14199               /* Pull out the offset of a symbol; print any symbol itself.  */
14200               if (GET_CODE (disp) == CONST
14201                   && GET_CODE (XEXP (disp, 0)) == PLUS
14202                   && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14203                 {
14204                   offset = XEXP (XEXP (disp, 0), 1);
14205                   disp = gen_rtx_CONST (VOIDmode,
14206                                         XEXP (XEXP (disp, 0), 0));
14207                 }
14208
14209               if (flag_pic)
14210                 output_pic_addr_const (file, disp, 0);
14211               else if (GET_CODE (disp) == LABEL_REF)
14212                 output_asm_label (disp);
14213               else if (CONST_INT_P (disp))
14214                 offset = disp;
14215               else
14216                 output_addr_const (file, disp);
14217             }
14218
14219           putc ('[', file);
14220           if (base)
14221             {
14222               print_reg (base, code, file);
14223               if (offset)
14224                 {
14225                   if (INTVAL (offset) >= 0)
14226                     putc ('+', file);
14227                   fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14228                 }
14229             }
14230           else if (offset)
14231             fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14232           else
14233             putc ('0', file);
14234
14235           if (index)
14236             {
14237               putc ('+', file);
14238               print_reg (index, code, file);
14239               if (scale != 1)
14240                 fprintf (file, "*%d", scale);
14241             }
14242           putc (']', file);
14243         }
14244     }
14245 }
14246
14247 /* Implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA.  */
14248
14249 static bool
14250 i386_asm_output_addr_const_extra (FILE *file, rtx x)
14251 {
14252   rtx op;
14253
14254   if (GET_CODE (x) != UNSPEC)
14255     return false;
14256
14257   op = XVECEXP (x, 0, 0);
14258   switch (XINT (x, 1))
14259     {
14260     case UNSPEC_GOTTPOFF:
14261       output_addr_const (file, op);
14262       /* FIXME: This might be @TPOFF in Sun ld.  */
14263       fputs ("@gottpoff", file);
14264       break;
14265     case UNSPEC_TPOFF:
14266       output_addr_const (file, op);
14267       fputs ("@tpoff", file);
14268       break;
14269     case UNSPEC_NTPOFF:
14270       output_addr_const (file, op);
14271       if (TARGET_64BIT)
14272         fputs ("@tpoff", file);
14273       else
14274         fputs ("@ntpoff", file);
14275       break;
14276     case UNSPEC_DTPOFF:
14277       output_addr_const (file, op);
14278       fputs ("@dtpoff", file);
14279       break;
14280     case UNSPEC_GOTNTPOFF:
14281       output_addr_const (file, op);
14282       if (TARGET_64BIT)
14283         fputs (ASSEMBLER_DIALECT == ASM_ATT ?
14284                "@gottpoff(%rip)" : "@gottpoff[rip]", file);
14285       else
14286         fputs ("@gotntpoff", file);
14287       break;
14288     case UNSPEC_INDNTPOFF:
14289       output_addr_const (file, op);
14290       fputs ("@indntpoff", file);
14291       break;
14292 #if TARGET_MACHO
14293     case UNSPEC_MACHOPIC_OFFSET:
14294       output_addr_const (file, op);
14295       putc ('-', file);
14296       machopic_output_function_base_name (file);
14297       break;
14298 #endif
14299
14300     case UNSPEC_STACK_CHECK:
14301       {
14302         int offset;
14303
14304         gcc_assert (flag_split_stack);
14305
14306 #ifdef TARGET_THREAD_SPLIT_STACK_OFFSET
14307         offset = TARGET_THREAD_SPLIT_STACK_OFFSET;
14308 #else
14309         gcc_unreachable ();
14310 #endif
14311
14312         fprintf (file, "%s:%d", TARGET_64BIT ? "%fs" : "%gs", offset);
14313       }
14314       break;
14315
14316     default:
14317       return false;
14318     }
14319
14320   return true;
14321 }
14322 \f
14323 /* Split one or more double-mode RTL references into pairs of half-mode
14324    references.  The RTL can be REG, offsettable MEM, integer constant, or
14325    CONST_DOUBLE.  "operands" is a pointer to an array of double-mode RTLs to
14326    split and "num" is its length.  lo_half and hi_half are output arrays
14327    that parallel "operands".  */
14328
14329 void
14330 split_double_mode (enum machine_mode mode, rtx operands[],
14331                    int num, rtx lo_half[], rtx hi_half[])
14332 {
14333   enum machine_mode half_mode;
14334   unsigned int byte;
14335
14336   switch (mode)
14337     {
14338     case TImode:
14339       half_mode = DImode;
14340       break;
14341     case DImode:
14342       half_mode = SImode;
14343       break;
14344     default:
14345       gcc_unreachable ();
14346     }
14347
14348   byte = GET_MODE_SIZE (half_mode);
14349
14350   while (num--)
14351     {
14352       rtx op = operands[num];
14353
14354       /* simplify_subreg refuse to split volatile memory addresses,
14355          but we still have to handle it.  */
14356       if (MEM_P (op))
14357         {
14358           lo_half[num] = adjust_address (op, half_mode, 0);
14359           hi_half[num] = adjust_address (op, half_mode, byte);
14360         }
14361       else
14362         {
14363           lo_half[num] = simplify_gen_subreg (half_mode, op,
14364                                               GET_MODE (op) == VOIDmode
14365                                               ? mode : GET_MODE (op), 0);
14366           hi_half[num] = simplify_gen_subreg (half_mode, op,
14367                                               GET_MODE (op) == VOIDmode
14368                                               ? mode : GET_MODE (op), byte);
14369         }
14370     }
14371 }
14372 \f
14373 /* Output code to perform a 387 binary operation in INSN, one of PLUS,
14374    MINUS, MULT or DIV.  OPERANDS are the insn operands, where operands[3]
14375    is the expression of the binary operation.  The output may either be
14376    emitted here, or returned to the caller, like all output_* functions.
14377
14378    There is no guarantee that the operands are the same mode, as they
14379    might be within FLOAT or FLOAT_EXTEND expressions.  */
14380
14381 #ifndef SYSV386_COMPAT
14382 /* Set to 1 for compatibility with brain-damaged assemblers.  No-one
14383    wants to fix the assemblers because that causes incompatibility
14384    with gcc.  No-one wants to fix gcc because that causes
14385    incompatibility with assemblers...  You can use the option of
14386    -DSYSV386_COMPAT=0 if you recompile both gcc and gas this way.  */
14387 #define SYSV386_COMPAT 1
14388 #endif
14389
14390 const char *
14391 output_387_binary_op (rtx insn, rtx *operands)
14392 {
14393   static char buf[40];
14394   const char *p;
14395   const char *ssep;
14396   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]) || SSE_REG_P (operands[2]);
14397
14398 #ifdef ENABLE_CHECKING
14399   /* Even if we do not want to check the inputs, this documents input
14400      constraints.  Which helps in understanding the following code.  */
14401   if (STACK_REG_P (operands[0])
14402       && ((REG_P (operands[1])
14403            && REGNO (operands[0]) == REGNO (operands[1])
14404            && (STACK_REG_P (operands[2]) || MEM_P (operands[2])))
14405           || (REG_P (operands[2])
14406               && REGNO (operands[0]) == REGNO (operands[2])
14407               && (STACK_REG_P (operands[1]) || MEM_P (operands[1]))))
14408       && (STACK_TOP_P (operands[1]) || STACK_TOP_P (operands[2])))
14409     ; /* ok */
14410   else
14411     gcc_assert (is_sse);
14412 #endif
14413
14414   switch (GET_CODE (operands[3]))
14415     {
14416     case PLUS:
14417       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14418           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14419         p = "fiadd";
14420       else
14421         p = "fadd";
14422       ssep = "vadd";
14423       break;
14424
14425     case MINUS:
14426       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14427           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14428         p = "fisub";
14429       else
14430         p = "fsub";
14431       ssep = "vsub";
14432       break;
14433
14434     case MULT:
14435       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14436           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14437         p = "fimul";
14438       else
14439         p = "fmul";
14440       ssep = "vmul";
14441       break;
14442
14443     case DIV:
14444       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14445           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14446         p = "fidiv";
14447       else
14448         p = "fdiv";
14449       ssep = "vdiv";
14450       break;
14451
14452     default:
14453       gcc_unreachable ();
14454     }
14455
14456   if (is_sse)
14457    {
14458      if (TARGET_AVX)
14459        {
14460          strcpy (buf, ssep);
14461          if (GET_MODE (operands[0]) == SFmode)
14462            strcat (buf, "ss\t{%2, %1, %0|%0, %1, %2}");
14463          else
14464            strcat (buf, "sd\t{%2, %1, %0|%0, %1, %2}");
14465        }
14466      else
14467        {
14468          strcpy (buf, ssep + 1);
14469          if (GET_MODE (operands[0]) == SFmode)
14470            strcat (buf, "ss\t{%2, %0|%0, %2}");
14471          else
14472            strcat (buf, "sd\t{%2, %0|%0, %2}");
14473        }
14474       return buf;
14475    }
14476   strcpy (buf, p);
14477
14478   switch (GET_CODE (operands[3]))
14479     {
14480     case MULT:
14481     case PLUS:
14482       if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
14483         {
14484           rtx temp = operands[2];
14485           operands[2] = operands[1];
14486           operands[1] = temp;
14487         }
14488
14489       /* know operands[0] == operands[1].  */
14490
14491       if (MEM_P (operands[2]))
14492         {
14493           p = "%Z2\t%2";
14494           break;
14495         }
14496
14497       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14498         {
14499           if (STACK_TOP_P (operands[0]))
14500             /* How is it that we are storing to a dead operand[2]?
14501                Well, presumably operands[1] is dead too.  We can't
14502                store the result to st(0) as st(0) gets popped on this
14503                instruction.  Instead store to operands[2] (which I
14504                think has to be st(1)).  st(1) will be popped later.
14505                gcc <= 2.8.1 didn't have this check and generated
14506                assembly code that the Unixware assembler rejected.  */
14507             p = "p\t{%0, %2|%2, %0}";   /* st(1) = st(0) op st(1); pop */
14508           else
14509             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14510           break;
14511         }
14512
14513       if (STACK_TOP_P (operands[0]))
14514         p = "\t{%y2, %0|%0, %y2}";      /* st(0) = st(0) op st(r2) */
14515       else
14516         p = "\t{%2, %0|%0, %2}";        /* st(r1) = st(r1) op st(0) */
14517       break;
14518
14519     case MINUS:
14520     case DIV:
14521       if (MEM_P (operands[1]))
14522         {
14523           p = "r%Z1\t%1";
14524           break;
14525         }
14526
14527       if (MEM_P (operands[2]))
14528         {
14529           p = "%Z2\t%2";
14530           break;
14531         }
14532
14533       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14534         {
14535 #if SYSV386_COMPAT
14536           /* The SystemV/386 SVR3.2 assembler, and probably all AT&T
14537              derived assemblers, confusingly reverse the direction of
14538              the operation for fsub{r} and fdiv{r} when the
14539              destination register is not st(0).  The Intel assembler
14540              doesn't have this brain damage.  Read !SYSV386_COMPAT to
14541              figure out what the hardware really does.  */
14542           if (STACK_TOP_P (operands[0]))
14543             p = "{p\t%0, %2|rp\t%2, %0}";
14544           else
14545             p = "{rp\t%2, %0|p\t%0, %2}";
14546 #else
14547           if (STACK_TOP_P (operands[0]))
14548             /* As above for fmul/fadd, we can't store to st(0).  */
14549             p = "rp\t{%0, %2|%2, %0}";  /* st(1) = st(0) op st(1); pop */
14550           else
14551             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14552 #endif
14553           break;
14554         }
14555
14556       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
14557         {
14558 #if SYSV386_COMPAT
14559           if (STACK_TOP_P (operands[0]))
14560             p = "{rp\t%0, %1|p\t%1, %0}";
14561           else
14562             p = "{p\t%1, %0|rp\t%0, %1}";
14563 #else
14564           if (STACK_TOP_P (operands[0]))
14565             p = "p\t{%0, %1|%1, %0}";   /* st(1) = st(1) op st(0); pop */
14566           else
14567             p = "rp\t{%1, %0|%0, %1}";  /* st(r2) = st(0) op st(r2); pop */
14568 #endif
14569           break;
14570         }
14571
14572       if (STACK_TOP_P (operands[0]))
14573         {
14574           if (STACK_TOP_P (operands[1]))
14575             p = "\t{%y2, %0|%0, %y2}";  /* st(0) = st(0) op st(r2) */
14576           else
14577             p = "r\t{%y1, %0|%0, %y1}"; /* st(0) = st(r1) op st(0) */
14578           break;
14579         }
14580       else if (STACK_TOP_P (operands[1]))
14581         {
14582 #if SYSV386_COMPAT
14583           p = "{\t%1, %0|r\t%0, %1}";
14584 #else
14585           p = "r\t{%1, %0|%0, %1}";     /* st(r2) = st(0) op st(r2) */
14586 #endif
14587         }
14588       else
14589         {
14590 #if SYSV386_COMPAT
14591           p = "{r\t%2, %0|\t%0, %2}";
14592 #else
14593           p = "\t{%2, %0|%0, %2}";      /* st(r1) = st(r1) op st(0) */
14594 #endif
14595         }
14596       break;
14597
14598     default:
14599       gcc_unreachable ();
14600     }
14601
14602   strcat (buf, p);
14603   return buf;
14604 }
14605
14606 /* Return needed mode for entity in optimize_mode_switching pass.  */
14607
14608 int
14609 ix86_mode_needed (int entity, rtx insn)
14610 {
14611   enum attr_i387_cw mode;
14612
14613   /* The mode UNINITIALIZED is used to store control word after a
14614      function call or ASM pattern.  The mode ANY specify that function
14615      has no requirements on the control word and make no changes in the
14616      bits we are interested in.  */
14617
14618   if (CALL_P (insn)
14619       || (NONJUMP_INSN_P (insn)
14620           && (asm_noperands (PATTERN (insn)) >= 0
14621               || GET_CODE (PATTERN (insn)) == ASM_INPUT)))
14622     return I387_CW_UNINITIALIZED;
14623
14624   if (recog_memoized (insn) < 0)
14625     return I387_CW_ANY;
14626
14627   mode = get_attr_i387_cw (insn);
14628
14629   switch (entity)
14630     {
14631     case I387_TRUNC:
14632       if (mode == I387_CW_TRUNC)
14633         return mode;
14634       break;
14635
14636     case I387_FLOOR:
14637       if (mode == I387_CW_FLOOR)
14638         return mode;
14639       break;
14640
14641     case I387_CEIL:
14642       if (mode == I387_CW_CEIL)
14643         return mode;
14644       break;
14645
14646     case I387_MASK_PM:
14647       if (mode == I387_CW_MASK_PM)
14648         return mode;
14649       break;
14650
14651     default:
14652       gcc_unreachable ();
14653     }
14654
14655   return I387_CW_ANY;
14656 }
14657
14658 /* Output code to initialize control word copies used by trunc?f?i and
14659    rounding patterns.  CURRENT_MODE is set to current control word,
14660    while NEW_MODE is set to new control word.  */
14661
14662 void
14663 emit_i387_cw_initialization (int mode)
14664 {
14665   rtx stored_mode = assign_386_stack_local (HImode, SLOT_CW_STORED);
14666   rtx new_mode;
14667
14668   enum ix86_stack_slot slot;
14669
14670   rtx reg = gen_reg_rtx (HImode);
14671
14672   emit_insn (gen_x86_fnstcw_1 (stored_mode));
14673   emit_move_insn (reg, copy_rtx (stored_mode));
14674
14675   if (TARGET_64BIT || TARGET_PARTIAL_REG_STALL
14676       || optimize_function_for_size_p (cfun))
14677     {
14678       switch (mode)
14679         {
14680         case I387_CW_TRUNC:
14681           /* round toward zero (truncate) */
14682           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0c00)));
14683           slot = SLOT_CW_TRUNC;
14684           break;
14685
14686         case I387_CW_FLOOR:
14687           /* round down toward -oo */
14688           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14689           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0400)));
14690           slot = SLOT_CW_FLOOR;
14691           break;
14692
14693         case I387_CW_CEIL:
14694           /* round up toward +oo */
14695           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14696           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0800)));
14697           slot = SLOT_CW_CEIL;
14698           break;
14699
14700         case I387_CW_MASK_PM:
14701           /* mask precision exception for nearbyint() */
14702           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14703           slot = SLOT_CW_MASK_PM;
14704           break;
14705
14706         default:
14707           gcc_unreachable ();
14708         }
14709     }
14710   else
14711     {
14712       switch (mode)
14713         {
14714         case I387_CW_TRUNC:
14715           /* round toward zero (truncate) */
14716           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0xc)));
14717           slot = SLOT_CW_TRUNC;
14718           break;
14719
14720         case I387_CW_FLOOR:
14721           /* round down toward -oo */
14722           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x4)));
14723           slot = SLOT_CW_FLOOR;
14724           break;
14725
14726         case I387_CW_CEIL:
14727           /* round up toward +oo */
14728           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x8)));
14729           slot = SLOT_CW_CEIL;
14730           break;
14731
14732         case I387_CW_MASK_PM:
14733           /* mask precision exception for nearbyint() */
14734           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14735           slot = SLOT_CW_MASK_PM;
14736           break;
14737
14738         default:
14739           gcc_unreachable ();
14740         }
14741     }
14742
14743   gcc_assert (slot < MAX_386_STACK_LOCALS);
14744
14745   new_mode = assign_386_stack_local (HImode, slot);
14746   emit_move_insn (new_mode, reg);
14747 }
14748
14749 /* Output code for INSN to convert a float to a signed int.  OPERANDS
14750    are the insn operands.  The output may be [HSD]Imode and the input
14751    operand may be [SDX]Fmode.  */
14752
14753 const char *
14754 output_fix_trunc (rtx insn, rtx *operands, bool fisttp)
14755 {
14756   int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14757   int dimode_p = GET_MODE (operands[0]) == DImode;
14758   int round_mode = get_attr_i387_cw (insn);
14759
14760   /* Jump through a hoop or two for DImode, since the hardware has no
14761      non-popping instruction.  We used to do this a different way, but
14762      that was somewhat fragile and broke with post-reload splitters.  */
14763   if ((dimode_p || fisttp) && !stack_top_dies)
14764     output_asm_insn ("fld\t%y1", operands);
14765
14766   gcc_assert (STACK_TOP_P (operands[1]));
14767   gcc_assert (MEM_P (operands[0]));
14768   gcc_assert (GET_MODE (operands[1]) != TFmode);
14769
14770   if (fisttp)
14771       output_asm_insn ("fisttp%Z0\t%0", operands);
14772   else
14773     {
14774       if (round_mode != I387_CW_ANY)
14775         output_asm_insn ("fldcw\t%3", operands);
14776       if (stack_top_dies || dimode_p)
14777         output_asm_insn ("fistp%Z0\t%0", operands);
14778       else
14779         output_asm_insn ("fist%Z0\t%0", operands);
14780       if (round_mode != I387_CW_ANY)
14781         output_asm_insn ("fldcw\t%2", operands);
14782     }
14783
14784   return "";
14785 }
14786
14787 /* Output code for x87 ffreep insn.  The OPNO argument, which may only
14788    have the values zero or one, indicates the ffreep insn's operand
14789    from the OPERANDS array.  */
14790
14791 static const char *
14792 output_387_ffreep (rtx *operands ATTRIBUTE_UNUSED, int opno)
14793 {
14794   if (TARGET_USE_FFREEP)
14795 #ifdef HAVE_AS_IX86_FFREEP
14796     return opno ? "ffreep\t%y1" : "ffreep\t%y0";
14797 #else
14798     {
14799       static char retval[32];
14800       int regno = REGNO (operands[opno]);
14801
14802       gcc_assert (FP_REGNO_P (regno));
14803
14804       regno -= FIRST_STACK_REG;
14805
14806       snprintf (retval, sizeof (retval), ASM_SHORT "0xc%ddf", regno);
14807       return retval;
14808     }
14809 #endif
14810
14811   return opno ? "fstp\t%y1" : "fstp\t%y0";
14812 }
14813
14814
14815 /* Output code for INSN to compare OPERANDS.  EFLAGS_P is 1 when fcomi
14816    should be used.  UNORDERED_P is true when fucom should be used.  */
14817
14818 const char *
14819 output_fp_compare (rtx insn, rtx *operands, bool eflags_p, bool unordered_p)
14820 {
14821   int stack_top_dies;
14822   rtx cmp_op0, cmp_op1;
14823   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]);
14824
14825   if (eflags_p)
14826     {
14827       cmp_op0 = operands[0];
14828       cmp_op1 = operands[1];
14829     }
14830   else
14831     {
14832       cmp_op0 = operands[1];
14833       cmp_op1 = operands[2];
14834     }
14835
14836   if (is_sse)
14837     {
14838       static const char ucomiss[] = "vucomiss\t{%1, %0|%0, %1}";
14839       static const char ucomisd[] = "vucomisd\t{%1, %0|%0, %1}";
14840       static const char comiss[] = "vcomiss\t{%1, %0|%0, %1}";
14841       static const char comisd[] = "vcomisd\t{%1, %0|%0, %1}";
14842
14843       if (GET_MODE (operands[0]) == SFmode)
14844         if (unordered_p)
14845           return &ucomiss[TARGET_AVX ? 0 : 1];
14846         else
14847           return &comiss[TARGET_AVX ? 0 : 1];
14848       else
14849         if (unordered_p)
14850           return &ucomisd[TARGET_AVX ? 0 : 1];
14851         else
14852           return &comisd[TARGET_AVX ? 0 : 1];
14853     }
14854
14855   gcc_assert (STACK_TOP_P (cmp_op0));
14856
14857   stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
14858
14859   if (cmp_op1 == CONST0_RTX (GET_MODE (cmp_op1)))
14860     {
14861       if (stack_top_dies)
14862         {
14863           output_asm_insn ("ftst\n\tfnstsw\t%0", operands);
14864           return output_387_ffreep (operands, 1);
14865         }
14866       else
14867         return "ftst\n\tfnstsw\t%0";
14868     }
14869
14870   if (STACK_REG_P (cmp_op1)
14871       && stack_top_dies
14872       && find_regno_note (insn, REG_DEAD, REGNO (cmp_op1))
14873       && REGNO (cmp_op1) != FIRST_STACK_REG)
14874     {
14875       /* If both the top of the 387 stack dies, and the other operand
14876          is also a stack register that dies, then this must be a
14877          `fcompp' float compare */
14878
14879       if (eflags_p)
14880         {
14881           /* There is no double popping fcomi variant.  Fortunately,
14882              eflags is immune from the fstp's cc clobbering.  */
14883           if (unordered_p)
14884             output_asm_insn ("fucomip\t{%y1, %0|%0, %y1}", operands);
14885           else
14886             output_asm_insn ("fcomip\t{%y1, %0|%0, %y1}", operands);
14887           return output_387_ffreep (operands, 0);
14888         }
14889       else
14890         {
14891           if (unordered_p)
14892             return "fucompp\n\tfnstsw\t%0";
14893           else
14894             return "fcompp\n\tfnstsw\t%0";
14895         }
14896     }
14897   else
14898     {
14899       /* Encoded here as eflags_p | intmode | unordered_p | stack_top_dies.  */
14900
14901       static const char * const alt[16] =
14902       {
14903         "fcom%Z2\t%y2\n\tfnstsw\t%0",
14904         "fcomp%Z2\t%y2\n\tfnstsw\t%0",
14905         "fucom%Z2\t%y2\n\tfnstsw\t%0",
14906         "fucomp%Z2\t%y2\n\tfnstsw\t%0",
14907
14908         "ficom%Z2\t%y2\n\tfnstsw\t%0",
14909         "ficomp%Z2\t%y2\n\tfnstsw\t%0",
14910         NULL,
14911         NULL,
14912
14913         "fcomi\t{%y1, %0|%0, %y1}",
14914         "fcomip\t{%y1, %0|%0, %y1}",
14915         "fucomi\t{%y1, %0|%0, %y1}",
14916         "fucomip\t{%y1, %0|%0, %y1}",
14917
14918         NULL,
14919         NULL,
14920         NULL,
14921         NULL
14922       };
14923
14924       int mask;
14925       const char *ret;
14926
14927       mask  = eflags_p << 3;
14928       mask |= (GET_MODE_CLASS (GET_MODE (cmp_op1)) == MODE_INT) << 2;
14929       mask |= unordered_p << 1;
14930       mask |= stack_top_dies;
14931
14932       gcc_assert (mask < 16);
14933       ret = alt[mask];
14934       gcc_assert (ret);
14935
14936       return ret;
14937     }
14938 }
14939
14940 void
14941 ix86_output_addr_vec_elt (FILE *file, int value)
14942 {
14943   const char *directive = ASM_LONG;
14944
14945 #ifdef ASM_QUAD
14946   if (TARGET_LP64)
14947     directive = ASM_QUAD;
14948 #else
14949   gcc_assert (!TARGET_64BIT);
14950 #endif
14951
14952   fprintf (file, "%s%s%d\n", directive, LPREFIX, value);
14953 }
14954
14955 void
14956 ix86_output_addr_diff_elt (FILE *file, int value, int rel)
14957 {
14958   const char *directive = ASM_LONG;
14959
14960 #ifdef ASM_QUAD
14961   if (TARGET_64BIT && CASE_VECTOR_MODE == DImode)
14962     directive = ASM_QUAD;
14963 #else
14964   gcc_assert (!TARGET_64BIT);
14965 #endif
14966   /* We can't use @GOTOFF for text labels on VxWorks; see gotoff_operand.  */
14967   if (TARGET_64BIT || TARGET_VXWORKS_RTP)
14968     fprintf (file, "%s%s%d-%s%d\n",
14969              directive, LPREFIX, value, LPREFIX, rel);
14970   else if (HAVE_AS_GOTOFF_IN_DATA)
14971     fprintf (file, ASM_LONG "%s%d@GOTOFF\n", LPREFIX, value);
14972 #if TARGET_MACHO
14973   else if (TARGET_MACHO)
14974     {
14975       fprintf (file, ASM_LONG "%s%d-", LPREFIX, value);
14976       machopic_output_function_base_name (file);
14977       putc ('\n', file);
14978     }
14979 #endif
14980   else
14981     asm_fprintf (file, ASM_LONG "%U%s+[.-%s%d]\n",
14982                  GOT_SYMBOL_NAME, LPREFIX, value);
14983 }
14984 \f
14985 /* Generate either "mov $0, reg" or "xor reg, reg", as appropriate
14986    for the target.  */
14987
14988 void
14989 ix86_expand_clear (rtx dest)
14990 {
14991   rtx tmp;
14992
14993   /* We play register width games, which are only valid after reload.  */
14994   gcc_assert (reload_completed);
14995
14996   /* Avoid HImode and its attendant prefix byte.  */
14997   if (GET_MODE_SIZE (GET_MODE (dest)) < 4)
14998     dest = gen_rtx_REG (SImode, REGNO (dest));
14999   tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx);
15000
15001   /* This predicate should match that for movsi_xor and movdi_xor_rex64.  */
15002   if (!TARGET_USE_MOV0 || optimize_insn_for_speed_p ())
15003     {
15004       rtx clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15005       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, clob));
15006     }
15007
15008   emit_insn (tmp);
15009 }
15010
15011 /* X is an unchanging MEM.  If it is a constant pool reference, return
15012    the constant pool rtx, else NULL.  */
15013
15014 rtx
15015 maybe_get_pool_constant (rtx x)
15016 {
15017   x = ix86_delegitimize_address (XEXP (x, 0));
15018
15019   if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
15020     return get_pool_constant (x);
15021
15022   return NULL_RTX;
15023 }
15024
15025 void
15026 ix86_expand_move (enum machine_mode mode, rtx operands[])
15027 {
15028   rtx op0, op1;
15029   enum tls_model model;
15030
15031   op0 = operands[0];
15032   op1 = operands[1];
15033
15034   if (GET_CODE (op1) == SYMBOL_REF)
15035     {
15036       model = SYMBOL_REF_TLS_MODEL (op1);
15037       if (model)
15038         {
15039           op1 = legitimize_tls_address (op1, model, true);
15040           op1 = force_operand (op1, op0);
15041           if (op1 == op0)
15042             return;
15043           if (GET_MODE (op1) != mode)
15044             op1 = convert_to_mode (mode, op1, 1);
15045         }
15046       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15047                && SYMBOL_REF_DLLIMPORT_P (op1))
15048         op1 = legitimize_dllimport_symbol (op1, false);
15049     }
15050   else if (GET_CODE (op1) == CONST
15051            && GET_CODE (XEXP (op1, 0)) == PLUS
15052            && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SYMBOL_REF)
15053     {
15054       rtx addend = XEXP (XEXP (op1, 0), 1);
15055       rtx symbol = XEXP (XEXP (op1, 0), 0);
15056       rtx tmp = NULL;
15057
15058       model = SYMBOL_REF_TLS_MODEL (symbol);
15059       if (model)
15060         tmp = legitimize_tls_address (symbol, model, true);
15061       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15062                && SYMBOL_REF_DLLIMPORT_P (symbol))
15063         tmp = legitimize_dllimport_symbol (symbol, true);
15064
15065       if (tmp)
15066         {
15067           tmp = force_operand (tmp, NULL);
15068           tmp = expand_simple_binop (Pmode, PLUS, tmp, addend,
15069                                      op0, 1, OPTAB_DIRECT);
15070           if (tmp == op0)
15071             return;
15072           if (GET_MODE (tmp) != mode)
15073             op1 = convert_to_mode (mode, tmp, 1);
15074         }
15075     }
15076
15077   if ((flag_pic || MACHOPIC_INDIRECT)
15078       && symbolic_operand (op1, mode))
15079     {
15080       if (TARGET_MACHO && !TARGET_64BIT)
15081         {
15082 #if TARGET_MACHO
15083           /* dynamic-no-pic */
15084           if (MACHOPIC_INDIRECT)
15085             {
15086               rtx temp = ((reload_in_progress
15087                            || ((op0 && REG_P (op0))
15088                                && mode == Pmode))
15089                           ? op0 : gen_reg_rtx (Pmode));
15090               op1 = machopic_indirect_data_reference (op1, temp);
15091               if (MACHOPIC_PURE)
15092                 op1 = machopic_legitimize_pic_address (op1, mode,
15093                                                        temp == op1 ? 0 : temp);
15094             }
15095           if (op0 != op1 && GET_CODE (op0) != MEM)
15096             {
15097               rtx insn = gen_rtx_SET (VOIDmode, op0, op1);
15098               emit_insn (insn);
15099               return;
15100             }
15101           if (GET_CODE (op0) == MEM)
15102             op1 = force_reg (Pmode, op1);
15103           else
15104             {
15105               rtx temp = op0;
15106               if (GET_CODE (temp) != REG)
15107                 temp = gen_reg_rtx (Pmode);
15108               temp = legitimize_pic_address (op1, temp);
15109               if (temp == op0)
15110             return;
15111               op1 = temp;
15112             }
15113       /* dynamic-no-pic */
15114 #endif
15115         }
15116       else
15117         {
15118           if (MEM_P (op0))
15119             op1 = force_reg (mode, op1);
15120           else if (!(TARGET_64BIT && x86_64_movabs_operand (op1, DImode)))
15121             {
15122               rtx reg = can_create_pseudo_p () ? NULL_RTX : op0;
15123               op1 = legitimize_pic_address (op1, reg);
15124               if (op0 == op1)
15125                 return;
15126               if (GET_MODE (op1) != mode)
15127                 op1 = convert_to_mode (mode, op1, 1);
15128             }
15129         }
15130     }
15131   else
15132     {
15133       if (MEM_P (op0)
15134           && (PUSH_ROUNDING (GET_MODE_SIZE (mode)) != GET_MODE_SIZE (mode)
15135               || !push_operand (op0, mode))
15136           && MEM_P (op1))
15137         op1 = force_reg (mode, op1);
15138
15139       if (push_operand (op0, mode)
15140           && ! general_no_elim_operand (op1, mode))
15141         op1 = copy_to_mode_reg (mode, op1);
15142
15143       /* Force large constants in 64bit compilation into register
15144          to get them CSEed.  */
15145       if (can_create_pseudo_p ()
15146           && (mode == DImode) && TARGET_64BIT
15147           && immediate_operand (op1, mode)
15148           && !x86_64_zext_immediate_operand (op1, VOIDmode)
15149           && !register_operand (op0, mode)
15150           && optimize)
15151         op1 = copy_to_mode_reg (mode, op1);
15152
15153       if (can_create_pseudo_p ()
15154           && FLOAT_MODE_P (mode)
15155           && GET_CODE (op1) == CONST_DOUBLE)
15156         {
15157           /* If we are loading a floating point constant to a register,
15158              force the value to memory now, since we'll get better code
15159              out the back end.  */
15160
15161           op1 = validize_mem (force_const_mem (mode, op1));
15162           if (!register_operand (op0, mode))
15163             {
15164               rtx temp = gen_reg_rtx (mode);
15165               emit_insn (gen_rtx_SET (VOIDmode, temp, op1));
15166               emit_move_insn (op0, temp);
15167               return;
15168             }
15169         }
15170     }
15171
15172   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15173 }
15174
15175 void
15176 ix86_expand_vector_move (enum machine_mode mode, rtx operands[])
15177 {
15178   rtx op0 = operands[0], op1 = operands[1];
15179   unsigned int align = GET_MODE_ALIGNMENT (mode);
15180
15181   /* Force constants other than zero into memory.  We do not know how
15182      the instructions used to build constants modify the upper 64 bits
15183      of the register, once we have that information we may be able
15184      to handle some of them more efficiently.  */
15185   if (can_create_pseudo_p ()
15186       && register_operand (op0, mode)
15187       && (CONSTANT_P (op1)
15188           || (GET_CODE (op1) == SUBREG
15189               && CONSTANT_P (SUBREG_REG (op1))))
15190       && !standard_sse_constant_p (op1))
15191     op1 = validize_mem (force_const_mem (mode, op1));
15192
15193   /* We need to check memory alignment for SSE mode since attribute
15194      can make operands unaligned.  */
15195   if (can_create_pseudo_p ()
15196       && SSE_REG_MODE_P (mode)
15197       && ((MEM_P (op0) && (MEM_ALIGN (op0) < align))
15198           || (MEM_P (op1) && (MEM_ALIGN (op1) < align))))
15199     {
15200       rtx tmp[2];
15201
15202       /* ix86_expand_vector_move_misalign() does not like constants ... */
15203       if (CONSTANT_P (op1)
15204           || (GET_CODE (op1) == SUBREG
15205               && CONSTANT_P (SUBREG_REG (op1))))
15206         op1 = validize_mem (force_const_mem (mode, op1));
15207
15208       /* ... nor both arguments in memory.  */
15209       if (!register_operand (op0, mode)
15210           && !register_operand (op1, mode))
15211         op1 = force_reg (mode, op1);
15212
15213       tmp[0] = op0; tmp[1] = op1;
15214       ix86_expand_vector_move_misalign (mode, tmp);
15215       return;
15216     }
15217
15218   /* Make operand1 a register if it isn't already.  */
15219   if (can_create_pseudo_p ()
15220       && !register_operand (op0, mode)
15221       && !register_operand (op1, mode))
15222     {
15223       emit_move_insn (op0, force_reg (GET_MODE (op0), op1));
15224       return;
15225     }
15226
15227   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15228 }
15229
15230 /* Split 32-byte AVX unaligned load and store if needed.  */
15231
15232 static void
15233 ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
15234 {
15235   rtx m;
15236   rtx (*extract) (rtx, rtx, rtx);
15237   rtx (*move_unaligned) (rtx, rtx);
15238   enum machine_mode mode;
15239
15240   switch (GET_MODE (op0))
15241     {
15242     default:
15243       gcc_unreachable ();
15244     case V32QImode:
15245       extract = gen_avx_vextractf128v32qi;
15246       move_unaligned = gen_avx_movdqu256;
15247       mode = V16QImode;
15248       break;
15249     case V8SFmode:
15250       extract = gen_avx_vextractf128v8sf;
15251       move_unaligned = gen_avx_movups256;
15252       mode = V4SFmode;
15253       break;
15254     case V4DFmode:
15255       extract = gen_avx_vextractf128v4df;
15256       move_unaligned = gen_avx_movupd256;
15257       mode = V2DFmode;
15258       break;
15259     }
15260
15261   if (MEM_P (op1) && TARGET_AVX256_SPLIT_UNALIGNED_LOAD)
15262     {
15263       rtx r = gen_reg_rtx (mode);
15264       m = adjust_address (op1, mode, 0);
15265       emit_move_insn (r, m);
15266       m = adjust_address (op1, mode, 16);
15267       r = gen_rtx_VEC_CONCAT (GET_MODE (op0), r, m);
15268       emit_move_insn (op0, r);
15269     }
15270   else if (MEM_P (op0) && TARGET_AVX256_SPLIT_UNALIGNED_STORE)
15271     {
15272       m = adjust_address (op0, mode, 0);
15273       emit_insn (extract (m, op1, const0_rtx));
15274       m = adjust_address (op0, mode, 16);
15275       emit_insn (extract (m, op1, const1_rtx));
15276     }
15277   else
15278     emit_insn (move_unaligned (op0, op1));
15279 }
15280
15281 /* Implement the movmisalign patterns for SSE.  Non-SSE modes go
15282    straight to ix86_expand_vector_move.  */
15283 /* Code generation for scalar reg-reg moves of single and double precision data:
15284      if (x86_sse_partial_reg_dependency == true | x86_sse_split_regs == true)
15285        movaps reg, reg
15286      else
15287        movss reg, reg
15288      if (x86_sse_partial_reg_dependency == true)
15289        movapd reg, reg
15290      else
15291        movsd reg, reg
15292
15293    Code generation for scalar loads of double precision data:
15294      if (x86_sse_split_regs == true)
15295        movlpd mem, reg      (gas syntax)
15296      else
15297        movsd mem, reg
15298
15299    Code generation for unaligned packed loads of single precision data
15300    (x86_sse_unaligned_move_optimal overrides x86_sse_partial_reg_dependency):
15301      if (x86_sse_unaligned_move_optimal)
15302        movups mem, reg
15303
15304      if (x86_sse_partial_reg_dependency == true)
15305        {
15306          xorps  reg, reg
15307          movlps mem, reg
15308          movhps mem+8, reg
15309        }
15310      else
15311        {
15312          movlps mem, reg
15313          movhps mem+8, reg
15314        }
15315
15316    Code generation for unaligned packed loads of double precision data
15317    (x86_sse_unaligned_move_optimal overrides x86_sse_split_regs):
15318      if (x86_sse_unaligned_move_optimal)
15319        movupd mem, reg
15320
15321      if (x86_sse_split_regs == true)
15322        {
15323          movlpd mem, reg
15324          movhpd mem+8, reg
15325        }
15326      else
15327        {
15328          movsd  mem, reg
15329          movhpd mem+8, reg
15330        }
15331  */
15332
15333 void
15334 ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[])
15335 {
15336   rtx op0, op1, m;
15337
15338   op0 = operands[0];
15339   op1 = operands[1];
15340
15341   if (TARGET_AVX)
15342     {
15343       switch (GET_MODE_CLASS (mode))
15344         {
15345         case MODE_VECTOR_INT:
15346         case MODE_INT:
15347           switch (GET_MODE_SIZE (mode))
15348             {
15349             case 16:
15350               /*  If we're optimizing for size, movups is the smallest.  */
15351               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15352                 {
15353                   op0 = gen_lowpart (V4SFmode, op0);
15354                   op1 = gen_lowpart (V4SFmode, op1);
15355                   emit_insn (gen_sse_movups (op0, op1));
15356                   return;
15357                 }
15358               op0 = gen_lowpart (V16QImode, op0);
15359               op1 = gen_lowpart (V16QImode, op1);
15360               emit_insn (gen_sse2_movdqu (op0, op1));
15361               break;
15362             case 32:
15363               op0 = gen_lowpart (V32QImode, op0);
15364               op1 = gen_lowpart (V32QImode, op1);
15365               ix86_avx256_split_vector_move_misalign (op0, op1);
15366               break;
15367             default:
15368               gcc_unreachable ();
15369             }
15370           break;
15371         case MODE_VECTOR_FLOAT:
15372           op0 = gen_lowpart (mode, op0);
15373           op1 = gen_lowpart (mode, op1);
15374
15375           switch (mode)
15376             {
15377             case V4SFmode:
15378               emit_insn (gen_sse_movups (op0, op1));
15379               break;
15380             case V8SFmode:
15381               ix86_avx256_split_vector_move_misalign (op0, op1);
15382               break;
15383             case V2DFmode:
15384               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15385                 {
15386                   op0 = gen_lowpart (V4SFmode, op0);
15387                   op1 = gen_lowpart (V4SFmode, op1);
15388                   emit_insn (gen_sse_movups (op0, op1));
15389                   return;
15390                 }
15391               emit_insn (gen_sse2_movupd (op0, op1));
15392               break;
15393             case V4DFmode:
15394               ix86_avx256_split_vector_move_misalign (op0, op1);
15395               break;
15396             default:
15397               gcc_unreachable ();
15398             }
15399           break;
15400
15401         default:
15402           gcc_unreachable ();
15403         }
15404
15405       return;
15406     }
15407
15408   if (MEM_P (op1))
15409     {
15410       /* If we're optimizing for size, movups is the smallest.  */
15411       if (optimize_insn_for_size_p ()
15412           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15413         {
15414           op0 = gen_lowpart (V4SFmode, op0);
15415           op1 = gen_lowpart (V4SFmode, op1);
15416           emit_insn (gen_sse_movups (op0, op1));
15417           return;
15418         }
15419
15420       /* ??? If we have typed data, then it would appear that using
15421          movdqu is the only way to get unaligned data loaded with
15422          integer type.  */
15423       if (TARGET_SSE2 && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15424         {
15425           op0 = gen_lowpart (V16QImode, op0);
15426           op1 = gen_lowpart (V16QImode, op1);
15427           emit_insn (gen_sse2_movdqu (op0, op1));
15428           return;
15429         }
15430
15431       if (TARGET_SSE2 && mode == V2DFmode)
15432         {
15433           rtx zero;
15434
15435           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15436             {
15437               op0 = gen_lowpart (V2DFmode, op0);
15438               op1 = gen_lowpart (V2DFmode, op1);
15439               emit_insn (gen_sse2_movupd (op0, op1));
15440               return;
15441             }
15442
15443           /* When SSE registers are split into halves, we can avoid
15444              writing to the top half twice.  */
15445           if (TARGET_SSE_SPLIT_REGS)
15446             {
15447               emit_clobber (op0);
15448               zero = op0;
15449             }
15450           else
15451             {
15452               /* ??? Not sure about the best option for the Intel chips.
15453                  The following would seem to satisfy; the register is
15454                  entirely cleared, breaking the dependency chain.  We
15455                  then store to the upper half, with a dependency depth
15456                  of one.  A rumor has it that Intel recommends two movsd
15457                  followed by an unpacklpd, but this is unconfirmed.  And
15458                  given that the dependency depth of the unpacklpd would
15459                  still be one, I'm not sure why this would be better.  */
15460               zero = CONST0_RTX (V2DFmode);
15461             }
15462
15463           m = adjust_address (op1, DFmode, 0);
15464           emit_insn (gen_sse2_loadlpd (op0, zero, m));
15465           m = adjust_address (op1, DFmode, 8);
15466           emit_insn (gen_sse2_loadhpd (op0, op0, m));
15467         }
15468       else
15469         {
15470           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15471             {
15472               op0 = gen_lowpart (V4SFmode, op0);
15473               op1 = gen_lowpart (V4SFmode, op1);
15474               emit_insn (gen_sse_movups (op0, op1));
15475               return;
15476             }
15477
15478           if (TARGET_SSE_PARTIAL_REG_DEPENDENCY)
15479             emit_move_insn (op0, CONST0_RTX (mode));
15480           else
15481             emit_clobber (op0);
15482
15483           if (mode != V4SFmode)
15484             op0 = gen_lowpart (V4SFmode, op0);
15485           m = adjust_address (op1, V2SFmode, 0);
15486           emit_insn (gen_sse_loadlps (op0, op0, m));
15487           m = adjust_address (op1, V2SFmode, 8);
15488           emit_insn (gen_sse_loadhps (op0, op0, m));
15489         }
15490     }
15491   else if (MEM_P (op0))
15492     {
15493       /* If we're optimizing for size, movups is the smallest.  */
15494       if (optimize_insn_for_size_p ()
15495           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15496         {
15497           op0 = gen_lowpart (V4SFmode, op0);
15498           op1 = gen_lowpart (V4SFmode, op1);
15499           emit_insn (gen_sse_movups (op0, op1));
15500           return;
15501         }
15502
15503       /* ??? Similar to above, only less clear because of quote
15504          typeless stores unquote.  */
15505       if (TARGET_SSE2 && !TARGET_SSE_TYPELESS_STORES
15506           && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15507         {
15508           op0 = gen_lowpart (V16QImode, op0);
15509           op1 = gen_lowpart (V16QImode, op1);
15510           emit_insn (gen_sse2_movdqu (op0, op1));
15511           return;
15512         }
15513
15514       if (TARGET_SSE2 && mode == V2DFmode)
15515         {
15516           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15517             {
15518               op0 = gen_lowpart (V2DFmode, op0);
15519               op1 = gen_lowpart (V2DFmode, op1);
15520               emit_insn (gen_sse2_movupd (op0, op1));
15521             }
15522           else
15523             {
15524               m = adjust_address (op0, DFmode, 0);
15525               emit_insn (gen_sse2_storelpd (m, op1));
15526               m = adjust_address (op0, DFmode, 8);
15527               emit_insn (gen_sse2_storehpd (m, op1));
15528             }
15529         }
15530       else
15531         {
15532           if (mode != V4SFmode)
15533             op1 = gen_lowpart (V4SFmode, op1);
15534
15535           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15536             {
15537               op0 = gen_lowpart (V4SFmode, op0);
15538               emit_insn (gen_sse_movups (op0, op1));
15539             }
15540           else
15541             {
15542               m = adjust_address (op0, V2SFmode, 0);
15543               emit_insn (gen_sse_storelps (m, op1));
15544               m = adjust_address (op0, V2SFmode, 8);
15545               emit_insn (gen_sse_storehps (m, op1));
15546             }
15547         }
15548     }
15549   else
15550     gcc_unreachable ();
15551 }
15552
15553 /* Expand a push in MODE.  This is some mode for which we do not support
15554    proper push instructions, at least from the registers that we expect
15555    the value to live in.  */
15556
15557 void
15558 ix86_expand_push (enum machine_mode mode, rtx x)
15559 {
15560   rtx tmp;
15561
15562   tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
15563                              GEN_INT (-GET_MODE_SIZE (mode)),
15564                              stack_pointer_rtx, 1, OPTAB_DIRECT);
15565   if (tmp != stack_pointer_rtx)
15566     emit_move_insn (stack_pointer_rtx, tmp);
15567
15568   tmp = gen_rtx_MEM (mode, stack_pointer_rtx);
15569
15570   /* When we push an operand onto stack, it has to be aligned at least
15571      at the function argument boundary.  However since we don't have
15572      the argument type, we can't determine the actual argument
15573      boundary.  */
15574   emit_move_insn (tmp, x);
15575 }
15576
15577 /* Helper function of ix86_fixup_binary_operands to canonicalize
15578    operand order.  Returns true if the operands should be swapped.  */
15579
15580 static bool
15581 ix86_swap_binary_operands_p (enum rtx_code code, enum machine_mode mode,
15582                              rtx operands[])
15583 {
15584   rtx dst = operands[0];
15585   rtx src1 = operands[1];
15586   rtx src2 = operands[2];
15587
15588   /* If the operation is not commutative, we can't do anything.  */
15589   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH)
15590     return false;
15591
15592   /* Highest priority is that src1 should match dst.  */
15593   if (rtx_equal_p (dst, src1))
15594     return false;
15595   if (rtx_equal_p (dst, src2))
15596     return true;
15597
15598   /* Next highest priority is that immediate constants come second.  */
15599   if (immediate_operand (src2, mode))
15600     return false;
15601   if (immediate_operand (src1, mode))
15602     return true;
15603
15604   /* Lowest priority is that memory references should come second.  */
15605   if (MEM_P (src2))
15606     return false;
15607   if (MEM_P (src1))
15608     return true;
15609
15610   return false;
15611 }
15612
15613
15614 /* Fix up OPERANDS to satisfy ix86_binary_operator_ok.  Return the
15615    destination to use for the operation.  If different from the true
15616    destination in operands[0], a copy operation will be required.  */
15617
15618 rtx
15619 ix86_fixup_binary_operands (enum rtx_code code, enum machine_mode mode,
15620                             rtx operands[])
15621 {
15622   rtx dst = operands[0];
15623   rtx src1 = operands[1];
15624   rtx src2 = operands[2];
15625
15626   /* Canonicalize operand order.  */
15627   if (ix86_swap_binary_operands_p (code, mode, operands))
15628     {
15629       rtx temp;
15630
15631       /* It is invalid to swap operands of different modes.  */
15632       gcc_assert (GET_MODE (src1) == GET_MODE (src2));
15633
15634       temp = src1;
15635       src1 = src2;
15636       src2 = temp;
15637     }
15638
15639   /* Both source operands cannot be in memory.  */
15640   if (MEM_P (src1) && MEM_P (src2))
15641     {
15642       /* Optimization: Only read from memory once.  */
15643       if (rtx_equal_p (src1, src2))
15644         {
15645           src2 = force_reg (mode, src2);
15646           src1 = src2;
15647         }
15648       else
15649         src2 = force_reg (mode, src2);
15650     }
15651
15652   /* If the destination is memory, and we do not have matching source
15653      operands, do things in registers.  */
15654   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15655     dst = gen_reg_rtx (mode);
15656
15657   /* Source 1 cannot be a constant.  */
15658   if (CONSTANT_P (src1))
15659     src1 = force_reg (mode, src1);
15660
15661   /* Source 1 cannot be a non-matching memory.  */
15662   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15663     src1 = force_reg (mode, src1);
15664
15665   operands[1] = src1;
15666   operands[2] = src2;
15667   return dst;
15668 }
15669
15670 /* Similarly, but assume that the destination has already been
15671    set up properly.  */
15672
15673 void
15674 ix86_fixup_binary_operands_no_copy (enum rtx_code code,
15675                                     enum machine_mode mode, rtx operands[])
15676 {
15677   rtx dst = ix86_fixup_binary_operands (code, mode, operands);
15678   gcc_assert (dst == operands[0]);
15679 }
15680
15681 /* Attempt to expand a binary operator.  Make the expansion closer to the
15682    actual machine, then just general_operand, which will allow 3 separate
15683    memory references (one output, two input) in a single insn.  */
15684
15685 void
15686 ix86_expand_binary_operator (enum rtx_code code, enum machine_mode mode,
15687                              rtx operands[])
15688 {
15689   rtx src1, src2, dst, op, clob;
15690
15691   dst = ix86_fixup_binary_operands (code, mode, operands);
15692   src1 = operands[1];
15693   src2 = operands[2];
15694
15695  /* Emit the instruction.  */
15696
15697   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, src1, src2));
15698   if (reload_in_progress)
15699     {
15700       /* Reload doesn't know about the flags register, and doesn't know that
15701          it doesn't want to clobber it.  We can only do this with PLUS.  */
15702       gcc_assert (code == PLUS);
15703       emit_insn (op);
15704     }
15705   else if (reload_completed
15706            && code == PLUS
15707            && !rtx_equal_p (dst, src1))
15708     {
15709       /* This is going to be an LEA; avoid splitting it later.  */
15710       emit_insn (op);
15711     }
15712   else
15713     {
15714       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15715       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15716     }
15717
15718   /* Fix up the destination if needed.  */
15719   if (dst != operands[0])
15720     emit_move_insn (operands[0], dst);
15721 }
15722
15723 /* Return TRUE or FALSE depending on whether the binary operator meets the
15724    appropriate constraints.  */
15725
15726 bool
15727 ix86_binary_operator_ok (enum rtx_code code, enum machine_mode mode,
15728                          rtx operands[3])
15729 {
15730   rtx dst = operands[0];
15731   rtx src1 = operands[1];
15732   rtx src2 = operands[2];
15733
15734   /* Both source operands cannot be in memory.  */
15735   if (MEM_P (src1) && MEM_P (src2))
15736     return false;
15737
15738   /* Canonicalize operand order for commutative operators.  */
15739   if (ix86_swap_binary_operands_p (code, mode, operands))
15740     {
15741       rtx temp = src1;
15742       src1 = src2;
15743       src2 = temp;
15744     }
15745
15746   /* If the destination is memory, we must have a matching source operand.  */
15747   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15748       return false;
15749
15750   /* Source 1 cannot be a constant.  */
15751   if (CONSTANT_P (src1))
15752     return false;
15753
15754   /* Source 1 cannot be a non-matching memory.  */
15755   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15756     {
15757       /* Support "andhi/andsi/anddi" as a zero-extending move.  */
15758       return (code == AND
15759               && (mode == HImode
15760                   || mode == SImode
15761                   || (TARGET_64BIT && mode == DImode))
15762               && CONST_INT_P (src2)
15763               && (INTVAL (src2) == 0xff
15764                   || INTVAL (src2) == 0xffff));
15765     }
15766
15767   return true;
15768 }
15769
15770 /* Attempt to expand a unary operator.  Make the expansion closer to the
15771    actual machine, then just general_operand, which will allow 2 separate
15772    memory references (one output, one input) in a single insn.  */
15773
15774 void
15775 ix86_expand_unary_operator (enum rtx_code code, enum machine_mode mode,
15776                             rtx operands[])
15777 {
15778   int matching_memory;
15779   rtx src, dst, op, clob;
15780
15781   dst = operands[0];
15782   src = operands[1];
15783
15784   /* If the destination is memory, and we do not have matching source
15785      operands, do things in registers.  */
15786   matching_memory = 0;
15787   if (MEM_P (dst))
15788     {
15789       if (rtx_equal_p (dst, src))
15790         matching_memory = 1;
15791       else
15792         dst = gen_reg_rtx (mode);
15793     }
15794
15795   /* When source operand is memory, destination must match.  */
15796   if (MEM_P (src) && !matching_memory)
15797     src = force_reg (mode, src);
15798
15799   /* Emit the instruction.  */
15800
15801   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_e (code, mode, src));
15802   if (reload_in_progress || code == NOT)
15803     {
15804       /* Reload doesn't know about the flags register, and doesn't know that
15805          it doesn't want to clobber it.  */
15806       gcc_assert (code == NOT);
15807       emit_insn (op);
15808     }
15809   else
15810     {
15811       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15812       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
15813     }
15814
15815   /* Fix up the destination if needed.  */
15816   if (dst != operands[0])
15817     emit_move_insn (operands[0], dst);
15818 }
15819
15820 /* Split 32bit/64bit divmod with 8bit unsigned divmod if dividend and
15821    divisor are within the range [0-255].  */
15822
15823 void
15824 ix86_split_idivmod (enum machine_mode mode, rtx operands[],
15825                     bool signed_p)
15826 {
15827   rtx end_label, qimode_label;
15828   rtx insn, div, mod;
15829   rtx scratch, tmp0, tmp1, tmp2;
15830   rtx (*gen_divmod4_1) (rtx, rtx, rtx, rtx);
15831   rtx (*gen_zero_extend) (rtx, rtx);
15832   rtx (*gen_test_ccno_1) (rtx, rtx);
15833
15834   switch (mode)
15835     {
15836     case SImode:
15837       gen_divmod4_1 = signed_p ? gen_divmodsi4_1 : gen_udivmodsi4_1;
15838       gen_test_ccno_1 = gen_testsi_ccno_1;
15839       gen_zero_extend = gen_zero_extendqisi2;
15840       break;
15841     case DImode:
15842       gen_divmod4_1 = signed_p ? gen_divmoddi4_1 : gen_udivmoddi4_1;
15843       gen_test_ccno_1 = gen_testdi_ccno_1;
15844       gen_zero_extend = gen_zero_extendqidi2;
15845       break;
15846     default:
15847       gcc_unreachable ();
15848     }
15849
15850   end_label = gen_label_rtx ();
15851   qimode_label = gen_label_rtx ();
15852
15853   scratch = gen_reg_rtx (mode);
15854
15855   /* Use 8bit unsigned divimod if dividend and divisor are within
15856      the range [0-255].  */
15857   emit_move_insn (scratch, operands[2]);
15858   scratch = expand_simple_binop (mode, IOR, scratch, operands[3],
15859                                  scratch, 1, OPTAB_DIRECT);
15860   emit_insn (gen_test_ccno_1 (scratch, GEN_INT (-0x100)));
15861   tmp0 = gen_rtx_REG (CCNOmode, FLAGS_REG);
15862   tmp0 = gen_rtx_EQ (VOIDmode, tmp0, const0_rtx);
15863   tmp0 = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp0,
15864                                gen_rtx_LABEL_REF (VOIDmode, qimode_label),
15865                                pc_rtx);
15866   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp0));
15867   predict_jump (REG_BR_PROB_BASE * 50 / 100);
15868   JUMP_LABEL (insn) = qimode_label;
15869
15870   /* Generate original signed/unsigned divimod.  */
15871   div = gen_divmod4_1 (operands[0], operands[1],
15872                        operands[2], operands[3]);
15873   emit_insn (div);
15874
15875   /* Branch to the end.  */
15876   emit_jump_insn (gen_jump (end_label));
15877   emit_barrier ();
15878
15879   /* Generate 8bit unsigned divide.  */
15880   emit_label (qimode_label);
15881   /* Don't use operands[0] for result of 8bit divide since not all
15882      registers support QImode ZERO_EXTRACT.  */
15883   tmp0 = simplify_gen_subreg (HImode, scratch, mode, 0);
15884   tmp1 = simplify_gen_subreg (HImode, operands[2], mode, 0);
15885   tmp2 = simplify_gen_subreg (QImode, operands[3], mode, 0);
15886   emit_insn (gen_udivmodhiqi3 (tmp0, tmp1, tmp2));
15887
15888   if (signed_p)
15889     {
15890       div = gen_rtx_DIV (SImode, operands[2], operands[3]);
15891       mod = gen_rtx_MOD (SImode, operands[2], operands[3]);
15892     }
15893   else
15894     {
15895       div = gen_rtx_UDIV (SImode, operands[2], operands[3]);
15896       mod = gen_rtx_UMOD (SImode, operands[2], operands[3]);
15897     }
15898
15899   /* Extract remainder from AH.  */
15900   tmp1 = gen_rtx_ZERO_EXTRACT (mode, tmp0, GEN_INT (8), GEN_INT (8));
15901   if (REG_P (operands[1]))
15902     insn = emit_move_insn (operands[1], tmp1);
15903   else
15904     {
15905       /* Need a new scratch register since the old one has result
15906          of 8bit divide.  */
15907       scratch = gen_reg_rtx (mode);
15908       emit_move_insn (scratch, tmp1);
15909       insn = emit_move_insn (operands[1], scratch);
15910     }
15911   set_unique_reg_note (insn, REG_EQUAL, mod);
15912
15913   /* Zero extend quotient from AL.  */
15914   tmp1 = gen_lowpart (QImode, tmp0);
15915   insn = emit_insn (gen_zero_extend (operands[0], tmp1));
15916   set_unique_reg_note (insn, REG_EQUAL, div);
15917
15918   emit_label (end_label);
15919 }
15920
15921 #define LEA_SEARCH_THRESHOLD 12
15922
15923 /* Search backward for non-agu definition of register number REGNO1
15924    or register number REGNO2 in INSN's basic block until
15925    1. Pass LEA_SEARCH_THRESHOLD instructions, or
15926    2. Reach BB boundary, or
15927    3. Reach agu definition.
15928    Returns the distance between the non-agu definition point and INSN.
15929    If no definition point, returns -1.  */
15930
15931 static int
15932 distance_non_agu_define (unsigned int regno1, unsigned int regno2,
15933                          rtx insn)
15934 {
15935   basic_block bb = BLOCK_FOR_INSN (insn);
15936   int distance = 0;
15937   df_ref *def_rec;
15938   enum attr_type insn_type;
15939
15940   if (insn != BB_HEAD (bb))
15941     {
15942       rtx prev = PREV_INSN (insn);
15943       while (prev && distance < LEA_SEARCH_THRESHOLD)
15944         {
15945           if (NONDEBUG_INSN_P (prev))
15946             {
15947               distance++;
15948               for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
15949                 if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
15950                     && !DF_REF_IS_ARTIFICIAL (*def_rec)
15951                     && (regno1 == DF_REF_REGNO (*def_rec)
15952                         || regno2 == DF_REF_REGNO (*def_rec)))
15953                   {
15954                     insn_type = get_attr_type (prev);
15955                     if (insn_type != TYPE_LEA)
15956                       goto done;
15957                   }
15958             }
15959           if (prev == BB_HEAD (bb))
15960             break;
15961           prev = PREV_INSN (prev);
15962         }
15963     }
15964
15965   if (distance < LEA_SEARCH_THRESHOLD)
15966     {
15967       edge e;
15968       edge_iterator ei;
15969       bool simple_loop = false;
15970
15971       FOR_EACH_EDGE (e, ei, bb->preds)
15972         if (e->src == bb)
15973           {
15974             simple_loop = true;
15975             break;
15976           }
15977
15978       if (simple_loop)
15979         {
15980           rtx prev = BB_END (bb);
15981           while (prev
15982                  && prev != insn
15983                  && distance < LEA_SEARCH_THRESHOLD)
15984             {
15985               if (NONDEBUG_INSN_P (prev))
15986                 {
15987                   distance++;
15988                   for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
15989                     if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
15990                         && !DF_REF_IS_ARTIFICIAL (*def_rec)
15991                         && (regno1 == DF_REF_REGNO (*def_rec)
15992                             || regno2 == DF_REF_REGNO (*def_rec)))
15993                       {
15994                         insn_type = get_attr_type (prev);
15995                         if (insn_type != TYPE_LEA)
15996                           goto done;
15997                       }
15998                 }
15999               prev = PREV_INSN (prev);
16000             }
16001         }
16002     }
16003
16004   distance = -1;
16005
16006 done:
16007   /* get_attr_type may modify recog data.  We want to make sure
16008      that recog data is valid for instruction INSN, on which
16009      distance_non_agu_define is called.  INSN is unchanged here.  */
16010   extract_insn_cached (insn);
16011   return distance;
16012 }
16013
16014 /* Return the distance between INSN and the next insn that uses
16015    register number REGNO0 in memory address.  Return -1 if no such
16016    a use is found within LEA_SEARCH_THRESHOLD or REGNO0 is set.  */
16017
16018 static int
16019 distance_agu_use (unsigned int regno0, rtx insn)
16020 {
16021   basic_block bb = BLOCK_FOR_INSN (insn);
16022   int distance = 0;
16023   df_ref *def_rec;
16024   df_ref *use_rec;
16025
16026   if (insn != BB_END (bb))
16027     {
16028       rtx next = NEXT_INSN (insn);
16029       while (next && distance < LEA_SEARCH_THRESHOLD)
16030         {
16031           if (NONDEBUG_INSN_P (next))
16032             {
16033               distance++;
16034
16035               for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
16036                 if ((DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_LOAD
16037                      || DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_STORE)
16038                     && regno0 == DF_REF_REGNO (*use_rec))
16039                   {
16040                     /* Return DISTANCE if OP0 is used in memory
16041                        address in NEXT.  */
16042                     return distance;
16043                   }
16044
16045               for (def_rec = DF_INSN_DEFS (next); *def_rec; def_rec++)
16046                 if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
16047                     && !DF_REF_IS_ARTIFICIAL (*def_rec)
16048                     && regno0 == DF_REF_REGNO (*def_rec))
16049                   {
16050                     /* Return -1 if OP0 is set in NEXT.  */
16051                     return -1;
16052                   }
16053             }
16054           if (next == BB_END (bb))
16055             break;
16056           next = NEXT_INSN (next);
16057         }
16058     }
16059
16060   if (distance < LEA_SEARCH_THRESHOLD)
16061     {
16062       edge e;
16063       edge_iterator ei;
16064       bool simple_loop = false;
16065
16066       FOR_EACH_EDGE (e, ei, bb->succs)
16067         if (e->dest == bb)
16068           {
16069             simple_loop = true;
16070             break;
16071           }
16072
16073       if (simple_loop)
16074         {
16075           rtx next = BB_HEAD (bb);
16076           while (next
16077                  && next != insn
16078                  && distance < LEA_SEARCH_THRESHOLD)
16079             {
16080               if (NONDEBUG_INSN_P (next))
16081                 {
16082                   distance++;
16083
16084                   for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
16085                     if ((DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_LOAD
16086                          || DF_REF_TYPE (*use_rec) == DF_REF_REG_MEM_STORE)
16087                         && regno0 == DF_REF_REGNO (*use_rec))
16088                       {
16089                         /* Return DISTANCE if OP0 is used in memory
16090                            address in NEXT.  */
16091                         return distance;
16092                       }
16093
16094                   for (def_rec = DF_INSN_DEFS (next); *def_rec; def_rec++)
16095                     if (DF_REF_TYPE (*def_rec) == DF_REF_REG_DEF
16096                         && !DF_REF_IS_ARTIFICIAL (*def_rec)
16097                         && regno0 == DF_REF_REGNO (*def_rec))
16098                       {
16099                         /* Return -1 if OP0 is set in NEXT.  */
16100                         return -1;
16101                       }
16102
16103                 }
16104               next = NEXT_INSN (next);
16105             }
16106         }
16107     }
16108
16109   return -1;
16110 }
16111
16112 /* Define this macro to tune LEA priority vs ADD, it take effect when
16113    there is a dilemma of choicing LEA or ADD
16114    Negative value: ADD is more preferred than LEA
16115    Zero: Netrual
16116    Positive value: LEA is more preferred than ADD*/
16117 #define IX86_LEA_PRIORITY 2
16118
16119 /* Return true if it is ok to optimize an ADD operation to LEA
16120    operation to avoid flag register consumation.  For most processors,
16121    ADD is faster than LEA.  For the processors like ATOM, if the
16122    destination register of LEA holds an actual address which will be
16123    used soon, LEA is better and otherwise ADD is better.  */
16124
16125 bool
16126 ix86_lea_for_add_ok (rtx insn, rtx operands[])
16127 {
16128   unsigned int regno0 = true_regnum (operands[0]);
16129   unsigned int regno1 = true_regnum (operands[1]);
16130   unsigned int regno2 = true_regnum (operands[2]);
16131
16132   /* If a = b + c, (a!=b && a!=c), must use lea form. */
16133   if (regno0 != regno1 && regno0 != regno2)
16134     return true;
16135
16136   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16137     return false;
16138   else
16139     {
16140       int dist_define, dist_use;
16141
16142       /* Return false if REGNO0 isn't used in memory address. */
16143       dist_use = distance_agu_use (regno0, insn);
16144       if (dist_use <= 0)
16145         return false;
16146
16147       dist_define = distance_non_agu_define (regno1, regno2, insn);
16148       if (dist_define <= 0)
16149         return true;
16150
16151       /* If this insn has both backward non-agu dependence and forward
16152          agu dependence, the one with short distance take effect. */
16153       if ((dist_define + IX86_LEA_PRIORITY) < dist_use)
16154         return false;
16155
16156       return true;
16157     }
16158 }
16159
16160 /* Return true if destination reg of SET_BODY is shift count of
16161    USE_BODY.  */
16162
16163 static bool
16164 ix86_dep_by_shift_count_body (const_rtx set_body, const_rtx use_body)
16165 {
16166   rtx set_dest;
16167   rtx shift_rtx;
16168   int i;
16169
16170   /* Retrieve destination of SET_BODY.  */
16171   switch (GET_CODE (set_body))
16172     {
16173     case SET:
16174       set_dest = SET_DEST (set_body);
16175       if (!set_dest || !REG_P (set_dest))
16176         return false;
16177       break;
16178     case PARALLEL:
16179       for (i = XVECLEN (set_body, 0) - 1; i >= 0; i--)
16180         if (ix86_dep_by_shift_count_body (XVECEXP (set_body, 0, i),
16181                                           use_body))
16182           return true;
16183     default:
16184       return false;
16185       break;
16186     }
16187
16188   /* Retrieve shift count of USE_BODY.  */
16189   switch (GET_CODE (use_body))
16190     {
16191     case SET:
16192       shift_rtx = XEXP (use_body, 1);
16193       break;
16194     case PARALLEL:
16195       for (i = XVECLEN (use_body, 0) - 1; i >= 0; i--)
16196         if (ix86_dep_by_shift_count_body (set_body,
16197                                           XVECEXP (use_body, 0, i)))
16198           return true;
16199     default:
16200       return false;
16201       break;
16202     }
16203
16204   if (shift_rtx
16205       && (GET_CODE (shift_rtx) == ASHIFT
16206           || GET_CODE (shift_rtx) == LSHIFTRT
16207           || GET_CODE (shift_rtx) == ASHIFTRT
16208           || GET_CODE (shift_rtx) == ROTATE
16209           || GET_CODE (shift_rtx) == ROTATERT))
16210     {
16211       rtx shift_count = XEXP (shift_rtx, 1);
16212
16213       /* Return true if shift count is dest of SET_BODY.  */
16214       if (REG_P (shift_count)
16215           && true_regnum (set_dest) == true_regnum (shift_count))
16216         return true;
16217     }
16218
16219   return false;
16220 }
16221
16222 /* Return true if destination reg of SET_INSN is shift count of
16223    USE_INSN.  */
16224
16225 bool
16226 ix86_dep_by_shift_count (const_rtx set_insn, const_rtx use_insn)
16227 {
16228   return ix86_dep_by_shift_count_body (PATTERN (set_insn),
16229                                        PATTERN (use_insn));
16230 }
16231
16232 /* Return TRUE or FALSE depending on whether the unary operator meets the
16233    appropriate constraints.  */
16234
16235 bool
16236 ix86_unary_operator_ok (enum rtx_code code ATTRIBUTE_UNUSED,
16237                         enum machine_mode mode ATTRIBUTE_UNUSED,
16238                         rtx operands[2] ATTRIBUTE_UNUSED)
16239 {
16240   /* If one of operands is memory, source and destination must match.  */
16241   if ((MEM_P (operands[0])
16242        || MEM_P (operands[1]))
16243       && ! rtx_equal_p (operands[0], operands[1]))
16244     return false;
16245   return true;
16246 }
16247
16248 /* Return TRUE if the operands to a vec_interleave_{high,low}v2df
16249    are ok, keeping in mind the possible movddup alternative.  */
16250
16251 bool
16252 ix86_vec_interleave_v2df_operator_ok (rtx operands[3], bool high)
16253 {
16254   if (MEM_P (operands[0]))
16255     return rtx_equal_p (operands[0], operands[1 + high]);
16256   if (MEM_P (operands[1]) && MEM_P (operands[2]))
16257     return TARGET_SSE3 && rtx_equal_p (operands[1], operands[2]);
16258   return true;
16259 }
16260
16261 /* Post-reload splitter for converting an SF or DFmode value in an
16262    SSE register into an unsigned SImode.  */
16263
16264 void
16265 ix86_split_convert_uns_si_sse (rtx operands[])
16266 {
16267   enum machine_mode vecmode;
16268   rtx value, large, zero_or_two31, input, two31, x;
16269
16270   large = operands[1];
16271   zero_or_two31 = operands[2];
16272   input = operands[3];
16273   two31 = operands[4];
16274   vecmode = GET_MODE (large);
16275   value = gen_rtx_REG (vecmode, REGNO (operands[0]));
16276
16277   /* Load up the value into the low element.  We must ensure that the other
16278      elements are valid floats -- zero is the easiest such value.  */
16279   if (MEM_P (input))
16280     {
16281       if (vecmode == V4SFmode)
16282         emit_insn (gen_vec_setv4sf_0 (value, CONST0_RTX (V4SFmode), input));
16283       else
16284         emit_insn (gen_sse2_loadlpd (value, CONST0_RTX (V2DFmode), input));
16285     }
16286   else
16287     {
16288       input = gen_rtx_REG (vecmode, REGNO (input));
16289       emit_move_insn (value, CONST0_RTX (vecmode));
16290       if (vecmode == V4SFmode)
16291         emit_insn (gen_sse_movss (value, value, input));
16292       else
16293         emit_insn (gen_sse2_movsd (value, value, input));
16294     }
16295
16296   emit_move_insn (large, two31);
16297   emit_move_insn (zero_or_two31, MEM_P (two31) ? large : two31);
16298
16299   x = gen_rtx_fmt_ee (LE, vecmode, large, value);
16300   emit_insn (gen_rtx_SET (VOIDmode, large, x));
16301
16302   x = gen_rtx_AND (vecmode, zero_or_two31, large);
16303   emit_insn (gen_rtx_SET (VOIDmode, zero_or_two31, x));
16304
16305   x = gen_rtx_MINUS (vecmode, value, zero_or_two31);
16306   emit_insn (gen_rtx_SET (VOIDmode, value, x));
16307
16308   large = gen_rtx_REG (V4SImode, REGNO (large));
16309   emit_insn (gen_ashlv4si3 (large, large, GEN_INT (31)));
16310
16311   x = gen_rtx_REG (V4SImode, REGNO (value));
16312   if (vecmode == V4SFmode)
16313     emit_insn (gen_sse2_cvttps2dq (x, value));
16314   else
16315     emit_insn (gen_sse2_cvttpd2dq (x, value));
16316   value = x;
16317
16318   emit_insn (gen_xorv4si3 (value, value, large));
16319 }
16320
16321 /* Convert an unsigned DImode value into a DFmode, using only SSE.
16322    Expects the 64-bit DImode to be supplied in a pair of integral
16323    registers.  Requires SSE2; will use SSE3 if available.  For x86_32,
16324    -mfpmath=sse, !optimize_size only.  */
16325
16326 void
16327 ix86_expand_convert_uns_didf_sse (rtx target, rtx input)
16328 {
16329   REAL_VALUE_TYPE bias_lo_rvt, bias_hi_rvt;
16330   rtx int_xmm, fp_xmm;
16331   rtx biases, exponents;
16332   rtx x;
16333
16334   int_xmm = gen_reg_rtx (V4SImode);
16335   if (TARGET_INTER_UNIT_MOVES)
16336     emit_insn (gen_movdi_to_sse (int_xmm, input));
16337   else if (TARGET_SSE_SPLIT_REGS)
16338     {
16339       emit_clobber (int_xmm);
16340       emit_move_insn (gen_lowpart (DImode, int_xmm), input);
16341     }
16342   else
16343     {
16344       x = gen_reg_rtx (V2DImode);
16345       ix86_expand_vector_init_one_nonzero (false, V2DImode, x, input, 0);
16346       emit_move_insn (int_xmm, gen_lowpart (V4SImode, x));
16347     }
16348
16349   x = gen_rtx_CONST_VECTOR (V4SImode,
16350                             gen_rtvec (4, GEN_INT (0x43300000UL),
16351                                        GEN_INT (0x45300000UL),
16352                                        const0_rtx, const0_rtx));
16353   exponents = validize_mem (force_const_mem (V4SImode, x));
16354
16355   /* int_xmm = {0x45300000UL, fp_xmm/hi, 0x43300000, fp_xmm/lo } */
16356   emit_insn (gen_vec_interleave_lowv4si (int_xmm, int_xmm, exponents));
16357
16358   /* Concatenating (juxtaposing) (0x43300000UL ## fp_value_low_xmm)
16359      yields a valid DF value equal to (0x1.0p52 + double(fp_value_lo_xmm)).
16360      Similarly (0x45300000UL ## fp_value_hi_xmm) yields
16361      (0x1.0p84 + double(fp_value_hi_xmm)).
16362      Note these exponents differ by 32.  */
16363
16364   fp_xmm = copy_to_mode_reg (V2DFmode, gen_lowpart (V2DFmode, int_xmm));
16365
16366   /* Subtract off those 0x1.0p52 and 0x1.0p84 biases, to produce values
16367      in [0,2**32-1] and [0]+[2**32,2**64-1] respectively.  */
16368   real_ldexp (&bias_lo_rvt, &dconst1, 52);
16369   real_ldexp (&bias_hi_rvt, &dconst1, 84);
16370   biases = const_double_from_real_value (bias_lo_rvt, DFmode);
16371   x = const_double_from_real_value (bias_hi_rvt, DFmode);
16372   biases = gen_rtx_CONST_VECTOR (V2DFmode, gen_rtvec (2, biases, x));
16373   biases = validize_mem (force_const_mem (V2DFmode, biases));
16374   emit_insn (gen_subv2df3 (fp_xmm, fp_xmm, biases));
16375
16376   /* Add the upper and lower DFmode values together.  */
16377   if (TARGET_SSE3)
16378     emit_insn (gen_sse3_haddv2df3 (fp_xmm, fp_xmm, fp_xmm));
16379   else
16380     {
16381       x = copy_to_mode_reg (V2DFmode, fp_xmm);
16382       emit_insn (gen_vec_interleave_highv2df (fp_xmm, fp_xmm, fp_xmm));
16383       emit_insn (gen_addv2df3 (fp_xmm, fp_xmm, x));
16384     }
16385
16386   ix86_expand_vector_extract (false, target, fp_xmm, 0);
16387 }
16388
16389 /* Not used, but eases macroization of patterns.  */
16390 void
16391 ix86_expand_convert_uns_sixf_sse (rtx target ATTRIBUTE_UNUSED,
16392                                   rtx input ATTRIBUTE_UNUSED)
16393 {
16394   gcc_unreachable ();
16395 }
16396
16397 /* Convert an unsigned SImode value into a DFmode.  Only currently used
16398    for SSE, but applicable anywhere.  */
16399
16400 void
16401 ix86_expand_convert_uns_sidf_sse (rtx target, rtx input)
16402 {
16403   REAL_VALUE_TYPE TWO31r;
16404   rtx x, fp;
16405
16406   x = expand_simple_binop (SImode, PLUS, input, GEN_INT (-2147483647 - 1),
16407                            NULL, 1, OPTAB_DIRECT);
16408
16409   fp = gen_reg_rtx (DFmode);
16410   emit_insn (gen_floatsidf2 (fp, x));
16411
16412   real_ldexp (&TWO31r, &dconst1, 31);
16413   x = const_double_from_real_value (TWO31r, DFmode);
16414
16415   x = expand_simple_binop (DFmode, PLUS, fp, x, target, 0, OPTAB_DIRECT);
16416   if (x != target)
16417     emit_move_insn (target, x);
16418 }
16419
16420 /* Convert a signed DImode value into a DFmode.  Only used for SSE in
16421    32-bit mode; otherwise we have a direct convert instruction.  */
16422
16423 void
16424 ix86_expand_convert_sign_didf_sse (rtx target, rtx input)
16425 {
16426   REAL_VALUE_TYPE TWO32r;
16427   rtx fp_lo, fp_hi, x;
16428
16429   fp_lo = gen_reg_rtx (DFmode);
16430   fp_hi = gen_reg_rtx (DFmode);
16431
16432   emit_insn (gen_floatsidf2 (fp_hi, gen_highpart (SImode, input)));
16433
16434   real_ldexp (&TWO32r, &dconst1, 32);
16435   x = const_double_from_real_value (TWO32r, DFmode);
16436   fp_hi = expand_simple_binop (DFmode, MULT, fp_hi, x, fp_hi, 0, OPTAB_DIRECT);
16437
16438   ix86_expand_convert_uns_sidf_sse (fp_lo, gen_lowpart (SImode, input));
16439
16440   x = expand_simple_binop (DFmode, PLUS, fp_hi, fp_lo, target,
16441                            0, OPTAB_DIRECT);
16442   if (x != target)
16443     emit_move_insn (target, x);
16444 }
16445
16446 /* Convert an unsigned SImode value into a SFmode, using only SSE.
16447    For x86_32, -mfpmath=sse, !optimize_size only.  */
16448 void
16449 ix86_expand_convert_uns_sisf_sse (rtx target, rtx input)
16450 {
16451   REAL_VALUE_TYPE ONE16r;
16452   rtx fp_hi, fp_lo, int_hi, int_lo, x;
16453
16454   real_ldexp (&ONE16r, &dconst1, 16);
16455   x = const_double_from_real_value (ONE16r, SFmode);
16456   int_lo = expand_simple_binop (SImode, AND, input, GEN_INT(0xffff),
16457                                       NULL, 0, OPTAB_DIRECT);
16458   int_hi = expand_simple_binop (SImode, LSHIFTRT, input, GEN_INT(16),
16459                                       NULL, 0, OPTAB_DIRECT);
16460   fp_hi = gen_reg_rtx (SFmode);
16461   fp_lo = gen_reg_rtx (SFmode);
16462   emit_insn (gen_floatsisf2 (fp_hi, int_hi));
16463   emit_insn (gen_floatsisf2 (fp_lo, int_lo));
16464   fp_hi = expand_simple_binop (SFmode, MULT, fp_hi, x, fp_hi,
16465                                0, OPTAB_DIRECT);
16466   fp_hi = expand_simple_binop (SFmode, PLUS, fp_hi, fp_lo, target,
16467                                0, OPTAB_DIRECT);
16468   if (!rtx_equal_p (target, fp_hi))
16469     emit_move_insn (target, fp_hi);
16470 }
16471
16472 /* A subroutine of ix86_build_signbit_mask.  If VECT is true,
16473    then replicate the value for all elements of the vector
16474    register.  */
16475
16476 rtx
16477 ix86_build_const_vector (enum machine_mode mode, bool vect, rtx value)
16478 {
16479   rtvec v;
16480   switch (mode)
16481     {
16482     case V4SImode:
16483       gcc_assert (vect);
16484       v = gen_rtvec (4, value, value, value, value);
16485       return gen_rtx_CONST_VECTOR (V4SImode, v);
16486
16487     case V2DImode:
16488       gcc_assert (vect);
16489       v = gen_rtvec (2, value, value);
16490       return gen_rtx_CONST_VECTOR (V2DImode, v);
16491
16492     case V8SFmode:
16493       if (vect)
16494         v = gen_rtvec (8, value, value, value, value,
16495                        value, value, value, value);
16496       else
16497         v = gen_rtvec (8, value, CONST0_RTX (SFmode),
16498                        CONST0_RTX (SFmode), CONST0_RTX (SFmode),
16499                        CONST0_RTX (SFmode), CONST0_RTX (SFmode),
16500                        CONST0_RTX (SFmode), CONST0_RTX (SFmode));
16501       return gen_rtx_CONST_VECTOR (V8SFmode, v);
16502
16503     case V4SFmode:
16504       if (vect)
16505         v = gen_rtvec (4, value, value, value, value);
16506       else
16507         v = gen_rtvec (4, value, CONST0_RTX (SFmode),
16508                        CONST0_RTX (SFmode), CONST0_RTX (SFmode));
16509       return gen_rtx_CONST_VECTOR (V4SFmode, v);
16510
16511     case V4DFmode:
16512       if (vect)
16513         v = gen_rtvec (4, value, value, value, value);
16514       else
16515         v = gen_rtvec (4, value, CONST0_RTX (DFmode),
16516                        CONST0_RTX (DFmode), CONST0_RTX (DFmode));
16517       return gen_rtx_CONST_VECTOR (V4DFmode, v);
16518
16519     case V2DFmode:
16520       if (vect)
16521         v = gen_rtvec (2, value, value);
16522       else
16523         v = gen_rtvec (2, value, CONST0_RTX (DFmode));
16524       return gen_rtx_CONST_VECTOR (V2DFmode, v);
16525
16526     default:
16527       gcc_unreachable ();
16528     }
16529 }
16530
16531 /* A subroutine of ix86_expand_fp_absneg_operator, copysign expanders
16532    and ix86_expand_int_vcond.  Create a mask for the sign bit in MODE
16533    for an SSE register.  If VECT is true, then replicate the mask for
16534    all elements of the vector register.  If INVERT is true, then create
16535    a mask excluding the sign bit.  */
16536
16537 rtx
16538 ix86_build_signbit_mask (enum machine_mode mode, bool vect, bool invert)
16539 {
16540   enum machine_mode vec_mode, imode;
16541   HOST_WIDE_INT hi, lo;
16542   int shift = 63;
16543   rtx v;
16544   rtx mask;
16545
16546   /* Find the sign bit, sign extended to 2*HWI.  */
16547   switch (mode)
16548     {
16549     case V4SImode:
16550     case V8SFmode:
16551     case V4SFmode:
16552       vec_mode = mode;
16553       mode = GET_MODE_INNER (mode);
16554       imode = SImode;
16555       lo = 0x80000000, hi = lo < 0;
16556       break;
16557
16558     case V2DImode:
16559     case V4DFmode:
16560     case V2DFmode:
16561       vec_mode = mode;
16562       mode = GET_MODE_INNER (mode);
16563       imode = DImode;
16564       if (HOST_BITS_PER_WIDE_INT >= 64)
16565         lo = (HOST_WIDE_INT)1 << shift, hi = -1;
16566       else
16567         lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
16568       break;
16569
16570     case TImode:
16571     case TFmode:
16572       vec_mode = VOIDmode;
16573       if (HOST_BITS_PER_WIDE_INT >= 64)
16574         {
16575           imode = TImode;
16576           lo = 0, hi = (HOST_WIDE_INT)1 << shift;
16577         }
16578       else
16579         {
16580           rtvec vec;
16581
16582           imode = DImode;
16583           lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
16584
16585           if (invert)
16586             {
16587               lo = ~lo, hi = ~hi;
16588               v = constm1_rtx;
16589             }
16590           else
16591             v = const0_rtx;
16592
16593           mask = immed_double_const (lo, hi, imode);
16594
16595           vec = gen_rtvec (2, v, mask);
16596           v = gen_rtx_CONST_VECTOR (V2DImode, vec);
16597           v = copy_to_mode_reg (mode, gen_lowpart (mode, v));
16598
16599           return v;
16600         }
16601      break;
16602
16603     default:
16604       gcc_unreachable ();
16605     }
16606
16607   if (invert)
16608     lo = ~lo, hi = ~hi;
16609
16610   /* Force this value into the low part of a fp vector constant.  */
16611   mask = immed_double_const (lo, hi, imode);
16612   mask = gen_lowpart (mode, mask);
16613
16614   if (vec_mode == VOIDmode)
16615     return force_reg (mode, mask);
16616
16617   v = ix86_build_const_vector (vec_mode, vect, mask);
16618   return force_reg (vec_mode, v);
16619 }
16620
16621 /* Generate code for floating point ABS or NEG.  */
16622
16623 void
16624 ix86_expand_fp_absneg_operator (enum rtx_code code, enum machine_mode mode,
16625                                 rtx operands[])
16626 {
16627   rtx mask, set, dst, src;
16628   bool use_sse = false;
16629   bool vector_mode = VECTOR_MODE_P (mode);
16630   enum machine_mode vmode = mode;
16631
16632   if (vector_mode)
16633     use_sse = true;
16634   else if (mode == TFmode)
16635     use_sse = true;
16636   else if (TARGET_SSE_MATH)
16637     {
16638       use_sse = SSE_FLOAT_MODE_P (mode);
16639       if (mode == SFmode)
16640         vmode = V4SFmode;
16641       else if (mode == DFmode)
16642         vmode = V2DFmode;
16643     }
16644
16645   /* NEG and ABS performed with SSE use bitwise mask operations.
16646      Create the appropriate mask now.  */
16647   if (use_sse)
16648     mask = ix86_build_signbit_mask (vmode, vector_mode, code == ABS);
16649   else
16650     mask = NULL_RTX;
16651
16652   dst = operands[0];
16653   src = operands[1];
16654
16655   set = gen_rtx_fmt_e (code, mode, src);
16656   set = gen_rtx_SET (VOIDmode, dst, set);
16657
16658   if (mask)
16659     {
16660       rtx use, clob;
16661       rtvec par;
16662
16663       use = gen_rtx_USE (VOIDmode, mask);
16664       if (vector_mode)
16665         par = gen_rtvec (2, set, use);
16666       else
16667         {
16668           clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16669           par = gen_rtvec (3, set, use, clob);
16670         }
16671       emit_insn (gen_rtx_PARALLEL (VOIDmode, par));
16672     }
16673   else
16674     emit_insn (set);
16675 }
16676
16677 /* Expand a copysign operation.  Special case operand 0 being a constant.  */
16678
16679 void
16680 ix86_expand_copysign (rtx operands[])
16681 {
16682   enum machine_mode mode, vmode;
16683   rtx dest, op0, op1, mask, nmask;
16684
16685   dest = operands[0];
16686   op0 = operands[1];
16687   op1 = operands[2];
16688
16689   mode = GET_MODE (dest);
16690
16691   if (mode == SFmode)
16692     vmode = V4SFmode;
16693   else if (mode == DFmode)
16694     vmode = V2DFmode;
16695   else
16696     vmode = mode;
16697
16698   if (GET_CODE (op0) == CONST_DOUBLE)
16699     {
16700       rtx (*copysign_insn)(rtx, rtx, rtx, rtx);
16701
16702       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
16703         op0 = simplify_unary_operation (ABS, mode, op0, mode);
16704
16705       if (mode == SFmode || mode == DFmode)
16706         {
16707           if (op0 == CONST0_RTX (mode))
16708             op0 = CONST0_RTX (vmode);
16709           else
16710             {
16711               rtx v = ix86_build_const_vector (vmode, false, op0);
16712
16713               op0 = force_reg (vmode, v);
16714             }
16715         }
16716       else if (op0 != CONST0_RTX (mode))
16717         op0 = force_reg (mode, op0);
16718
16719       mask = ix86_build_signbit_mask (vmode, 0, 0);
16720
16721       if (mode == SFmode)
16722         copysign_insn = gen_copysignsf3_const;
16723       else if (mode == DFmode)
16724         copysign_insn = gen_copysigndf3_const;
16725       else
16726         copysign_insn = gen_copysigntf3_const;
16727
16728         emit_insn (copysign_insn (dest, op0, op1, mask));
16729     }
16730   else
16731     {
16732       rtx (*copysign_insn)(rtx, rtx, rtx, rtx, rtx, rtx);
16733
16734       nmask = ix86_build_signbit_mask (vmode, 0, 1);
16735       mask = ix86_build_signbit_mask (vmode, 0, 0);
16736
16737       if (mode == SFmode)
16738         copysign_insn = gen_copysignsf3_var;
16739       else if (mode == DFmode)
16740         copysign_insn = gen_copysigndf3_var;
16741       else
16742         copysign_insn = gen_copysigntf3_var;
16743
16744       emit_insn (copysign_insn (dest, NULL_RTX, op0, op1, nmask, mask));
16745     }
16746 }
16747
16748 /* Deconstruct a copysign operation into bit masks.  Operand 0 is known to
16749    be a constant, and so has already been expanded into a vector constant.  */
16750
16751 void
16752 ix86_split_copysign_const (rtx operands[])
16753 {
16754   enum machine_mode mode, vmode;
16755   rtx dest, op0, mask, x;
16756
16757   dest = operands[0];
16758   op0 = operands[1];
16759   mask = operands[3];
16760
16761   mode = GET_MODE (dest);
16762   vmode = GET_MODE (mask);
16763
16764   dest = simplify_gen_subreg (vmode, dest, mode, 0);
16765   x = gen_rtx_AND (vmode, dest, mask);
16766   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16767
16768   if (op0 != CONST0_RTX (vmode))
16769     {
16770       x = gen_rtx_IOR (vmode, dest, op0);
16771       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16772     }
16773 }
16774
16775 /* Deconstruct a copysign operation into bit masks.  Operand 0 is variable,
16776    so we have to do two masks.  */
16777
16778 void
16779 ix86_split_copysign_var (rtx operands[])
16780 {
16781   enum machine_mode mode, vmode;
16782   rtx dest, scratch, op0, op1, mask, nmask, x;
16783
16784   dest = operands[0];
16785   scratch = operands[1];
16786   op0 = operands[2];
16787   op1 = operands[3];
16788   nmask = operands[4];
16789   mask = operands[5];
16790
16791   mode = GET_MODE (dest);
16792   vmode = GET_MODE (mask);
16793
16794   if (rtx_equal_p (op0, op1))
16795     {
16796       /* Shouldn't happen often (it's useless, obviously), but when it does
16797          we'd generate incorrect code if we continue below.  */
16798       emit_move_insn (dest, op0);
16799       return;
16800     }
16801
16802   if (REG_P (mask) && REGNO (dest) == REGNO (mask))     /* alternative 0 */
16803     {
16804       gcc_assert (REGNO (op1) == REGNO (scratch));
16805
16806       x = gen_rtx_AND (vmode, scratch, mask);
16807       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
16808
16809       dest = mask;
16810       op0 = simplify_gen_subreg (vmode, op0, mode, 0);
16811       x = gen_rtx_NOT (vmode, dest);
16812       x = gen_rtx_AND (vmode, x, op0);
16813       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16814     }
16815   else
16816     {
16817       if (REGNO (op1) == REGNO (scratch))               /* alternative 1,3 */
16818         {
16819           x = gen_rtx_AND (vmode, scratch, mask);
16820         }
16821       else                                              /* alternative 2,4 */
16822         {
16823           gcc_assert (REGNO (mask) == REGNO (scratch));
16824           op1 = simplify_gen_subreg (vmode, op1, mode, 0);
16825           x = gen_rtx_AND (vmode, scratch, op1);
16826         }
16827       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
16828
16829       if (REGNO (op0) == REGNO (dest))                  /* alternative 1,2 */
16830         {
16831           dest = simplify_gen_subreg (vmode, op0, mode, 0);
16832           x = gen_rtx_AND (vmode, dest, nmask);
16833         }
16834       else                                              /* alternative 3,4 */
16835         {
16836           gcc_assert (REGNO (nmask) == REGNO (dest));
16837           dest = nmask;
16838           op0 = simplify_gen_subreg (vmode, op0, mode, 0);
16839           x = gen_rtx_AND (vmode, dest, op0);
16840         }
16841       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16842     }
16843
16844   x = gen_rtx_IOR (vmode, dest, scratch);
16845   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
16846 }
16847
16848 /* Return TRUE or FALSE depending on whether the first SET in INSN
16849    has source and destination with matching CC modes, and that the
16850    CC mode is at least as constrained as REQ_MODE.  */
16851
16852 bool
16853 ix86_match_ccmode (rtx insn, enum machine_mode req_mode)
16854 {
16855   rtx set;
16856   enum machine_mode set_mode;
16857
16858   set = PATTERN (insn);
16859   if (GET_CODE (set) == PARALLEL)
16860     set = XVECEXP (set, 0, 0);
16861   gcc_assert (GET_CODE (set) == SET);
16862   gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE);
16863
16864   set_mode = GET_MODE (SET_DEST (set));
16865   switch (set_mode)
16866     {
16867     case CCNOmode:
16868       if (req_mode != CCNOmode
16869           && (req_mode != CCmode
16870               || XEXP (SET_SRC (set), 1) != const0_rtx))
16871         return false;
16872       break;
16873     case CCmode:
16874       if (req_mode == CCGCmode)
16875         return false;
16876       /* FALLTHRU */
16877     case CCGCmode:
16878       if (req_mode == CCGOCmode || req_mode == CCNOmode)
16879         return false;
16880       /* FALLTHRU */
16881     case CCGOCmode:
16882       if (req_mode == CCZmode)
16883         return false;
16884       /* FALLTHRU */
16885     case CCZmode:
16886       break;
16887
16888     case CCAmode:
16889     case CCCmode:
16890     case CCOmode:
16891     case CCSmode:
16892       if (set_mode != req_mode)
16893         return false;
16894       break;
16895
16896     default:
16897       gcc_unreachable ();
16898     }
16899
16900   return GET_MODE (SET_SRC (set)) == set_mode;
16901 }
16902
16903 /* Generate insn patterns to do an integer compare of OPERANDS.  */
16904
16905 static rtx
16906 ix86_expand_int_compare (enum rtx_code code, rtx op0, rtx op1)
16907 {
16908   enum machine_mode cmpmode;
16909   rtx tmp, flags;
16910
16911   cmpmode = SELECT_CC_MODE (code, op0, op1);
16912   flags = gen_rtx_REG (cmpmode, FLAGS_REG);
16913
16914   /* This is very simple, but making the interface the same as in the
16915      FP case makes the rest of the code easier.  */
16916   tmp = gen_rtx_COMPARE (cmpmode, op0, op1);
16917   emit_insn (gen_rtx_SET (VOIDmode, flags, tmp));
16918
16919   /* Return the test that should be put into the flags user, i.e.
16920      the bcc, scc, or cmov instruction.  */
16921   return gen_rtx_fmt_ee (code, VOIDmode, flags, const0_rtx);
16922 }
16923
16924 /* Figure out whether to use ordered or unordered fp comparisons.
16925    Return the appropriate mode to use.  */
16926
16927 enum machine_mode
16928 ix86_fp_compare_mode (enum rtx_code code ATTRIBUTE_UNUSED)
16929 {
16930   /* ??? In order to make all comparisons reversible, we do all comparisons
16931      non-trapping when compiling for IEEE.  Once gcc is able to distinguish
16932      all forms trapping and nontrapping comparisons, we can make inequality
16933      comparisons trapping again, since it results in better code when using
16934      FCOM based compares.  */
16935   return TARGET_IEEE_FP ? CCFPUmode : CCFPmode;
16936 }
16937
16938 enum machine_mode
16939 ix86_cc_mode (enum rtx_code code, rtx op0, rtx op1)
16940 {
16941   enum machine_mode mode = GET_MODE (op0);
16942
16943   if (SCALAR_FLOAT_MODE_P (mode))
16944     {
16945       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
16946       return ix86_fp_compare_mode (code);
16947     }
16948
16949   switch (code)
16950     {
16951       /* Only zero flag is needed.  */
16952     case EQ:                    /* ZF=0 */
16953     case NE:                    /* ZF!=0 */
16954       return CCZmode;
16955       /* Codes needing carry flag.  */
16956     case GEU:                   /* CF=0 */
16957     case LTU:                   /* CF=1 */
16958       /* Detect overflow checks.  They need just the carry flag.  */
16959       if (GET_CODE (op0) == PLUS
16960           && rtx_equal_p (op1, XEXP (op0, 0)))
16961         return CCCmode;
16962       else
16963         return CCmode;
16964     case GTU:                   /* CF=0 & ZF=0 */
16965     case LEU:                   /* CF=1 | ZF=1 */
16966       /* Detect overflow checks.  They need just the carry flag.  */
16967       if (GET_CODE (op0) == MINUS
16968           && rtx_equal_p (op1, XEXP (op0, 0)))
16969         return CCCmode;
16970       else
16971         return CCmode;
16972       /* Codes possibly doable only with sign flag when
16973          comparing against zero.  */
16974     case GE:                    /* SF=OF   or   SF=0 */
16975     case LT:                    /* SF<>OF  or   SF=1 */
16976       if (op1 == const0_rtx)
16977         return CCGOCmode;
16978       else
16979         /* For other cases Carry flag is not required.  */
16980         return CCGCmode;
16981       /* Codes doable only with sign flag when comparing
16982          against zero, but we miss jump instruction for it
16983          so we need to use relational tests against overflow
16984          that thus needs to be zero.  */
16985     case GT:                    /* ZF=0 & SF=OF */
16986     case LE:                    /* ZF=1 | SF<>OF */
16987       if (op1 == const0_rtx)
16988         return CCNOmode;
16989       else
16990         return CCGCmode;
16991       /* strcmp pattern do (use flags) and combine may ask us for proper
16992          mode.  */
16993     case USE:
16994       return CCmode;
16995     default:
16996       gcc_unreachable ();
16997     }
16998 }
16999
17000 /* Return the fixed registers used for condition codes.  */
17001
17002 static bool
17003 ix86_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
17004 {
17005   *p1 = FLAGS_REG;
17006   *p2 = FPSR_REG;
17007   return true;
17008 }
17009
17010 /* If two condition code modes are compatible, return a condition code
17011    mode which is compatible with both.  Otherwise, return
17012    VOIDmode.  */
17013
17014 static enum machine_mode
17015 ix86_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
17016 {
17017   if (m1 == m2)
17018     return m1;
17019
17020   if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC)
17021     return VOIDmode;
17022
17023   if ((m1 == CCGCmode && m2 == CCGOCmode)
17024       || (m1 == CCGOCmode && m2 == CCGCmode))
17025     return CCGCmode;
17026
17027   switch (m1)
17028     {
17029     default:
17030       gcc_unreachable ();
17031
17032     case CCmode:
17033     case CCGCmode:
17034     case CCGOCmode:
17035     case CCNOmode:
17036     case CCAmode:
17037     case CCCmode:
17038     case CCOmode:
17039     case CCSmode:
17040     case CCZmode:
17041       switch (m2)
17042         {
17043         default:
17044           return VOIDmode;
17045
17046         case CCmode:
17047         case CCGCmode:
17048         case CCGOCmode:
17049         case CCNOmode:
17050         case CCAmode:
17051         case CCCmode:
17052         case CCOmode:
17053         case CCSmode:
17054         case CCZmode:
17055           return CCmode;
17056         }
17057
17058     case CCFPmode:
17059     case CCFPUmode:
17060       /* These are only compatible with themselves, which we already
17061          checked above.  */
17062       return VOIDmode;
17063     }
17064 }
17065
17066
17067 /* Return a comparison we can do and that it is equivalent to
17068    swap_condition (code) apart possibly from orderedness.
17069    But, never change orderedness if TARGET_IEEE_FP, returning
17070    UNKNOWN in that case if necessary.  */
17071
17072 static enum rtx_code
17073 ix86_fp_swap_condition (enum rtx_code code)
17074 {
17075   switch (code)
17076     {
17077     case GT:                   /* GTU - CF=0 & ZF=0 */
17078       return TARGET_IEEE_FP ? UNKNOWN : UNLT;
17079     case GE:                   /* GEU - CF=0 */
17080       return TARGET_IEEE_FP ? UNKNOWN : UNLE;
17081     case UNLT:                 /* LTU - CF=1 */
17082       return TARGET_IEEE_FP ? UNKNOWN : GT;
17083     case UNLE:                 /* LEU - CF=1 | ZF=1 */
17084       return TARGET_IEEE_FP ? UNKNOWN : GE;
17085     default:
17086       return swap_condition (code);
17087     }
17088 }
17089
17090 /* Return cost of comparison CODE using the best strategy for performance.
17091    All following functions do use number of instructions as a cost metrics.
17092    In future this should be tweaked to compute bytes for optimize_size and
17093    take into account performance of various instructions on various CPUs.  */
17094
17095 static int
17096 ix86_fp_comparison_cost (enum rtx_code code)
17097 {
17098   int arith_cost;
17099
17100   /* The cost of code using bit-twiddling on %ah.  */
17101   switch (code)
17102     {
17103     case UNLE:
17104     case UNLT:
17105     case LTGT:
17106     case GT:
17107     case GE:
17108     case UNORDERED:
17109     case ORDERED:
17110     case UNEQ:
17111       arith_cost = 4;
17112       break;
17113     case LT:
17114     case NE:
17115     case EQ:
17116     case UNGE:
17117       arith_cost = TARGET_IEEE_FP ? 5 : 4;
17118       break;
17119     case LE:
17120     case UNGT:
17121       arith_cost = TARGET_IEEE_FP ? 6 : 4;
17122       break;
17123     default:
17124       gcc_unreachable ();
17125     }
17126
17127   switch (ix86_fp_comparison_strategy (code))
17128     {
17129     case IX86_FPCMP_COMI:
17130       return arith_cost > 4 ? 3 : 2;
17131     case IX86_FPCMP_SAHF:
17132       return arith_cost > 4 ? 4 : 3;
17133     default:
17134       return arith_cost;
17135     }
17136 }
17137
17138 /* Return strategy to use for floating-point.  We assume that fcomi is always
17139    preferrable where available, since that is also true when looking at size
17140    (2 bytes, vs. 3 for fnstsw+sahf and at least 5 for fnstsw+test).  */
17141
17142 enum ix86_fpcmp_strategy
17143 ix86_fp_comparison_strategy (enum rtx_code code ATTRIBUTE_UNUSED)
17144 {
17145   /* Do fcomi/sahf based test when profitable.  */
17146
17147   if (TARGET_CMOVE)
17148     return IX86_FPCMP_COMI;
17149
17150   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_function_for_size_p (cfun)))
17151     return IX86_FPCMP_SAHF;
17152
17153   return IX86_FPCMP_ARITH;
17154 }
17155
17156 /* Swap, force into registers, or otherwise massage the two operands
17157    to a fp comparison.  The operands are updated in place; the new
17158    comparison code is returned.  */
17159
17160 static enum rtx_code
17161 ix86_prepare_fp_compare_args (enum rtx_code code, rtx *pop0, rtx *pop1)
17162 {
17163   enum machine_mode fpcmp_mode = ix86_fp_compare_mode (code);
17164   rtx op0 = *pop0, op1 = *pop1;
17165   enum machine_mode op_mode = GET_MODE (op0);
17166   int is_sse = TARGET_SSE_MATH && SSE_FLOAT_MODE_P (op_mode);
17167
17168   /* All of the unordered compare instructions only work on registers.
17169      The same is true of the fcomi compare instructions.  The XFmode
17170      compare instructions require registers except when comparing
17171      against zero or when converting operand 1 from fixed point to
17172      floating point.  */
17173
17174   if (!is_sse
17175       && (fpcmp_mode == CCFPUmode
17176           || (op_mode == XFmode
17177               && ! (standard_80387_constant_p (op0) == 1
17178                     || standard_80387_constant_p (op1) == 1)
17179               && GET_CODE (op1) != FLOAT)
17180           || ix86_fp_comparison_strategy (code) == IX86_FPCMP_COMI))
17181     {
17182       op0 = force_reg (op_mode, op0);
17183       op1 = force_reg (op_mode, op1);
17184     }
17185   else
17186     {
17187       /* %%% We only allow op1 in memory; op0 must be st(0).  So swap
17188          things around if they appear profitable, otherwise force op0
17189          into a register.  */
17190
17191       if (standard_80387_constant_p (op0) == 0
17192           || (MEM_P (op0)
17193               && ! (standard_80387_constant_p (op1) == 0
17194                     || MEM_P (op1))))
17195         {
17196           enum rtx_code new_code = ix86_fp_swap_condition (code);
17197           if (new_code != UNKNOWN)
17198             {
17199               rtx tmp;
17200               tmp = op0, op0 = op1, op1 = tmp;
17201               code = new_code;
17202             }
17203         }
17204
17205       if (!REG_P (op0))
17206         op0 = force_reg (op_mode, op0);
17207
17208       if (CONSTANT_P (op1))
17209         {
17210           int tmp = standard_80387_constant_p (op1);
17211           if (tmp == 0)
17212             op1 = validize_mem (force_const_mem (op_mode, op1));
17213           else if (tmp == 1)
17214             {
17215               if (TARGET_CMOVE)
17216                 op1 = force_reg (op_mode, op1);
17217             }
17218           else
17219             op1 = force_reg (op_mode, op1);
17220         }
17221     }
17222
17223   /* Try to rearrange the comparison to make it cheaper.  */
17224   if (ix86_fp_comparison_cost (code)
17225       > ix86_fp_comparison_cost (swap_condition (code))
17226       && (REG_P (op1) || can_create_pseudo_p ()))
17227     {
17228       rtx tmp;
17229       tmp = op0, op0 = op1, op1 = tmp;
17230       code = swap_condition (code);
17231       if (!REG_P (op0))
17232         op0 = force_reg (op_mode, op0);
17233     }
17234
17235   *pop0 = op0;
17236   *pop1 = op1;
17237   return code;
17238 }
17239
17240 /* Convert comparison codes we use to represent FP comparison to integer
17241    code that will result in proper branch.  Return UNKNOWN if no such code
17242    is available.  */
17243
17244 enum rtx_code
17245 ix86_fp_compare_code_to_integer (enum rtx_code code)
17246 {
17247   switch (code)
17248     {
17249     case GT:
17250       return GTU;
17251     case GE:
17252       return GEU;
17253     case ORDERED:
17254     case UNORDERED:
17255       return code;
17256       break;
17257     case UNEQ:
17258       return EQ;
17259       break;
17260     case UNLT:
17261       return LTU;
17262       break;
17263     case UNLE:
17264       return LEU;
17265       break;
17266     case LTGT:
17267       return NE;
17268       break;
17269     default:
17270       return UNKNOWN;
17271     }
17272 }
17273
17274 /* Generate insn patterns to do a floating point compare of OPERANDS.  */
17275
17276 static rtx
17277 ix86_expand_fp_compare (enum rtx_code code, rtx op0, rtx op1, rtx scratch)
17278 {
17279   enum machine_mode fpcmp_mode, intcmp_mode;
17280   rtx tmp, tmp2;
17281
17282   fpcmp_mode = ix86_fp_compare_mode (code);
17283   code = ix86_prepare_fp_compare_args (code, &op0, &op1);
17284
17285   /* Do fcomi/sahf based test when profitable.  */
17286   switch (ix86_fp_comparison_strategy (code))
17287     {
17288     case IX86_FPCMP_COMI:
17289       intcmp_mode = fpcmp_mode;
17290       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17291       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17292                          tmp);
17293       emit_insn (tmp);
17294       break;
17295
17296     case IX86_FPCMP_SAHF:
17297       intcmp_mode = fpcmp_mode;
17298       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17299       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
17300                          tmp);
17301
17302       if (!scratch)
17303         scratch = gen_reg_rtx (HImode);
17304       tmp2 = gen_rtx_CLOBBER (VOIDmode, scratch);
17305       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, tmp2)));
17306       break;
17307
17308     case IX86_FPCMP_ARITH:
17309       /* Sadness wrt reg-stack pops killing fpsr -- gotta get fnstsw first.  */
17310       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
17311       tmp2 = gen_rtx_UNSPEC (HImode, gen_rtvec (1, tmp), UNSPEC_FNSTSW);
17312       if (!scratch)
17313         scratch = gen_reg_rtx (HImode);
17314       emit_insn (gen_rtx_SET (VOIDmode, scratch, tmp2));
17315
17316       /* In the unordered case, we have to check C2 for NaN's, which
17317          doesn't happen to work out to anything nice combination-wise.
17318          So do some bit twiddling on the value we've got in AH to come
17319          up with an appropriate set of condition codes.  */
17320
17321       intcmp_mode = CCNOmode;
17322       switch (code)
17323         {
17324         case GT:
17325         case UNGT:
17326           if (code == GT || !TARGET_IEEE_FP)
17327             {
17328               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17329               code = EQ;
17330             }
17331           else
17332             {
17333               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17334               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17335               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x44)));
17336               intcmp_mode = CCmode;
17337               code = GEU;
17338             }
17339           break;
17340         case LT:
17341         case UNLT:
17342           if (code == LT && TARGET_IEEE_FP)
17343             {
17344               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17345               emit_insn (gen_cmpqi_ext_3 (scratch, const1_rtx));
17346               intcmp_mode = CCmode;
17347               code = EQ;
17348             }
17349           else
17350             {
17351               emit_insn (gen_testqi_ext_ccno_0 (scratch, const1_rtx));
17352               code = NE;
17353             }
17354           break;
17355         case GE:
17356         case UNGE:
17357           if (code == GE || !TARGET_IEEE_FP)
17358             {
17359               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x05)));
17360               code = EQ;
17361             }
17362           else
17363             {
17364               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17365               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch, const1_rtx));
17366               code = NE;
17367             }
17368           break;
17369         case LE:
17370         case UNLE:
17371           if (code == LE && TARGET_IEEE_FP)
17372             {
17373               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17374               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
17375               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17376               intcmp_mode = CCmode;
17377               code = LTU;
17378             }
17379           else
17380             {
17381               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
17382               code = NE;
17383             }
17384           break;
17385         case EQ:
17386         case UNEQ:
17387           if (code == EQ && TARGET_IEEE_FP)
17388             {
17389               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17390               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
17391               intcmp_mode = CCmode;
17392               code = EQ;
17393             }
17394           else
17395             {
17396               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17397               code = NE;
17398             }
17399           break;
17400         case NE:
17401         case LTGT:
17402           if (code == NE && TARGET_IEEE_FP)
17403             {
17404               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
17405               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch,
17406                                              GEN_INT (0x40)));
17407               code = NE;
17408             }
17409           else
17410             {
17411               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
17412               code = EQ;
17413             }
17414           break;
17415
17416         case UNORDERED:
17417           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17418           code = NE;
17419           break;
17420         case ORDERED:
17421           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
17422           code = EQ;
17423           break;
17424
17425         default:
17426           gcc_unreachable ();
17427         }
17428         break;
17429
17430     default:
17431       gcc_unreachable();
17432     }
17433
17434   /* Return the test that should be put into the flags user, i.e.
17435      the bcc, scc, or cmov instruction.  */
17436   return gen_rtx_fmt_ee (code, VOIDmode,
17437                          gen_rtx_REG (intcmp_mode, FLAGS_REG),
17438                          const0_rtx);
17439 }
17440
17441 static rtx
17442 ix86_expand_compare (enum rtx_code code, rtx op0, rtx op1)
17443 {
17444   rtx ret;
17445
17446   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
17447     ret = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
17448
17449   else if (SCALAR_FLOAT_MODE_P (GET_MODE (op0)))
17450     {
17451       gcc_assert (!DECIMAL_FLOAT_MODE_P (GET_MODE (op0)));
17452       ret = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
17453     }
17454   else
17455     ret = ix86_expand_int_compare (code, op0, op1);
17456
17457   return ret;
17458 }
17459
17460 void
17461 ix86_expand_branch (enum rtx_code code, rtx op0, rtx op1, rtx label)
17462 {
17463   enum machine_mode mode = GET_MODE (op0);
17464   rtx tmp;
17465
17466   switch (mode)
17467     {
17468     case SFmode:
17469     case DFmode:
17470     case XFmode:
17471     case QImode:
17472     case HImode:
17473     case SImode:
17474       simple:
17475       tmp = ix86_expand_compare (code, op0, op1);
17476       tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
17477                                   gen_rtx_LABEL_REF (VOIDmode, label),
17478                                   pc_rtx);
17479       emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
17480       return;
17481
17482     case DImode:
17483       if (TARGET_64BIT)
17484         goto simple;
17485     case TImode:
17486       /* Expand DImode branch into multiple compare+branch.  */
17487       {
17488         rtx lo[2], hi[2], label2;
17489         enum rtx_code code1, code2, code3;
17490         enum machine_mode submode;
17491
17492         if (CONSTANT_P (op0) && !CONSTANT_P (op1))
17493           {
17494             tmp = op0, op0 = op1, op1 = tmp;
17495             code = swap_condition (code);
17496           }
17497
17498         split_double_mode (mode, &op0, 1, lo+0, hi+0);
17499         split_double_mode (mode, &op1, 1, lo+1, hi+1);
17500
17501         submode = mode == DImode ? SImode : DImode;
17502
17503         /* When comparing for equality, we can use (hi0^hi1)|(lo0^lo1) to
17504            avoid two branches.  This costs one extra insn, so disable when
17505            optimizing for size.  */
17506
17507         if ((code == EQ || code == NE)
17508             && (!optimize_insn_for_size_p ()
17509                 || hi[1] == const0_rtx || lo[1] == const0_rtx))
17510           {
17511             rtx xor0, xor1;
17512
17513             xor1 = hi[0];
17514             if (hi[1] != const0_rtx)
17515               xor1 = expand_binop (submode, xor_optab, xor1, hi[1],
17516                                    NULL_RTX, 0, OPTAB_WIDEN);
17517
17518             xor0 = lo[0];
17519             if (lo[1] != const0_rtx)
17520               xor0 = expand_binop (submode, xor_optab, xor0, lo[1],
17521                                    NULL_RTX, 0, OPTAB_WIDEN);
17522
17523             tmp = expand_binop (submode, ior_optab, xor1, xor0,
17524                                 NULL_RTX, 0, OPTAB_WIDEN);
17525
17526             ix86_expand_branch (code, tmp, const0_rtx, label);
17527             return;
17528           }
17529
17530         /* Otherwise, if we are doing less-than or greater-or-equal-than,
17531            op1 is a constant and the low word is zero, then we can just
17532            examine the high word.  Similarly for low word -1 and
17533            less-or-equal-than or greater-than.  */
17534
17535         if (CONST_INT_P (hi[1]))
17536           switch (code)
17537             {
17538             case LT: case LTU: case GE: case GEU:
17539               if (lo[1] == const0_rtx)
17540                 {
17541                   ix86_expand_branch (code, hi[0], hi[1], label);
17542                   return;
17543                 }
17544               break;
17545             case LE: case LEU: case GT: case GTU:
17546               if (lo[1] == constm1_rtx)
17547                 {
17548                   ix86_expand_branch (code, hi[0], hi[1], label);
17549                   return;
17550                 }
17551               break;
17552             default:
17553               break;
17554             }
17555
17556         /* Otherwise, we need two or three jumps.  */
17557
17558         label2 = gen_label_rtx ();
17559
17560         code1 = code;
17561         code2 = swap_condition (code);
17562         code3 = unsigned_condition (code);
17563
17564         switch (code)
17565           {
17566           case LT: case GT: case LTU: case GTU:
17567             break;
17568
17569           case LE:   code1 = LT;  code2 = GT;  break;
17570           case GE:   code1 = GT;  code2 = LT;  break;
17571           case LEU:  code1 = LTU; code2 = GTU; break;
17572           case GEU:  code1 = GTU; code2 = LTU; break;
17573
17574           case EQ:   code1 = UNKNOWN; code2 = NE;  break;
17575           case NE:   code2 = UNKNOWN; break;
17576
17577           default:
17578             gcc_unreachable ();
17579           }
17580
17581         /*
17582          * a < b =>
17583          *    if (hi(a) < hi(b)) goto true;
17584          *    if (hi(a) > hi(b)) goto false;
17585          *    if (lo(a) < lo(b)) goto true;
17586          *  false:
17587          */
17588
17589         if (code1 != UNKNOWN)
17590           ix86_expand_branch (code1, hi[0], hi[1], label);
17591         if (code2 != UNKNOWN)
17592           ix86_expand_branch (code2, hi[0], hi[1], label2);
17593
17594         ix86_expand_branch (code3, lo[0], lo[1], label);
17595
17596         if (code2 != UNKNOWN)
17597           emit_label (label2);
17598         return;
17599       }
17600
17601     default:
17602       gcc_assert (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC);
17603       goto simple;
17604     }
17605 }
17606
17607 /* Split branch based on floating point condition.  */
17608 void
17609 ix86_split_fp_branch (enum rtx_code code, rtx op1, rtx op2,
17610                       rtx target1, rtx target2, rtx tmp, rtx pushed)
17611 {
17612   rtx condition;
17613   rtx i;
17614
17615   if (target2 != pc_rtx)
17616     {
17617       rtx tmp = target2;
17618       code = reverse_condition_maybe_unordered (code);
17619       target2 = target1;
17620       target1 = tmp;
17621     }
17622
17623   condition = ix86_expand_fp_compare (code, op1, op2,
17624                                       tmp);
17625
17626   /* Remove pushed operand from stack.  */
17627   if (pushed)
17628     ix86_free_from_memory (GET_MODE (pushed));
17629
17630   i = emit_jump_insn (gen_rtx_SET
17631                       (VOIDmode, pc_rtx,
17632                        gen_rtx_IF_THEN_ELSE (VOIDmode,
17633                                              condition, target1, target2)));
17634   if (split_branch_probability >= 0)
17635     add_reg_note (i, REG_BR_PROB, GEN_INT (split_branch_probability));
17636 }
17637
17638 void
17639 ix86_expand_setcc (rtx dest, enum rtx_code code, rtx op0, rtx op1)
17640 {
17641   rtx ret;
17642
17643   gcc_assert (GET_MODE (dest) == QImode);
17644
17645   ret = ix86_expand_compare (code, op0, op1);
17646   PUT_MODE (ret, QImode);
17647   emit_insn (gen_rtx_SET (VOIDmode, dest, ret));
17648 }
17649
17650 /* Expand comparison setting or clearing carry flag.  Return true when
17651    successful and set pop for the operation.  */
17652 static bool
17653 ix86_expand_carry_flag_compare (enum rtx_code code, rtx op0, rtx op1, rtx *pop)
17654 {
17655   enum machine_mode mode =
17656     GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
17657
17658   /* Do not handle double-mode compares that go through special path.  */
17659   if (mode == (TARGET_64BIT ? TImode : DImode))
17660     return false;
17661
17662   if (SCALAR_FLOAT_MODE_P (mode))
17663     {
17664       rtx compare_op, compare_seq;
17665
17666       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
17667
17668       /* Shortcut:  following common codes never translate
17669          into carry flag compares.  */
17670       if (code == EQ || code == NE || code == UNEQ || code == LTGT
17671           || code == ORDERED || code == UNORDERED)
17672         return false;
17673
17674       /* These comparisons require zero flag; swap operands so they won't.  */
17675       if ((code == GT || code == UNLE || code == LE || code == UNGT)
17676           && !TARGET_IEEE_FP)
17677         {
17678           rtx tmp = op0;
17679           op0 = op1;
17680           op1 = tmp;
17681           code = swap_condition (code);
17682         }
17683
17684       /* Try to expand the comparison and verify that we end up with
17685          carry flag based comparison.  This fails to be true only when
17686          we decide to expand comparison using arithmetic that is not
17687          too common scenario.  */
17688       start_sequence ();
17689       compare_op = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
17690       compare_seq = get_insns ();
17691       end_sequence ();
17692
17693       if (GET_MODE (XEXP (compare_op, 0)) == CCFPmode
17694           || GET_MODE (XEXP (compare_op, 0)) == CCFPUmode)
17695         code = ix86_fp_compare_code_to_integer (GET_CODE (compare_op));
17696       else
17697         code = GET_CODE (compare_op);
17698
17699       if (code != LTU && code != GEU)
17700         return false;
17701
17702       emit_insn (compare_seq);
17703       *pop = compare_op;
17704       return true;
17705     }
17706
17707   if (!INTEGRAL_MODE_P (mode))
17708     return false;
17709
17710   switch (code)
17711     {
17712     case LTU:
17713     case GEU:
17714       break;
17715
17716     /* Convert a==0 into (unsigned)a<1.  */
17717     case EQ:
17718     case NE:
17719       if (op1 != const0_rtx)
17720         return false;
17721       op1 = const1_rtx;
17722       code = (code == EQ ? LTU : GEU);
17723       break;
17724
17725     /* Convert a>b into b<a or a>=b-1.  */
17726     case GTU:
17727     case LEU:
17728       if (CONST_INT_P (op1))
17729         {
17730           op1 = gen_int_mode (INTVAL (op1) + 1, GET_MODE (op0));
17731           /* Bail out on overflow.  We still can swap operands but that
17732              would force loading of the constant into register.  */
17733           if (op1 == const0_rtx
17734               || !x86_64_immediate_operand (op1, GET_MODE (op1)))
17735             return false;
17736           code = (code == GTU ? GEU : LTU);
17737         }
17738       else
17739         {
17740           rtx tmp = op1;
17741           op1 = op0;
17742           op0 = tmp;
17743           code = (code == GTU ? LTU : GEU);
17744         }
17745       break;
17746
17747     /* Convert a>=0 into (unsigned)a<0x80000000.  */
17748     case LT:
17749     case GE:
17750       if (mode == DImode || op1 != const0_rtx)
17751         return false;
17752       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
17753       code = (code == LT ? GEU : LTU);
17754       break;
17755     case LE:
17756     case GT:
17757       if (mode == DImode || op1 != constm1_rtx)
17758         return false;
17759       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
17760       code = (code == LE ? GEU : LTU);
17761       break;
17762
17763     default:
17764       return false;
17765     }
17766   /* Swapping operands may cause constant to appear as first operand.  */
17767   if (!nonimmediate_operand (op0, VOIDmode))
17768     {
17769       if (!can_create_pseudo_p ())
17770         return false;
17771       op0 = force_reg (mode, op0);
17772     }
17773   *pop = ix86_expand_compare (code, op0, op1);
17774   gcc_assert (GET_CODE (*pop) == LTU || GET_CODE (*pop) == GEU);
17775   return true;
17776 }
17777
17778 bool
17779 ix86_expand_int_movcc (rtx operands[])
17780 {
17781   enum rtx_code code = GET_CODE (operands[1]), compare_code;
17782   rtx compare_seq, compare_op;
17783   enum machine_mode mode = GET_MODE (operands[0]);
17784   bool sign_bit_compare_p = false;
17785   rtx op0 = XEXP (operands[1], 0);
17786   rtx op1 = XEXP (operands[1], 1);
17787
17788   start_sequence ();
17789   compare_op = ix86_expand_compare (code, op0, op1);
17790   compare_seq = get_insns ();
17791   end_sequence ();
17792
17793   compare_code = GET_CODE (compare_op);
17794
17795   if ((op1 == const0_rtx && (code == GE || code == LT))
17796       || (op1 == constm1_rtx && (code == GT || code == LE)))
17797     sign_bit_compare_p = true;
17798
17799   /* Don't attempt mode expansion here -- if we had to expand 5 or 6
17800      HImode insns, we'd be swallowed in word prefix ops.  */
17801
17802   if ((mode != HImode || TARGET_FAST_PREFIX)
17803       && (mode != (TARGET_64BIT ? TImode : DImode))
17804       && CONST_INT_P (operands[2])
17805       && CONST_INT_P (operands[3]))
17806     {
17807       rtx out = operands[0];
17808       HOST_WIDE_INT ct = INTVAL (operands[2]);
17809       HOST_WIDE_INT cf = INTVAL (operands[3]);
17810       HOST_WIDE_INT diff;
17811
17812       diff = ct - cf;
17813       /*  Sign bit compares are better done using shifts than we do by using
17814           sbb.  */
17815       if (sign_bit_compare_p
17816           || ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
17817         {
17818           /* Detect overlap between destination and compare sources.  */
17819           rtx tmp = out;
17820
17821           if (!sign_bit_compare_p)
17822             {
17823               rtx flags;
17824               bool fpcmp = false;
17825
17826               compare_code = GET_CODE (compare_op);
17827
17828               flags = XEXP (compare_op, 0);
17829
17830               if (GET_MODE (flags) == CCFPmode
17831                   || GET_MODE (flags) == CCFPUmode)
17832                 {
17833                   fpcmp = true;
17834                   compare_code
17835                     = ix86_fp_compare_code_to_integer (compare_code);
17836                 }
17837
17838               /* To simplify rest of code, restrict to the GEU case.  */
17839               if (compare_code == LTU)
17840                 {
17841                   HOST_WIDE_INT tmp = ct;
17842                   ct = cf;
17843                   cf = tmp;
17844                   compare_code = reverse_condition (compare_code);
17845                   code = reverse_condition (code);
17846                 }
17847               else
17848                 {
17849                   if (fpcmp)
17850                     PUT_CODE (compare_op,
17851                               reverse_condition_maybe_unordered
17852                                 (GET_CODE (compare_op)));
17853                   else
17854                     PUT_CODE (compare_op,
17855                               reverse_condition (GET_CODE (compare_op)));
17856                 }
17857               diff = ct - cf;
17858
17859               if (reg_overlap_mentioned_p (out, op0)
17860                   || reg_overlap_mentioned_p (out, op1))
17861                 tmp = gen_reg_rtx (mode);
17862
17863               if (mode == DImode)
17864                 emit_insn (gen_x86_movdicc_0_m1 (tmp, flags, compare_op));
17865               else
17866                 emit_insn (gen_x86_movsicc_0_m1 (gen_lowpart (SImode, tmp),
17867                                                  flags, compare_op));
17868             }
17869           else
17870             {
17871               if (code == GT || code == GE)
17872                 code = reverse_condition (code);
17873               else
17874                 {
17875                   HOST_WIDE_INT tmp = ct;
17876                   ct = cf;
17877                   cf = tmp;
17878                   diff = ct - cf;
17879                 }
17880               tmp = emit_store_flag (tmp, code, op0, op1, VOIDmode, 0, -1);
17881             }
17882
17883           if (diff == 1)
17884             {
17885               /*
17886                * cmpl op0,op1
17887                * sbbl dest,dest
17888                * [addl dest, ct]
17889                *
17890                * Size 5 - 8.
17891                */
17892               if (ct)
17893                 tmp = expand_simple_binop (mode, PLUS,
17894                                            tmp, GEN_INT (ct),
17895                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17896             }
17897           else if (cf == -1)
17898             {
17899               /*
17900                * cmpl op0,op1
17901                * sbbl dest,dest
17902                * orl $ct, dest
17903                *
17904                * Size 8.
17905                */
17906               tmp = expand_simple_binop (mode, IOR,
17907                                          tmp, GEN_INT (ct),
17908                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
17909             }
17910           else if (diff == -1 && ct)
17911             {
17912               /*
17913                * cmpl op0,op1
17914                * sbbl dest,dest
17915                * notl dest
17916                * [addl dest, cf]
17917                *
17918                * Size 8 - 11.
17919                */
17920               tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
17921               if (cf)
17922                 tmp = expand_simple_binop (mode, PLUS,
17923                                            copy_rtx (tmp), GEN_INT (cf),
17924                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17925             }
17926           else
17927             {
17928               /*
17929                * cmpl op0,op1
17930                * sbbl dest,dest
17931                * [notl dest]
17932                * andl cf - ct, dest
17933                * [addl dest, ct]
17934                *
17935                * Size 8 - 11.
17936                */
17937
17938               if (cf == 0)
17939                 {
17940                   cf = ct;
17941                   ct = 0;
17942                   tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
17943                 }
17944
17945               tmp = expand_simple_binop (mode, AND,
17946                                          copy_rtx (tmp),
17947                                          gen_int_mode (cf - ct, mode),
17948                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
17949               if (ct)
17950                 tmp = expand_simple_binop (mode, PLUS,
17951                                            copy_rtx (tmp), GEN_INT (ct),
17952                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
17953             }
17954
17955           if (!rtx_equal_p (tmp, out))
17956             emit_move_insn (copy_rtx (out), copy_rtx (tmp));
17957
17958           return true;
17959         }
17960
17961       if (diff < 0)
17962         {
17963           enum machine_mode cmp_mode = GET_MODE (op0);
17964
17965           HOST_WIDE_INT tmp;
17966           tmp = ct, ct = cf, cf = tmp;
17967           diff = -diff;
17968
17969           if (SCALAR_FLOAT_MODE_P (cmp_mode))
17970             {
17971               gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
17972
17973               /* We may be reversing unordered compare to normal compare, that
17974                  is not valid in general (we may convert non-trapping condition
17975                  to trapping one), however on i386 we currently emit all
17976                  comparisons unordered.  */
17977               compare_code = reverse_condition_maybe_unordered (compare_code);
17978               code = reverse_condition_maybe_unordered (code);
17979             }
17980           else
17981             {
17982               compare_code = reverse_condition (compare_code);
17983               code = reverse_condition (code);
17984             }
17985         }
17986
17987       compare_code = UNKNOWN;
17988       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
17989           && CONST_INT_P (op1))
17990         {
17991           if (op1 == const0_rtx
17992               && (code == LT || code == GE))
17993             compare_code = code;
17994           else if (op1 == constm1_rtx)
17995             {
17996               if (code == LE)
17997                 compare_code = LT;
17998               else if (code == GT)
17999                 compare_code = GE;
18000             }
18001         }
18002
18003       /* Optimize dest = (op0 < 0) ? -1 : cf.  */
18004       if (compare_code != UNKNOWN
18005           && GET_MODE (op0) == GET_MODE (out)
18006           && (cf == -1 || ct == -1))
18007         {
18008           /* If lea code below could be used, only optimize
18009              if it results in a 2 insn sequence.  */
18010
18011           if (! (diff == 1 || diff == 2 || diff == 4 || diff == 8
18012                  || diff == 3 || diff == 5 || diff == 9)
18013               || (compare_code == LT && ct == -1)
18014               || (compare_code == GE && cf == -1))
18015             {
18016               /*
18017                * notl op1       (if necessary)
18018                * sarl $31, op1
18019                * orl cf, op1
18020                */
18021               if (ct != -1)
18022                 {
18023                   cf = ct;
18024                   ct = -1;
18025                   code = reverse_condition (code);
18026                 }
18027
18028               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18029
18030               out = expand_simple_binop (mode, IOR,
18031                                          out, GEN_INT (cf),
18032                                          out, 1, OPTAB_DIRECT);
18033               if (out != operands[0])
18034                 emit_move_insn (operands[0], out);
18035
18036               return true;
18037             }
18038         }
18039
18040
18041       if ((diff == 1 || diff == 2 || diff == 4 || diff == 8
18042            || diff == 3 || diff == 5 || diff == 9)
18043           && ((mode != QImode && mode != HImode) || !TARGET_PARTIAL_REG_STALL)
18044           && (mode != DImode
18045               || x86_64_immediate_operand (GEN_INT (cf), VOIDmode)))
18046         {
18047           /*
18048            * xorl dest,dest
18049            * cmpl op1,op2
18050            * setcc dest
18051            * lea cf(dest*(ct-cf)),dest
18052            *
18053            * Size 14.
18054            *
18055            * This also catches the degenerate setcc-only case.
18056            */
18057
18058           rtx tmp;
18059           int nops;
18060
18061           out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18062
18063           nops = 0;
18064           /* On x86_64 the lea instruction operates on Pmode, so we need
18065              to get arithmetics done in proper mode to match.  */
18066           if (diff == 1)
18067             tmp = copy_rtx (out);
18068           else
18069             {
18070               rtx out1;
18071               out1 = copy_rtx (out);
18072               tmp = gen_rtx_MULT (mode, out1, GEN_INT (diff & ~1));
18073               nops++;
18074               if (diff & 1)
18075                 {
18076                   tmp = gen_rtx_PLUS (mode, tmp, out1);
18077                   nops++;
18078                 }
18079             }
18080           if (cf != 0)
18081             {
18082               tmp = gen_rtx_PLUS (mode, tmp, GEN_INT (cf));
18083               nops++;
18084             }
18085           if (!rtx_equal_p (tmp, out))
18086             {
18087               if (nops == 1)
18088                 out = force_operand (tmp, copy_rtx (out));
18089               else
18090                 emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (out), copy_rtx (tmp)));
18091             }
18092           if (!rtx_equal_p (out, operands[0]))
18093             emit_move_insn (operands[0], copy_rtx (out));
18094
18095           return true;
18096         }
18097
18098       /*
18099        * General case:                  Jumpful:
18100        *   xorl dest,dest               cmpl op1, op2
18101        *   cmpl op1, op2                movl ct, dest
18102        *   setcc dest                   jcc 1f
18103        *   decl dest                    movl cf, dest
18104        *   andl (cf-ct),dest            1:
18105        *   addl ct,dest
18106        *
18107        * Size 20.                       Size 14.
18108        *
18109        * This is reasonably steep, but branch mispredict costs are
18110        * high on modern cpus, so consider failing only if optimizing
18111        * for space.
18112        */
18113
18114       if ((!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18115           && BRANCH_COST (optimize_insn_for_speed_p (),
18116                           false) >= 2)
18117         {
18118           if (cf == 0)
18119             {
18120               enum machine_mode cmp_mode = GET_MODE (op0);
18121
18122               cf = ct;
18123               ct = 0;
18124
18125               if (SCALAR_FLOAT_MODE_P (cmp_mode))
18126                 {
18127                   gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18128
18129                   /* We may be reversing unordered compare to normal compare,
18130                      that is not valid in general (we may convert non-trapping
18131                      condition to trapping one), however on i386 we currently
18132                      emit all comparisons unordered.  */
18133                   code = reverse_condition_maybe_unordered (code);
18134                 }
18135               else
18136                 {
18137                   code = reverse_condition (code);
18138                   if (compare_code != UNKNOWN)
18139                     compare_code = reverse_condition (compare_code);
18140                 }
18141             }
18142
18143           if (compare_code != UNKNOWN)
18144             {
18145               /* notl op1       (if needed)
18146                  sarl $31, op1
18147                  andl (cf-ct), op1
18148                  addl ct, op1
18149
18150                  For x < 0 (resp. x <= -1) there will be no notl,
18151                  so if possible swap the constants to get rid of the
18152                  complement.
18153                  True/false will be -1/0 while code below (store flag
18154                  followed by decrement) is 0/-1, so the constants need
18155                  to be exchanged once more.  */
18156
18157               if (compare_code == GE || !cf)
18158                 {
18159                   code = reverse_condition (code);
18160                   compare_code = LT;
18161                 }
18162               else
18163                 {
18164                   HOST_WIDE_INT tmp = cf;
18165                   cf = ct;
18166                   ct = tmp;
18167                 }
18168
18169               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18170             }
18171           else
18172             {
18173               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18174
18175               out = expand_simple_binop (mode, PLUS, copy_rtx (out),
18176                                          constm1_rtx,
18177                                          copy_rtx (out), 1, OPTAB_DIRECT);
18178             }
18179
18180           out = expand_simple_binop (mode, AND, copy_rtx (out),
18181                                      gen_int_mode (cf - ct, mode),
18182                                      copy_rtx (out), 1, OPTAB_DIRECT);
18183           if (ct)
18184             out = expand_simple_binop (mode, PLUS, copy_rtx (out), GEN_INT (ct),
18185                                        copy_rtx (out), 1, OPTAB_DIRECT);
18186           if (!rtx_equal_p (out, operands[0]))
18187             emit_move_insn (operands[0], copy_rtx (out));
18188
18189           return true;
18190         }
18191     }
18192
18193   if (!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18194     {
18195       /* Try a few things more with specific constants and a variable.  */
18196
18197       optab op;
18198       rtx var, orig_out, out, tmp;
18199
18200       if (BRANCH_COST (optimize_insn_for_speed_p (), false) <= 2)
18201         return false;
18202
18203       /* If one of the two operands is an interesting constant, load a
18204          constant with the above and mask it in with a logical operation.  */
18205
18206       if (CONST_INT_P (operands[2]))
18207         {
18208           var = operands[3];
18209           if (INTVAL (operands[2]) == 0 && operands[3] != constm1_rtx)
18210             operands[3] = constm1_rtx, op = and_optab;
18211           else if (INTVAL (operands[2]) == -1 && operands[3] != const0_rtx)
18212             operands[3] = const0_rtx, op = ior_optab;
18213           else
18214             return false;
18215         }
18216       else if (CONST_INT_P (operands[3]))
18217         {
18218           var = operands[2];
18219           if (INTVAL (operands[3]) == 0 && operands[2] != constm1_rtx)
18220             operands[2] = constm1_rtx, op = and_optab;
18221           else if (INTVAL (operands[3]) == -1 && operands[3] != const0_rtx)
18222             operands[2] = const0_rtx, op = ior_optab;
18223           else
18224             return false;
18225         }
18226       else
18227         return false;
18228
18229       orig_out = operands[0];
18230       tmp = gen_reg_rtx (mode);
18231       operands[0] = tmp;
18232
18233       /* Recurse to get the constant loaded.  */
18234       if (ix86_expand_int_movcc (operands) == 0)
18235         return false;
18236
18237       /* Mask in the interesting variable.  */
18238       out = expand_binop (mode, op, var, tmp, orig_out, 0,
18239                           OPTAB_WIDEN);
18240       if (!rtx_equal_p (out, orig_out))
18241         emit_move_insn (copy_rtx (orig_out), copy_rtx (out));
18242
18243       return true;
18244     }
18245
18246   /*
18247    * For comparison with above,
18248    *
18249    * movl cf,dest
18250    * movl ct,tmp
18251    * cmpl op1,op2
18252    * cmovcc tmp,dest
18253    *
18254    * Size 15.
18255    */
18256
18257   if (! nonimmediate_operand (operands[2], mode))
18258     operands[2] = force_reg (mode, operands[2]);
18259   if (! nonimmediate_operand (operands[3], mode))
18260     operands[3] = force_reg (mode, operands[3]);
18261
18262   if (! register_operand (operands[2], VOIDmode)
18263       && (mode == QImode
18264           || ! register_operand (operands[3], VOIDmode)))
18265     operands[2] = force_reg (mode, operands[2]);
18266
18267   if (mode == QImode
18268       && ! register_operand (operands[3], VOIDmode))
18269     operands[3] = force_reg (mode, operands[3]);
18270
18271   emit_insn (compare_seq);
18272   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
18273                           gen_rtx_IF_THEN_ELSE (mode,
18274                                                 compare_op, operands[2],
18275                                                 operands[3])));
18276   return true;
18277 }
18278
18279 /* Swap, force into registers, or otherwise massage the two operands
18280    to an sse comparison with a mask result.  Thus we differ a bit from
18281    ix86_prepare_fp_compare_args which expects to produce a flags result.
18282
18283    The DEST operand exists to help determine whether to commute commutative
18284    operators.  The POP0/POP1 operands are updated in place.  The new
18285    comparison code is returned, or UNKNOWN if not implementable.  */
18286
18287 static enum rtx_code
18288 ix86_prepare_sse_fp_compare_args (rtx dest, enum rtx_code code,
18289                                   rtx *pop0, rtx *pop1)
18290 {
18291   rtx tmp;
18292
18293   switch (code)
18294     {
18295     case LTGT:
18296     case UNEQ:
18297       /* We have no LTGT as an operator.  We could implement it with
18298          NE & ORDERED, but this requires an extra temporary.  It's
18299          not clear that it's worth it.  */
18300       return UNKNOWN;
18301
18302     case LT:
18303     case LE:
18304     case UNGT:
18305     case UNGE:
18306       /* These are supported directly.  */
18307       break;
18308
18309     case EQ:
18310     case NE:
18311     case UNORDERED:
18312     case ORDERED:
18313       /* For commutative operators, try to canonicalize the destination
18314          operand to be first in the comparison - this helps reload to
18315          avoid extra moves.  */
18316       if (!dest || !rtx_equal_p (dest, *pop1))
18317         break;
18318       /* FALLTHRU */
18319
18320     case GE:
18321     case GT:
18322     case UNLE:
18323     case UNLT:
18324       /* These are not supported directly.  Swap the comparison operands
18325          to transform into something that is supported.  */
18326       tmp = *pop0;
18327       *pop0 = *pop1;
18328       *pop1 = tmp;
18329       code = swap_condition (code);
18330       break;
18331
18332     default:
18333       gcc_unreachable ();
18334     }
18335
18336   return code;
18337 }
18338
18339 /* Detect conditional moves that exactly match min/max operational
18340    semantics.  Note that this is IEEE safe, as long as we don't
18341    interchange the operands.
18342
18343    Returns FALSE if this conditional move doesn't match a MIN/MAX,
18344    and TRUE if the operation is successful and instructions are emitted.  */
18345
18346 static bool
18347 ix86_expand_sse_fp_minmax (rtx dest, enum rtx_code code, rtx cmp_op0,
18348                            rtx cmp_op1, rtx if_true, rtx if_false)
18349 {
18350   enum machine_mode mode;
18351   bool is_min;
18352   rtx tmp;
18353
18354   if (code == LT)
18355     ;
18356   else if (code == UNGE)
18357     {
18358       tmp = if_true;
18359       if_true = if_false;
18360       if_false = tmp;
18361     }
18362   else
18363     return false;
18364
18365   if (rtx_equal_p (cmp_op0, if_true) && rtx_equal_p (cmp_op1, if_false))
18366     is_min = true;
18367   else if (rtx_equal_p (cmp_op1, if_true) && rtx_equal_p (cmp_op0, if_false))
18368     is_min = false;
18369   else
18370     return false;
18371
18372   mode = GET_MODE (dest);
18373
18374   /* We want to check HONOR_NANS and HONOR_SIGNED_ZEROS here,
18375      but MODE may be a vector mode and thus not appropriate.  */
18376   if (!flag_finite_math_only || !flag_unsafe_math_optimizations)
18377     {
18378       int u = is_min ? UNSPEC_IEEE_MIN : UNSPEC_IEEE_MAX;
18379       rtvec v;
18380
18381       if_true = force_reg (mode, if_true);
18382       v = gen_rtvec (2, if_true, if_false);
18383       tmp = gen_rtx_UNSPEC (mode, v, u);
18384     }
18385   else
18386     {
18387       code = is_min ? SMIN : SMAX;
18388       tmp = gen_rtx_fmt_ee (code, mode, if_true, if_false);
18389     }
18390
18391   emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
18392   return true;
18393 }
18394
18395 /* Expand an sse vector comparison.  Return the register with the result.  */
18396
18397 static rtx
18398 ix86_expand_sse_cmp (rtx dest, enum rtx_code code, rtx cmp_op0, rtx cmp_op1,
18399                      rtx op_true, rtx op_false)
18400 {
18401   enum machine_mode mode = GET_MODE (dest);
18402   rtx x;
18403
18404   cmp_op0 = force_reg (mode, cmp_op0);
18405   if (!nonimmediate_operand (cmp_op1, mode))
18406     cmp_op1 = force_reg (mode, cmp_op1);
18407
18408   if (optimize
18409       || reg_overlap_mentioned_p (dest, op_true)
18410       || reg_overlap_mentioned_p (dest, op_false))
18411     dest = gen_reg_rtx (mode);
18412
18413   x = gen_rtx_fmt_ee (code, mode, cmp_op0, cmp_op1);
18414   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18415
18416   return dest;
18417 }
18418
18419 /* Expand DEST = CMP ? OP_TRUE : OP_FALSE into a sequence of logical
18420    operations.  This is used for both scalar and vector conditional moves.  */
18421
18422 static void
18423 ix86_expand_sse_movcc (rtx dest, rtx cmp, rtx op_true, rtx op_false)
18424 {
18425   enum machine_mode mode = GET_MODE (dest);
18426   rtx t2, t3, x;
18427
18428   if (op_false == CONST0_RTX (mode))
18429     {
18430       op_true = force_reg (mode, op_true);
18431       x = gen_rtx_AND (mode, cmp, op_true);
18432       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18433     }
18434   else if (op_true == CONST0_RTX (mode))
18435     {
18436       op_false = force_reg (mode, op_false);
18437       x = gen_rtx_NOT (mode, cmp);
18438       x = gen_rtx_AND (mode, x, op_false);
18439       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18440     }
18441   else if (TARGET_XOP)
18442     {
18443       rtx pcmov = gen_rtx_SET (mode, dest,
18444                                gen_rtx_IF_THEN_ELSE (mode, cmp,
18445                                                      op_true,
18446                                                      op_false));
18447       emit_insn (pcmov);
18448     }
18449   else
18450     {
18451       op_true = force_reg (mode, op_true);
18452       op_false = force_reg (mode, op_false);
18453
18454       t2 = gen_reg_rtx (mode);
18455       if (optimize)
18456         t3 = gen_reg_rtx (mode);
18457       else
18458         t3 = dest;
18459
18460       x = gen_rtx_AND (mode, op_true, cmp);
18461       emit_insn (gen_rtx_SET (VOIDmode, t2, x));
18462
18463       x = gen_rtx_NOT (mode, cmp);
18464       x = gen_rtx_AND (mode, x, op_false);
18465       emit_insn (gen_rtx_SET (VOIDmode, t3, x));
18466
18467       x = gen_rtx_IOR (mode, t3, t2);
18468       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
18469     }
18470 }
18471
18472 /* Expand a floating-point conditional move.  Return true if successful.  */
18473
18474 bool
18475 ix86_expand_fp_movcc (rtx operands[])
18476 {
18477   enum machine_mode mode = GET_MODE (operands[0]);
18478   enum rtx_code code = GET_CODE (operands[1]);
18479   rtx tmp, compare_op;
18480   rtx op0 = XEXP (operands[1], 0);
18481   rtx op1 = XEXP (operands[1], 1);
18482
18483   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
18484     {
18485       enum machine_mode cmode;
18486
18487       /* Since we've no cmove for sse registers, don't force bad register
18488          allocation just to gain access to it.  Deny movcc when the
18489          comparison mode doesn't match the move mode.  */
18490       cmode = GET_MODE (op0);
18491       if (cmode == VOIDmode)
18492         cmode = GET_MODE (op1);
18493       if (cmode != mode)
18494         return false;
18495
18496       code = ix86_prepare_sse_fp_compare_args (operands[0], code, &op0, &op1);
18497       if (code == UNKNOWN)
18498         return false;
18499
18500       if (ix86_expand_sse_fp_minmax (operands[0], code, op0, op1,
18501                                      operands[2], operands[3]))
18502         return true;
18503
18504       tmp = ix86_expand_sse_cmp (operands[0], code, op0, op1,
18505                                  operands[2], operands[3]);
18506       ix86_expand_sse_movcc (operands[0], tmp, operands[2], operands[3]);
18507       return true;
18508     }
18509
18510   /* The floating point conditional move instructions don't directly
18511      support conditions resulting from a signed integer comparison.  */
18512
18513   compare_op = ix86_expand_compare (code, op0, op1);
18514   if (!fcmov_comparison_operator (compare_op, VOIDmode))
18515     {
18516       tmp = gen_reg_rtx (QImode);
18517       ix86_expand_setcc (tmp, code, op0, op1);
18518
18519       compare_op = ix86_expand_compare (NE, tmp, const0_rtx);
18520     }
18521
18522   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
18523                           gen_rtx_IF_THEN_ELSE (mode, compare_op,
18524                                                 operands[2], operands[3])));
18525
18526   return true;
18527 }
18528
18529 /* Expand a floating-point vector conditional move; a vcond operation
18530    rather than a movcc operation.  */
18531
18532 bool
18533 ix86_expand_fp_vcond (rtx operands[])
18534 {
18535   enum rtx_code code = GET_CODE (operands[3]);
18536   rtx cmp;
18537
18538   code = ix86_prepare_sse_fp_compare_args (operands[0], code,
18539                                            &operands[4], &operands[5]);
18540   if (code == UNKNOWN)
18541     return false;
18542
18543   if (ix86_expand_sse_fp_minmax (operands[0], code, operands[4],
18544                                  operands[5], operands[1], operands[2]))
18545     return true;
18546
18547   cmp = ix86_expand_sse_cmp (operands[0], code, operands[4], operands[5],
18548                              operands[1], operands[2]);
18549   ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
18550   return true;
18551 }
18552
18553 /* Expand a signed/unsigned integral vector conditional move.  */
18554
18555 bool
18556 ix86_expand_int_vcond (rtx operands[])
18557 {
18558   enum machine_mode mode = GET_MODE (operands[0]);
18559   enum rtx_code code = GET_CODE (operands[3]);
18560   bool negate = false;
18561   rtx x, cop0, cop1;
18562
18563   cop0 = operands[4];
18564   cop1 = operands[5];
18565
18566   /* XOP supports all of the comparisons on all vector int types.  */
18567   if (!TARGET_XOP)
18568     {
18569       /* Canonicalize the comparison to EQ, GT, GTU.  */
18570       switch (code)
18571         {
18572         case EQ:
18573         case GT:
18574         case GTU:
18575           break;
18576
18577         case NE:
18578         case LE:
18579         case LEU:
18580           code = reverse_condition (code);
18581           negate = true;
18582           break;
18583
18584         case GE:
18585         case GEU:
18586           code = reverse_condition (code);
18587           negate = true;
18588           /* FALLTHRU */
18589
18590         case LT:
18591         case LTU:
18592           code = swap_condition (code);
18593           x = cop0, cop0 = cop1, cop1 = x;
18594           break;
18595
18596         default:
18597           gcc_unreachable ();
18598         }
18599
18600       /* Only SSE4.1/SSE4.2 supports V2DImode.  */
18601       if (mode == V2DImode)
18602         {
18603           switch (code)
18604             {
18605             case EQ:
18606               /* SSE4.1 supports EQ.  */
18607               if (!TARGET_SSE4_1)
18608                 return false;
18609               break;
18610
18611             case GT:
18612             case GTU:
18613               /* SSE4.2 supports GT/GTU.  */
18614               if (!TARGET_SSE4_2)
18615                 return false;
18616               break;
18617
18618             default:
18619               gcc_unreachable ();
18620             }
18621         }
18622
18623       /* Unsigned parallel compare is not supported by the hardware.
18624          Play some tricks to turn this into a signed comparison
18625          against 0.  */
18626       if (code == GTU)
18627         {
18628           cop0 = force_reg (mode, cop0);
18629
18630           switch (mode)
18631             {
18632             case V4SImode:
18633             case V2DImode:
18634                 {
18635                   rtx t1, t2, mask;
18636                   rtx (*gen_sub3) (rtx, rtx, rtx);
18637
18638                   /* Subtract (-(INT MAX) - 1) from both operands to make
18639                      them signed.  */
18640                   mask = ix86_build_signbit_mask (mode, true, false);
18641                   gen_sub3 = (mode == V4SImode
18642                               ? gen_subv4si3 : gen_subv2di3);
18643                   t1 = gen_reg_rtx (mode);
18644                   emit_insn (gen_sub3 (t1, cop0, mask));
18645
18646                   t2 = gen_reg_rtx (mode);
18647                   emit_insn (gen_sub3 (t2, cop1, mask));
18648
18649                   cop0 = t1;
18650                   cop1 = t2;
18651                   code = GT;
18652                 }
18653               break;
18654
18655             case V16QImode:
18656             case V8HImode:
18657               /* Perform a parallel unsigned saturating subtraction.  */
18658               x = gen_reg_rtx (mode);
18659               emit_insn (gen_rtx_SET (VOIDmode, x,
18660                                       gen_rtx_US_MINUS (mode, cop0, cop1)));
18661
18662               cop0 = x;
18663               cop1 = CONST0_RTX (mode);
18664               code = EQ;
18665               negate = !negate;
18666               break;
18667
18668             default:
18669               gcc_unreachable ();
18670             }
18671         }
18672     }
18673
18674   x = ix86_expand_sse_cmp (operands[0], code, cop0, cop1,
18675                            operands[1+negate], operands[2-negate]);
18676
18677   ix86_expand_sse_movcc (operands[0], x, operands[1+negate],
18678                          operands[2-negate]);
18679   return true;
18680 }
18681
18682 /* Unpack OP[1] into the next wider integer vector type.  UNSIGNED_P is
18683    true if we should do zero extension, else sign extension.  HIGH_P is
18684    true if we want the N/2 high elements, else the low elements.  */
18685
18686 void
18687 ix86_expand_sse_unpack (rtx operands[2], bool unsigned_p, bool high_p)
18688 {
18689   enum machine_mode imode = GET_MODE (operands[1]);
18690   rtx tmp, dest;
18691
18692   if (TARGET_SSE4_1)
18693     {
18694       rtx (*unpack)(rtx, rtx);
18695
18696       switch (imode)
18697         {
18698         case V16QImode:
18699           if (unsigned_p)
18700             unpack = gen_sse4_1_zero_extendv8qiv8hi2;
18701           else
18702             unpack = gen_sse4_1_sign_extendv8qiv8hi2;
18703           break;
18704         case V8HImode:
18705           if (unsigned_p)
18706             unpack = gen_sse4_1_zero_extendv4hiv4si2;
18707           else
18708             unpack = gen_sse4_1_sign_extendv4hiv4si2;
18709           break;
18710         case V4SImode:
18711           if (unsigned_p)
18712             unpack = gen_sse4_1_zero_extendv2siv2di2;
18713           else
18714             unpack = gen_sse4_1_sign_extendv2siv2di2;
18715           break;
18716         default:
18717           gcc_unreachable ();
18718         }
18719
18720       if (high_p)
18721         {
18722           /* Shift higher 8 bytes to lower 8 bytes.  */
18723           tmp = gen_reg_rtx (imode);
18724           emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, tmp),
18725                                          gen_lowpart (V1TImode, operands[1]),
18726                                          GEN_INT (64)));
18727         }
18728       else
18729         tmp = operands[1];
18730
18731       emit_insn (unpack (operands[0], tmp));
18732     }
18733   else
18734     {
18735       rtx (*unpack)(rtx, rtx, rtx);
18736
18737       switch (imode)
18738         {
18739         case V16QImode:
18740           if (high_p)
18741             unpack = gen_vec_interleave_highv16qi;
18742           else
18743             unpack = gen_vec_interleave_lowv16qi;
18744           break;
18745         case V8HImode:
18746           if (high_p)
18747             unpack = gen_vec_interleave_highv8hi;
18748           else
18749             unpack = gen_vec_interleave_lowv8hi;
18750           break;
18751         case V4SImode:
18752           if (high_p)
18753             unpack = gen_vec_interleave_highv4si;
18754           else
18755             unpack = gen_vec_interleave_lowv4si;
18756           break;
18757         default:
18758           gcc_unreachable ();
18759         }
18760
18761       dest = gen_lowpart (imode, operands[0]);
18762
18763       if (unsigned_p)
18764         tmp = force_reg (imode, CONST0_RTX (imode));
18765       else
18766         tmp = ix86_expand_sse_cmp (gen_reg_rtx (imode), GT, CONST0_RTX (imode),
18767                                    operands[1], pc_rtx, pc_rtx);
18768
18769       emit_insn (unpack (dest, operands[1], tmp));
18770     }
18771 }
18772
18773 /* Expand conditional increment or decrement using adb/sbb instructions.
18774    The default case using setcc followed by the conditional move can be
18775    done by generic code.  */
18776 bool
18777 ix86_expand_int_addcc (rtx operands[])
18778 {
18779   enum rtx_code code = GET_CODE (operands[1]);
18780   rtx flags;
18781   rtx (*insn)(rtx, rtx, rtx, rtx, rtx);
18782   rtx compare_op;
18783   rtx val = const0_rtx;
18784   bool fpcmp = false;
18785   enum machine_mode mode;
18786   rtx op0 = XEXP (operands[1], 0);
18787   rtx op1 = XEXP (operands[1], 1);
18788
18789   if (operands[3] != const1_rtx
18790       && operands[3] != constm1_rtx)
18791     return false;
18792   if (!ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
18793      return false;
18794   code = GET_CODE (compare_op);
18795
18796   flags = XEXP (compare_op, 0);
18797
18798   if (GET_MODE (flags) == CCFPmode
18799       || GET_MODE (flags) == CCFPUmode)
18800     {
18801       fpcmp = true;
18802       code = ix86_fp_compare_code_to_integer (code);
18803     }
18804
18805   if (code != LTU)
18806     {
18807       val = constm1_rtx;
18808       if (fpcmp)
18809         PUT_CODE (compare_op,
18810                   reverse_condition_maybe_unordered
18811                     (GET_CODE (compare_op)));
18812       else
18813         PUT_CODE (compare_op, reverse_condition (GET_CODE (compare_op)));
18814     }
18815
18816   mode = GET_MODE (operands[0]);
18817
18818   /* Construct either adc or sbb insn.  */
18819   if ((code == LTU) == (operands[3] == constm1_rtx))
18820     {
18821       switch (mode)
18822         {
18823           case QImode:
18824             insn = gen_subqi3_carry;
18825             break;
18826           case HImode:
18827             insn = gen_subhi3_carry;
18828             break;
18829           case SImode:
18830             insn = gen_subsi3_carry;
18831             break;
18832           case DImode:
18833             insn = gen_subdi3_carry;
18834             break;
18835           default:
18836             gcc_unreachable ();
18837         }
18838     }
18839   else
18840     {
18841       switch (mode)
18842         {
18843           case QImode:
18844             insn = gen_addqi3_carry;
18845             break;
18846           case HImode:
18847             insn = gen_addhi3_carry;
18848             break;
18849           case SImode:
18850             insn = gen_addsi3_carry;
18851             break;
18852           case DImode:
18853             insn = gen_adddi3_carry;
18854             break;
18855           default:
18856             gcc_unreachable ();
18857         }
18858     }
18859   emit_insn (insn (operands[0], operands[2], val, flags, compare_op));
18860
18861   return true;
18862 }
18863
18864
18865 /* Split operands 0 and 1 into half-mode parts.  Similar to split_double_mode,
18866    but works for floating pointer parameters and nonoffsetable memories.
18867    For pushes, it returns just stack offsets; the values will be saved
18868    in the right order.  Maximally three parts are generated.  */
18869
18870 static int
18871 ix86_split_to_parts (rtx operand, rtx *parts, enum machine_mode mode)
18872 {
18873   int size;
18874
18875   if (!TARGET_64BIT)
18876     size = mode==XFmode ? 3 : GET_MODE_SIZE (mode) / 4;
18877   else
18878     size = (GET_MODE_SIZE (mode) + 4) / 8;
18879
18880   gcc_assert (!REG_P (operand) || !MMX_REGNO_P (REGNO (operand)));
18881   gcc_assert (size >= 2 && size <= 4);
18882
18883   /* Optimize constant pool reference to immediates.  This is used by fp
18884      moves, that force all constants to memory to allow combining.  */
18885   if (MEM_P (operand) && MEM_READONLY_P (operand))
18886     {
18887       rtx tmp = maybe_get_pool_constant (operand);
18888       if (tmp)
18889         operand = tmp;
18890     }
18891
18892   if (MEM_P (operand) && !offsettable_memref_p (operand))
18893     {
18894       /* The only non-offsetable memories we handle are pushes.  */
18895       int ok = push_operand (operand, VOIDmode);
18896
18897       gcc_assert (ok);
18898
18899       operand = copy_rtx (operand);
18900       PUT_MODE (operand, Pmode);
18901       parts[0] = parts[1] = parts[2] = parts[3] = operand;
18902       return size;
18903     }
18904
18905   if (GET_CODE (operand) == CONST_VECTOR)
18906     {
18907       enum machine_mode imode = int_mode_for_mode (mode);
18908       /* Caution: if we looked through a constant pool memory above,
18909          the operand may actually have a different mode now.  That's
18910          ok, since we want to pun this all the way back to an integer.  */
18911       operand = simplify_subreg (imode, operand, GET_MODE (operand), 0);
18912       gcc_assert (operand != NULL);
18913       mode = imode;
18914     }
18915
18916   if (!TARGET_64BIT)
18917     {
18918       if (mode == DImode)
18919         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
18920       else
18921         {
18922           int i;
18923
18924           if (REG_P (operand))
18925             {
18926               gcc_assert (reload_completed);
18927               for (i = 0; i < size; i++)
18928                 parts[i] = gen_rtx_REG (SImode, REGNO (operand) + i);
18929             }
18930           else if (offsettable_memref_p (operand))
18931             {
18932               operand = adjust_address (operand, SImode, 0);
18933               parts[0] = operand;
18934               for (i = 1; i < size; i++)
18935                 parts[i] = adjust_address (operand, SImode, 4 * i);
18936             }
18937           else if (GET_CODE (operand) == CONST_DOUBLE)
18938             {
18939               REAL_VALUE_TYPE r;
18940               long l[4];
18941
18942               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
18943               switch (mode)
18944                 {
18945                 case TFmode:
18946                   real_to_target (l, &r, mode);
18947                   parts[3] = gen_int_mode (l[3], SImode);
18948                   parts[2] = gen_int_mode (l[2], SImode);
18949                   break;
18950                 case XFmode:
18951                   REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
18952                   parts[2] = gen_int_mode (l[2], SImode);
18953                   break;
18954                 case DFmode:
18955                   REAL_VALUE_TO_TARGET_DOUBLE (r, l);
18956                   break;
18957                 default:
18958                   gcc_unreachable ();
18959                 }
18960               parts[1] = gen_int_mode (l[1], SImode);
18961               parts[0] = gen_int_mode (l[0], SImode);
18962             }
18963           else
18964             gcc_unreachable ();
18965         }
18966     }
18967   else
18968     {
18969       if (mode == TImode)
18970         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
18971       if (mode == XFmode || mode == TFmode)
18972         {
18973           enum machine_mode upper_mode = mode==XFmode ? SImode : DImode;
18974           if (REG_P (operand))
18975             {
18976               gcc_assert (reload_completed);
18977               parts[0] = gen_rtx_REG (DImode, REGNO (operand) + 0);
18978               parts[1] = gen_rtx_REG (upper_mode, REGNO (operand) + 1);
18979             }
18980           else if (offsettable_memref_p (operand))
18981             {
18982               operand = adjust_address (operand, DImode, 0);
18983               parts[0] = operand;
18984               parts[1] = adjust_address (operand, upper_mode, 8);
18985             }
18986           else if (GET_CODE (operand) == CONST_DOUBLE)
18987             {
18988               REAL_VALUE_TYPE r;
18989               long l[4];
18990
18991               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
18992               real_to_target (l, &r, mode);
18993
18994               /* Do not use shift by 32 to avoid warning on 32bit systems.  */
18995               if (HOST_BITS_PER_WIDE_INT >= 64)
18996                 parts[0]
18997                   = gen_int_mode
18998                       ((l[0] & (((HOST_WIDE_INT) 2 << 31) - 1))
18999                        + ((((HOST_WIDE_INT) l[1]) << 31) << 1),
19000                        DImode);
19001               else
19002                 parts[0] = immed_double_const (l[0], l[1], DImode);
19003
19004               if (upper_mode == SImode)
19005                 parts[1] = gen_int_mode (l[2], SImode);
19006               else if (HOST_BITS_PER_WIDE_INT >= 64)
19007                 parts[1]
19008                   = gen_int_mode
19009                       ((l[2] & (((HOST_WIDE_INT) 2 << 31) - 1))
19010                        + ((((HOST_WIDE_INT) l[3]) << 31) << 1),
19011                        DImode);
19012               else
19013                 parts[1] = immed_double_const (l[2], l[3], DImode);
19014             }
19015           else
19016             gcc_unreachable ();
19017         }
19018     }
19019
19020   return size;
19021 }
19022
19023 /* Emit insns to perform a move or push of DI, DF, XF, and TF values.
19024    Return false when normal moves are needed; true when all required
19025    insns have been emitted.  Operands 2-4 contain the input values
19026    int the correct order; operands 5-7 contain the output values.  */
19027
19028 void
19029 ix86_split_long_move (rtx operands[])
19030 {
19031   rtx part[2][4];
19032   int nparts, i, j;
19033   int push = 0;
19034   int collisions = 0;
19035   enum machine_mode mode = GET_MODE (operands[0]);
19036   bool collisionparts[4];
19037
19038   /* The DFmode expanders may ask us to move double.
19039      For 64bit target this is single move.  By hiding the fact
19040      here we simplify i386.md splitters.  */
19041   if (TARGET_64BIT && GET_MODE_SIZE (GET_MODE (operands[0])) == 8)
19042     {
19043       /* Optimize constant pool reference to immediates.  This is used by
19044          fp moves, that force all constants to memory to allow combining.  */
19045
19046       if (MEM_P (operands[1])
19047           && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
19048           && CONSTANT_POOL_ADDRESS_P (XEXP (operands[1], 0)))
19049         operands[1] = get_pool_constant (XEXP (operands[1], 0));
19050       if (push_operand (operands[0], VOIDmode))
19051         {
19052           operands[0] = copy_rtx (operands[0]);
19053           PUT_MODE (operands[0], Pmode);
19054         }
19055       else
19056         operands[0] = gen_lowpart (DImode, operands[0]);
19057       operands[1] = gen_lowpart (DImode, operands[1]);
19058       emit_move_insn (operands[0], operands[1]);
19059       return;
19060     }
19061
19062   /* The only non-offsettable memory we handle is push.  */
19063   if (push_operand (operands[0], VOIDmode))
19064     push = 1;
19065   else
19066     gcc_assert (!MEM_P (operands[0])
19067                 || offsettable_memref_p (operands[0]));
19068
19069   nparts = ix86_split_to_parts (operands[1], part[1], GET_MODE (operands[0]));
19070   ix86_split_to_parts (operands[0], part[0], GET_MODE (operands[0]));
19071
19072   /* When emitting push, take care for source operands on the stack.  */
19073   if (push && MEM_P (operands[1])
19074       && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
19075     {
19076       rtx src_base = XEXP (part[1][nparts - 1], 0);
19077
19078       /* Compensate for the stack decrement by 4.  */
19079       if (!TARGET_64BIT && nparts == 3
19080           && mode == XFmode && TARGET_128BIT_LONG_DOUBLE)
19081         src_base = plus_constant (src_base, 4);
19082
19083       /* src_base refers to the stack pointer and is
19084          automatically decreased by emitted push.  */
19085       for (i = 0; i < nparts; i++)
19086         part[1][i] = change_address (part[1][i],
19087                                      GET_MODE (part[1][i]), src_base);
19088     }
19089
19090   /* We need to do copy in the right order in case an address register
19091      of the source overlaps the destination.  */
19092   if (REG_P (part[0][0]) && MEM_P (part[1][0]))
19093     {
19094       rtx tmp;
19095
19096       for (i = 0; i < nparts; i++)
19097         {
19098           collisionparts[i]
19099             = reg_overlap_mentioned_p (part[0][i], XEXP (part[1][0], 0));
19100           if (collisionparts[i])
19101             collisions++;
19102         }
19103
19104       /* Collision in the middle part can be handled by reordering.  */
19105       if (collisions == 1 && nparts == 3 && collisionparts [1])
19106         {
19107           tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19108           tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19109         }
19110       else if (collisions == 1
19111                && nparts == 4
19112                && (collisionparts [1] || collisionparts [2]))
19113         {
19114           if (collisionparts [1])
19115             {
19116               tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
19117               tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
19118             }
19119           else
19120             {
19121               tmp = part[0][2]; part[0][2] = part[0][3]; part[0][3] = tmp;
19122               tmp = part[1][2]; part[1][2] = part[1][3]; part[1][3] = tmp;
19123             }
19124         }
19125
19126       /* If there are more collisions, we can't handle it by reordering.
19127          Do an lea to the last part and use only one colliding move.  */
19128       else if (collisions > 1)
19129         {
19130           rtx base;
19131
19132           collisions = 1;
19133
19134           base = part[0][nparts - 1];
19135
19136           /* Handle the case when the last part isn't valid for lea.
19137              Happens in 64-bit mode storing the 12-byte XFmode.  */
19138           if (GET_MODE (base) != Pmode)
19139             base = gen_rtx_REG (Pmode, REGNO (base));
19140
19141           emit_insn (gen_rtx_SET (VOIDmode, base, XEXP (part[1][0], 0)));
19142           part[1][0] = replace_equiv_address (part[1][0], base);
19143           for (i = 1; i < nparts; i++)
19144             {
19145               tmp = plus_constant (base, UNITS_PER_WORD * i);
19146               part[1][i] = replace_equiv_address (part[1][i], tmp);
19147             }
19148         }
19149     }
19150
19151   if (push)
19152     {
19153       if (!TARGET_64BIT)
19154         {
19155           if (nparts == 3)
19156             {
19157               if (TARGET_128BIT_LONG_DOUBLE && mode == XFmode)
19158                 emit_insn (gen_addsi3 (stack_pointer_rtx,
19159                                        stack_pointer_rtx, GEN_INT (-4)));
19160               emit_move_insn (part[0][2], part[1][2]);
19161             }
19162           else if (nparts == 4)
19163             {
19164               emit_move_insn (part[0][3], part[1][3]);
19165               emit_move_insn (part[0][2], part[1][2]);
19166             }
19167         }
19168       else
19169         {
19170           /* In 64bit mode we don't have 32bit push available.  In case this is
19171              register, it is OK - we will just use larger counterpart.  We also
19172              retype memory - these comes from attempt to avoid REX prefix on
19173              moving of second half of TFmode value.  */
19174           if (GET_MODE (part[1][1]) == SImode)
19175             {
19176               switch (GET_CODE (part[1][1]))
19177                 {
19178                 case MEM:
19179                   part[1][1] = adjust_address (part[1][1], DImode, 0);
19180                   break;
19181
19182                 case REG:
19183                   part[1][1] = gen_rtx_REG (DImode, REGNO (part[1][1]));
19184                   break;
19185
19186                 default:
19187                   gcc_unreachable ();
19188                 }
19189
19190               if (GET_MODE (part[1][0]) == SImode)
19191                 part[1][0] = part[1][1];
19192             }
19193         }
19194       emit_move_insn (part[0][1], part[1][1]);
19195       emit_move_insn (part[0][0], part[1][0]);
19196       return;
19197     }
19198
19199   /* Choose correct order to not overwrite the source before it is copied.  */
19200   if ((REG_P (part[0][0])
19201        && REG_P (part[1][1])
19202        && (REGNO (part[0][0]) == REGNO (part[1][1])
19203            || (nparts == 3
19204                && REGNO (part[0][0]) == REGNO (part[1][2]))
19205            || (nparts == 4
19206                && REGNO (part[0][0]) == REGNO (part[1][3]))))
19207       || (collisions > 0
19208           && reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0))))
19209     {
19210       for (i = 0, j = nparts - 1; i < nparts; i++, j--)
19211         {
19212           operands[2 + i] = part[0][j];
19213           operands[6 + i] = part[1][j];
19214         }
19215     }
19216   else
19217     {
19218       for (i = 0; i < nparts; i++)
19219         {
19220           operands[2 + i] = part[0][i];
19221           operands[6 + i] = part[1][i];
19222         }
19223     }
19224
19225   /* If optimizing for size, attempt to locally unCSE nonzero constants.  */
19226   if (optimize_insn_for_size_p ())
19227     {
19228       for (j = 0; j < nparts - 1; j++)
19229         if (CONST_INT_P (operands[6 + j])
19230             && operands[6 + j] != const0_rtx
19231             && REG_P (operands[2 + j]))
19232           for (i = j; i < nparts - 1; i++)
19233             if (CONST_INT_P (operands[7 + i])
19234                 && INTVAL (operands[7 + i]) == INTVAL (operands[6 + j]))
19235               operands[7 + i] = operands[2 + j];
19236     }
19237
19238   for (i = 0; i < nparts; i++)
19239     emit_move_insn (operands[2 + i], operands[6 + i]);
19240
19241   return;
19242 }
19243
19244 /* Helper function of ix86_split_ashl used to generate an SImode/DImode
19245    left shift by a constant, either using a single shift or
19246    a sequence of add instructions.  */
19247
19248 static void
19249 ix86_expand_ashl_const (rtx operand, int count, enum machine_mode mode)
19250 {
19251   rtx (*insn)(rtx, rtx, rtx);
19252
19253   if (count == 1
19254       || (count * ix86_cost->add <= ix86_cost->shift_const
19255           && !optimize_insn_for_size_p ()))
19256     {
19257       insn = mode == DImode ? gen_addsi3 : gen_adddi3;
19258       while (count-- > 0)
19259         emit_insn (insn (operand, operand, operand));
19260     }
19261   else
19262     {
19263       insn = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
19264       emit_insn (insn (operand, operand, GEN_INT (count)));
19265     }
19266 }
19267
19268 void
19269 ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode)
19270 {
19271   rtx (*gen_ashl3)(rtx, rtx, rtx);
19272   rtx (*gen_shld)(rtx, rtx, rtx);
19273   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19274
19275   rtx low[2], high[2];
19276   int count;
19277
19278   if (CONST_INT_P (operands[2]))
19279     {
19280       split_double_mode (mode, operands, 2, low, high);
19281       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19282
19283       if (count >= half_width)
19284         {
19285           emit_move_insn (high[0], low[1]);
19286           emit_move_insn (low[0], const0_rtx);
19287
19288           if (count > half_width)
19289             ix86_expand_ashl_const (high[0], count - half_width, mode);
19290         }
19291       else
19292         {
19293           gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
19294
19295           if (!rtx_equal_p (operands[0], operands[1]))
19296             emit_move_insn (operands[0], operands[1]);
19297
19298           emit_insn (gen_shld (high[0], low[0], GEN_INT (count)));
19299           ix86_expand_ashl_const (low[0], count, mode);
19300         }
19301       return;
19302     }
19303
19304   split_double_mode (mode, operands, 1, low, high);
19305
19306   gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
19307
19308   if (operands[1] == const1_rtx)
19309     {
19310       /* Assuming we've chosen a QImode capable registers, then 1 << N
19311          can be done with two 32/64-bit shifts, no branches, no cmoves.  */
19312       if (ANY_QI_REG_P (low[0]) && ANY_QI_REG_P (high[0]))
19313         {
19314           rtx s, d, flags = gen_rtx_REG (CCZmode, FLAGS_REG);
19315
19316           ix86_expand_clear (low[0]);
19317           ix86_expand_clear (high[0]);
19318           emit_insn (gen_testqi_ccz_1 (operands[2], GEN_INT (half_width)));
19319
19320           d = gen_lowpart (QImode, low[0]);
19321           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
19322           s = gen_rtx_EQ (QImode, flags, const0_rtx);
19323           emit_insn (gen_rtx_SET (VOIDmode, d, s));
19324
19325           d = gen_lowpart (QImode, high[0]);
19326           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
19327           s = gen_rtx_NE (QImode, flags, const0_rtx);
19328           emit_insn (gen_rtx_SET (VOIDmode, d, s));
19329         }
19330
19331       /* Otherwise, we can get the same results by manually performing
19332          a bit extract operation on bit 5/6, and then performing the two
19333          shifts.  The two methods of getting 0/1 into low/high are exactly
19334          the same size.  Avoiding the shift in the bit extract case helps
19335          pentium4 a bit; no one else seems to care much either way.  */
19336       else
19337         {
19338           enum machine_mode half_mode;
19339           rtx (*gen_lshr3)(rtx, rtx, rtx);
19340           rtx (*gen_and3)(rtx, rtx, rtx);
19341           rtx (*gen_xor3)(rtx, rtx, rtx);
19342           HOST_WIDE_INT bits;
19343           rtx x;
19344
19345           if (mode == DImode)
19346             {
19347               half_mode = SImode;
19348               gen_lshr3 = gen_lshrsi3;
19349               gen_and3 = gen_andsi3;
19350               gen_xor3 = gen_xorsi3;
19351               bits = 5;
19352             }
19353           else
19354             {
19355               half_mode = DImode;
19356               gen_lshr3 = gen_lshrdi3;
19357               gen_and3 = gen_anddi3;
19358               gen_xor3 = gen_xordi3;
19359               bits = 6;
19360             }
19361
19362           if (TARGET_PARTIAL_REG_STALL && !optimize_insn_for_size_p ())
19363             x = gen_rtx_ZERO_EXTEND (half_mode, operands[2]);
19364           else
19365             x = gen_lowpart (half_mode, operands[2]);
19366           emit_insn (gen_rtx_SET (VOIDmode, high[0], x));
19367
19368           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (bits)));
19369           emit_insn (gen_and3 (high[0], high[0], const1_rtx));
19370           emit_move_insn (low[0], high[0]);
19371           emit_insn (gen_xor3 (low[0], low[0], const1_rtx));
19372         }
19373
19374       emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
19375       emit_insn (gen_ashl3 (high[0], high[0], operands[2]));
19376       return;
19377     }
19378
19379   if (operands[1] == constm1_rtx)
19380     {
19381       /* For -1 << N, we can avoid the shld instruction, because we
19382          know that we're shifting 0...31/63 ones into a -1.  */
19383       emit_move_insn (low[0], constm1_rtx);
19384       if (optimize_insn_for_size_p ())
19385         emit_move_insn (high[0], low[0]);
19386       else
19387         emit_move_insn (high[0], constm1_rtx);
19388     }
19389   else
19390     {
19391       gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
19392
19393       if (!rtx_equal_p (operands[0], operands[1]))
19394         emit_move_insn (operands[0], operands[1]);
19395
19396       split_double_mode (mode, operands, 1, low, high);
19397       emit_insn (gen_shld (high[0], low[0], operands[2]));
19398     }
19399
19400   emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
19401
19402   if (TARGET_CMOVE && scratch)
19403     {
19404       rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19405         = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19406
19407       ix86_expand_clear (scratch);
19408       emit_insn (gen_x86_shift_adj_1 (high[0], low[0], operands[2], scratch));
19409     }
19410   else
19411     {
19412       rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
19413         = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
19414
19415       emit_insn (gen_x86_shift_adj_2 (high[0], low[0], operands[2]));
19416     }
19417 }
19418
19419 void
19420 ix86_split_ashr (rtx *operands, rtx scratch, enum machine_mode mode)
19421 {
19422   rtx (*gen_ashr3)(rtx, rtx, rtx)
19423     = mode == DImode ? gen_ashrsi3 : gen_ashrdi3;
19424   rtx (*gen_shrd)(rtx, rtx, rtx);
19425   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19426
19427   rtx low[2], high[2];
19428   int count;
19429
19430   if (CONST_INT_P (operands[2]))
19431     {
19432       split_double_mode (mode, operands, 2, low, high);
19433       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19434
19435       if (count == GET_MODE_BITSIZE (mode) - 1)
19436         {
19437           emit_move_insn (high[0], high[1]);
19438           emit_insn (gen_ashr3 (high[0], high[0],
19439                                 GEN_INT (half_width - 1)));
19440           emit_move_insn (low[0], high[0]);
19441
19442         }
19443       else if (count >= half_width)
19444         {
19445           emit_move_insn (low[0], high[1]);
19446           emit_move_insn (high[0], low[0]);
19447           emit_insn (gen_ashr3 (high[0], high[0],
19448                                 GEN_INT (half_width - 1)));
19449
19450           if (count > half_width)
19451             emit_insn (gen_ashr3 (low[0], low[0],
19452                                   GEN_INT (count - half_width)));
19453         }
19454       else
19455         {
19456           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19457
19458           if (!rtx_equal_p (operands[0], operands[1]))
19459             emit_move_insn (operands[0], operands[1]);
19460
19461           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
19462           emit_insn (gen_ashr3 (high[0], high[0], GEN_INT (count)));
19463         }
19464     }
19465   else
19466     {
19467       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19468
19469      if (!rtx_equal_p (operands[0], operands[1]))
19470         emit_move_insn (operands[0], operands[1]);
19471
19472       split_double_mode (mode, operands, 1, low, high);
19473
19474       emit_insn (gen_shrd (low[0], high[0], operands[2]));
19475       emit_insn (gen_ashr3 (high[0], high[0], operands[2]));
19476
19477       if (TARGET_CMOVE && scratch)
19478         {
19479           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19480             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19481
19482           emit_move_insn (scratch, high[0]);
19483           emit_insn (gen_ashr3 (scratch, scratch,
19484                                 GEN_INT (half_width - 1)));
19485           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
19486                                           scratch));
19487         }
19488       else
19489         {
19490           rtx (*gen_x86_shift_adj_3)(rtx, rtx, rtx)
19491             = mode == DImode ? gen_x86_shiftsi_adj_3 : gen_x86_shiftdi_adj_3;
19492
19493           emit_insn (gen_x86_shift_adj_3 (low[0], high[0], operands[2]));
19494         }
19495     }
19496 }
19497
19498 void
19499 ix86_split_lshr (rtx *operands, rtx scratch, enum machine_mode mode)
19500 {
19501   rtx (*gen_lshr3)(rtx, rtx, rtx)
19502     = mode == DImode ? gen_lshrsi3 : gen_lshrdi3;
19503   rtx (*gen_shrd)(rtx, rtx, rtx);
19504   int half_width = GET_MODE_BITSIZE (mode) >> 1;
19505
19506   rtx low[2], high[2];
19507   int count;
19508
19509   if (CONST_INT_P (operands[2]))
19510     {
19511       split_double_mode (mode, operands, 2, low, high);
19512       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
19513
19514       if (count >= half_width)
19515         {
19516           emit_move_insn (low[0], high[1]);
19517           ix86_expand_clear (high[0]);
19518
19519           if (count > half_width)
19520             emit_insn (gen_lshr3 (low[0], low[0],
19521                                   GEN_INT (count - half_width)));
19522         }
19523       else
19524         {
19525           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19526
19527           if (!rtx_equal_p (operands[0], operands[1]))
19528             emit_move_insn (operands[0], operands[1]);
19529
19530           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
19531           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (count)));
19532         }
19533     }
19534   else
19535     {
19536       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
19537
19538       if (!rtx_equal_p (operands[0], operands[1]))
19539         emit_move_insn (operands[0], operands[1]);
19540
19541       split_double_mode (mode, operands, 1, low, high);
19542
19543       emit_insn (gen_shrd (low[0], high[0], operands[2]));
19544       emit_insn (gen_lshr3 (high[0], high[0], operands[2]));
19545
19546       if (TARGET_CMOVE && scratch)
19547         {
19548           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
19549             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
19550
19551           ix86_expand_clear (scratch);
19552           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
19553                                           scratch));
19554         }
19555       else
19556         {
19557           rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
19558             = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
19559
19560           emit_insn (gen_x86_shift_adj_2 (low[0], high[0], operands[2]));
19561         }
19562     }
19563 }
19564
19565 /* Predict just emitted jump instruction to be taken with probability PROB.  */
19566 static void
19567 predict_jump (int prob)
19568 {
19569   rtx insn = get_last_insn ();
19570   gcc_assert (JUMP_P (insn));
19571   add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
19572 }
19573
19574 /* Helper function for the string operations below.  Dest VARIABLE whether
19575    it is aligned to VALUE bytes.  If true, jump to the label.  */
19576 static rtx
19577 ix86_expand_aligntest (rtx variable, int value, bool epilogue)
19578 {
19579   rtx label = gen_label_rtx ();
19580   rtx tmpcount = gen_reg_rtx (GET_MODE (variable));
19581   if (GET_MODE (variable) == DImode)
19582     emit_insn (gen_anddi3 (tmpcount, variable, GEN_INT (value)));
19583   else
19584     emit_insn (gen_andsi3 (tmpcount, variable, GEN_INT (value)));
19585   emit_cmp_and_jump_insns (tmpcount, const0_rtx, EQ, 0, GET_MODE (variable),
19586                            1, label);
19587   if (epilogue)
19588     predict_jump (REG_BR_PROB_BASE * 50 / 100);
19589   else
19590     predict_jump (REG_BR_PROB_BASE * 90 / 100);
19591   return label;
19592 }
19593
19594 /* Adjust COUNTER by the VALUE.  */
19595 static void
19596 ix86_adjust_counter (rtx countreg, HOST_WIDE_INT value)
19597 {
19598   rtx (*gen_add)(rtx, rtx, rtx)
19599     = GET_MODE (countreg) == DImode ? gen_adddi3 : gen_addsi3;
19600
19601   emit_insn (gen_add (countreg, countreg, GEN_INT (-value)));
19602 }
19603
19604 /* Zero extend possibly SImode EXP to Pmode register.  */
19605 rtx
19606 ix86_zero_extend_to_Pmode (rtx exp)
19607 {
19608   rtx r;
19609   if (GET_MODE (exp) == VOIDmode)
19610     return force_reg (Pmode, exp);
19611   if (GET_MODE (exp) == Pmode)
19612     return copy_to_mode_reg (Pmode, exp);
19613   r = gen_reg_rtx (Pmode);
19614   emit_insn (gen_zero_extendsidi2 (r, exp));
19615   return r;
19616 }
19617
19618 /* Divide COUNTREG by SCALE.  */
19619 static rtx
19620 scale_counter (rtx countreg, int scale)
19621 {
19622   rtx sc;
19623
19624   if (scale == 1)
19625     return countreg;
19626   if (CONST_INT_P (countreg))
19627     return GEN_INT (INTVAL (countreg) / scale);
19628   gcc_assert (REG_P (countreg));
19629
19630   sc = expand_simple_binop (GET_MODE (countreg), LSHIFTRT, countreg,
19631                             GEN_INT (exact_log2 (scale)),
19632                             NULL, 1, OPTAB_DIRECT);
19633   return sc;
19634 }
19635
19636 /* Return mode for the memcpy/memset loop counter.  Prefer SImode over
19637    DImode for constant loop counts.  */
19638
19639 static enum machine_mode
19640 counter_mode (rtx count_exp)
19641 {
19642   if (GET_MODE (count_exp) != VOIDmode)
19643     return GET_MODE (count_exp);
19644   if (!CONST_INT_P (count_exp))
19645     return Pmode;
19646   if (TARGET_64BIT && (INTVAL (count_exp) & ~0xffffffff))
19647     return DImode;
19648   return SImode;
19649 }
19650
19651 /* When SRCPTR is non-NULL, output simple loop to move memory
19652    pointer to SRCPTR to DESTPTR via chunks of MODE unrolled UNROLL times,
19653    overall size is COUNT specified in bytes.  When SRCPTR is NULL, output the
19654    equivalent loop to set memory by VALUE (supposed to be in MODE).
19655
19656    The size is rounded down to whole number of chunk size moved at once.
19657    SRCMEM and DESTMEM provide MEMrtx to feed proper aliasing info.  */
19658
19659
19660 static void
19661 expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem,
19662                                rtx destptr, rtx srcptr, rtx value,
19663                                rtx count, enum machine_mode mode, int unroll,
19664                                int expected_size)
19665 {
19666   rtx out_label, top_label, iter, tmp;
19667   enum machine_mode iter_mode = counter_mode (count);
19668   rtx piece_size = GEN_INT (GET_MODE_SIZE (mode) * unroll);
19669   rtx piece_size_mask = GEN_INT (~((GET_MODE_SIZE (mode) * unroll) - 1));
19670   rtx size;
19671   rtx x_addr;
19672   rtx y_addr;
19673   int i;
19674
19675   top_label = gen_label_rtx ();
19676   out_label = gen_label_rtx ();
19677   iter = gen_reg_rtx (iter_mode);
19678
19679   size = expand_simple_binop (iter_mode, AND, count, piece_size_mask,
19680                               NULL, 1, OPTAB_DIRECT);
19681   /* Those two should combine.  */
19682   if (piece_size == const1_rtx)
19683     {
19684       emit_cmp_and_jump_insns (size, const0_rtx, EQ, NULL_RTX, iter_mode,
19685                                true, out_label);
19686       predict_jump (REG_BR_PROB_BASE * 10 / 100);
19687     }
19688   emit_move_insn (iter, const0_rtx);
19689
19690   emit_label (top_label);
19691
19692   tmp = convert_modes (Pmode, iter_mode, iter, true);
19693   x_addr = gen_rtx_PLUS (Pmode, destptr, tmp);
19694   destmem = change_address (destmem, mode, x_addr);
19695
19696   if (srcmem)
19697     {
19698       y_addr = gen_rtx_PLUS (Pmode, srcptr, copy_rtx (tmp));
19699       srcmem = change_address (srcmem, mode, y_addr);
19700
19701       /* When unrolling for chips that reorder memory reads and writes,
19702          we can save registers by using single temporary.
19703          Also using 4 temporaries is overkill in 32bit mode.  */
19704       if (!TARGET_64BIT && 0)
19705         {
19706           for (i = 0; i < unroll; i++)
19707             {
19708               if (i)
19709                 {
19710                   destmem =
19711                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19712                   srcmem =
19713                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
19714                 }
19715               emit_move_insn (destmem, srcmem);
19716             }
19717         }
19718       else
19719         {
19720           rtx tmpreg[4];
19721           gcc_assert (unroll <= 4);
19722           for (i = 0; i < unroll; i++)
19723             {
19724               tmpreg[i] = gen_reg_rtx (mode);
19725               if (i)
19726                 {
19727                   srcmem =
19728                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
19729                 }
19730               emit_move_insn (tmpreg[i], srcmem);
19731             }
19732           for (i = 0; i < unroll; i++)
19733             {
19734               if (i)
19735                 {
19736                   destmem =
19737                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19738                 }
19739               emit_move_insn (destmem, tmpreg[i]);
19740             }
19741         }
19742     }
19743   else
19744     for (i = 0; i < unroll; i++)
19745       {
19746         if (i)
19747           destmem =
19748             adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
19749         emit_move_insn (destmem, value);
19750       }
19751
19752   tmp = expand_simple_binop (iter_mode, PLUS, iter, piece_size, iter,
19753                              true, OPTAB_LIB_WIDEN);
19754   if (tmp != iter)
19755     emit_move_insn (iter, tmp);
19756
19757   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
19758                            true, top_label);
19759   if (expected_size != -1)
19760     {
19761       expected_size /= GET_MODE_SIZE (mode) * unroll;
19762       if (expected_size == 0)
19763         predict_jump (0);
19764       else if (expected_size > REG_BR_PROB_BASE)
19765         predict_jump (REG_BR_PROB_BASE - 1);
19766       else
19767         predict_jump (REG_BR_PROB_BASE - (REG_BR_PROB_BASE + expected_size / 2) / expected_size);
19768     }
19769   else
19770     predict_jump (REG_BR_PROB_BASE * 80 / 100);
19771   iter = ix86_zero_extend_to_Pmode (iter);
19772   tmp = expand_simple_binop (Pmode, PLUS, destptr, iter, destptr,
19773                              true, OPTAB_LIB_WIDEN);
19774   if (tmp != destptr)
19775     emit_move_insn (destptr, tmp);
19776   if (srcptr)
19777     {
19778       tmp = expand_simple_binop (Pmode, PLUS, srcptr, iter, srcptr,
19779                                  true, OPTAB_LIB_WIDEN);
19780       if (tmp != srcptr)
19781         emit_move_insn (srcptr, tmp);
19782     }
19783   emit_label (out_label);
19784 }
19785
19786 /* Output "rep; mov" instruction.
19787    Arguments have same meaning as for previous function */
19788 static void
19789 expand_movmem_via_rep_mov (rtx destmem, rtx srcmem,
19790                            rtx destptr, rtx srcptr,
19791                            rtx count,
19792                            enum machine_mode mode)
19793 {
19794   rtx destexp;
19795   rtx srcexp;
19796   rtx countreg;
19797   HOST_WIDE_INT rounded_count;
19798
19799   /* If the size is known, it is shorter to use rep movs.  */
19800   if (mode == QImode && CONST_INT_P (count)
19801       && !(INTVAL (count) & 3))
19802     mode = SImode;
19803
19804   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
19805     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
19806   if (srcptr != XEXP (srcmem, 0) || GET_MODE (srcmem) != BLKmode)
19807     srcmem = adjust_automodify_address_nv (srcmem, BLKmode, srcptr, 0);
19808   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
19809   if (mode != QImode)
19810     {
19811       destexp = gen_rtx_ASHIFT (Pmode, countreg,
19812                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19813       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
19814       srcexp = gen_rtx_ASHIFT (Pmode, countreg,
19815                                GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19816       srcexp = gen_rtx_PLUS (Pmode, srcexp, srcptr);
19817     }
19818   else
19819     {
19820       destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
19821       srcexp = gen_rtx_PLUS (Pmode, srcptr, countreg);
19822     }
19823   if (CONST_INT_P (count))
19824     {
19825       rounded_count = (INTVAL (count)
19826                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
19827       destmem = shallow_copy_rtx (destmem);
19828       srcmem = shallow_copy_rtx (srcmem);
19829       set_mem_size (destmem, rounded_count);
19830       set_mem_size (srcmem, rounded_count);
19831     }
19832   else
19833     {
19834       if (MEM_SIZE_KNOWN_P (destmem))
19835         clear_mem_size (destmem);
19836       if (MEM_SIZE_KNOWN_P (srcmem))
19837         clear_mem_size (srcmem);
19838     }
19839   emit_insn (gen_rep_mov (destptr, destmem, srcptr, srcmem, countreg,
19840                           destexp, srcexp));
19841 }
19842
19843 /* Output "rep; stos" instruction.
19844    Arguments have same meaning as for previous function */
19845 static void
19846 expand_setmem_via_rep_stos (rtx destmem, rtx destptr, rtx value,
19847                             rtx count, enum machine_mode mode,
19848                             rtx orig_value)
19849 {
19850   rtx destexp;
19851   rtx countreg;
19852   HOST_WIDE_INT rounded_count;
19853
19854   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
19855     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
19856   value = force_reg (mode, gen_lowpart (mode, value));
19857   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
19858   if (mode != QImode)
19859     {
19860       destexp = gen_rtx_ASHIFT (Pmode, countreg,
19861                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
19862       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
19863     }
19864   else
19865     destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
19866   if (orig_value == const0_rtx && CONST_INT_P (count))
19867     {
19868       rounded_count = (INTVAL (count)
19869                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
19870       destmem = shallow_copy_rtx (destmem);
19871       set_mem_size (destmem, rounded_count);
19872     }
19873   else if (MEM_SIZE_KNOWN_P (destmem))
19874     clear_mem_size (destmem);
19875   emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp));
19876 }
19877
19878 static void
19879 emit_strmov (rtx destmem, rtx srcmem,
19880              rtx destptr, rtx srcptr, enum machine_mode mode, int offset)
19881 {
19882   rtx src = adjust_automodify_address_nv (srcmem, mode, srcptr, offset);
19883   rtx dest = adjust_automodify_address_nv (destmem, mode, destptr, offset);
19884   emit_insn (gen_strmov (destptr, dest, srcptr, src));
19885 }
19886
19887 /* Output code to copy at most count & (max_size - 1) bytes from SRC to DEST.  */
19888 static void
19889 expand_movmem_epilogue (rtx destmem, rtx srcmem,
19890                         rtx destptr, rtx srcptr, rtx count, int max_size)
19891 {
19892   rtx src, dest;
19893   if (CONST_INT_P (count))
19894     {
19895       HOST_WIDE_INT countval = INTVAL (count);
19896       int offset = 0;
19897
19898       if ((countval & 0x10) && max_size > 16)
19899         {
19900           if (TARGET_64BIT)
19901             {
19902               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
19903               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset + 8);
19904             }
19905           else
19906             gcc_unreachable ();
19907           offset += 16;
19908         }
19909       if ((countval & 0x08) && max_size > 8)
19910         {
19911           if (TARGET_64BIT)
19912             emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
19913           else
19914             {
19915               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
19916               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset + 4);
19917             }
19918           offset += 8;
19919         }
19920       if ((countval & 0x04) && max_size > 4)
19921         {
19922           emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
19923           offset += 4;
19924         }
19925       if ((countval & 0x02) && max_size > 2)
19926         {
19927           emit_strmov (destmem, srcmem, destptr, srcptr, HImode, offset);
19928           offset += 2;
19929         }
19930       if ((countval & 0x01) && max_size > 1)
19931         {
19932           emit_strmov (destmem, srcmem, destptr, srcptr, QImode, offset);
19933           offset += 1;
19934         }
19935       return;
19936     }
19937   if (max_size > 8)
19938     {
19939       count = expand_simple_binop (GET_MODE (count), AND, count, GEN_INT (max_size - 1),
19940                                     count, 1, OPTAB_DIRECT);
19941       expand_set_or_movmem_via_loop (destmem, srcmem, destptr, srcptr, NULL,
19942                                      count, QImode, 1, 4);
19943       return;
19944     }
19945
19946   /* When there are stringops, we can cheaply increase dest and src pointers.
19947      Otherwise we save code size by maintaining offset (zero is readily
19948      available from preceding rep operation) and using x86 addressing modes.
19949    */
19950   if (TARGET_SINGLE_STRINGOP)
19951     {
19952       if (max_size > 4)
19953         {
19954           rtx label = ix86_expand_aligntest (count, 4, true);
19955           src = change_address (srcmem, SImode, srcptr);
19956           dest = change_address (destmem, SImode, destptr);
19957           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19958           emit_label (label);
19959           LABEL_NUSES (label) = 1;
19960         }
19961       if (max_size > 2)
19962         {
19963           rtx label = ix86_expand_aligntest (count, 2, true);
19964           src = change_address (srcmem, HImode, srcptr);
19965           dest = change_address (destmem, HImode, destptr);
19966           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19967           emit_label (label);
19968           LABEL_NUSES (label) = 1;
19969         }
19970       if (max_size > 1)
19971         {
19972           rtx label = ix86_expand_aligntest (count, 1, true);
19973           src = change_address (srcmem, QImode, srcptr);
19974           dest = change_address (destmem, QImode, destptr);
19975           emit_insn (gen_strmov (destptr, dest, srcptr, src));
19976           emit_label (label);
19977           LABEL_NUSES (label) = 1;
19978         }
19979     }
19980   else
19981     {
19982       rtx offset = force_reg (Pmode, const0_rtx);
19983       rtx tmp;
19984
19985       if (max_size > 4)
19986         {
19987           rtx label = ix86_expand_aligntest (count, 4, true);
19988           src = change_address (srcmem, SImode, srcptr);
19989           dest = change_address (destmem, SImode, destptr);
19990           emit_move_insn (dest, src);
19991           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (4), NULL,
19992                                      true, OPTAB_LIB_WIDEN);
19993           if (tmp != offset)
19994             emit_move_insn (offset, tmp);
19995           emit_label (label);
19996           LABEL_NUSES (label) = 1;
19997         }
19998       if (max_size > 2)
19999         {
20000           rtx label = ix86_expand_aligntest (count, 2, true);
20001           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
20002           src = change_address (srcmem, HImode, tmp);
20003           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
20004           dest = change_address (destmem, HImode, tmp);
20005           emit_move_insn (dest, src);
20006           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (2), tmp,
20007                                      true, OPTAB_LIB_WIDEN);
20008           if (tmp != offset)
20009             emit_move_insn (offset, tmp);
20010           emit_label (label);
20011           LABEL_NUSES (label) = 1;
20012         }
20013       if (max_size > 1)
20014         {
20015           rtx label = ix86_expand_aligntest (count, 1, true);
20016           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
20017           src = change_address (srcmem, QImode, tmp);
20018           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
20019           dest = change_address (destmem, QImode, tmp);
20020           emit_move_insn (dest, src);
20021           emit_label (label);
20022           LABEL_NUSES (label) = 1;
20023         }
20024     }
20025 }
20026
20027 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
20028 static void
20029 expand_setmem_epilogue_via_loop (rtx destmem, rtx destptr, rtx value,
20030                                  rtx count, int max_size)
20031 {
20032   count =
20033     expand_simple_binop (counter_mode (count), AND, count,
20034                          GEN_INT (max_size - 1), count, 1, OPTAB_DIRECT);
20035   expand_set_or_movmem_via_loop (destmem, NULL, destptr, NULL,
20036                                  gen_lowpart (QImode, value), count, QImode,
20037                                  1, max_size / 2);
20038 }
20039
20040 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
20041 static void
20042 expand_setmem_epilogue (rtx destmem, rtx destptr, rtx value, rtx count, int max_size)
20043 {
20044   rtx dest;
20045
20046   if (CONST_INT_P (count))
20047     {
20048       HOST_WIDE_INT countval = INTVAL (count);
20049       int offset = 0;
20050
20051       if ((countval & 0x10) && max_size > 16)
20052         {
20053           if (TARGET_64BIT)
20054             {
20055               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
20056               emit_insn (gen_strset (destptr, dest, value));
20057               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset + 8);
20058               emit_insn (gen_strset (destptr, dest, value));
20059             }
20060           else
20061             gcc_unreachable ();
20062           offset += 16;
20063         }
20064       if ((countval & 0x08) && max_size > 8)
20065         {
20066           if (TARGET_64BIT)
20067             {
20068               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
20069               emit_insn (gen_strset (destptr, dest, value));
20070             }
20071           else
20072             {
20073               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
20074               emit_insn (gen_strset (destptr, dest, value));
20075               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset + 4);
20076               emit_insn (gen_strset (destptr, dest, value));
20077             }
20078           offset += 8;
20079         }
20080       if ((countval & 0x04) && max_size > 4)
20081         {
20082           dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
20083           emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
20084           offset += 4;
20085         }
20086       if ((countval & 0x02) && max_size > 2)
20087         {
20088           dest = adjust_automodify_address_nv (destmem, HImode, destptr, offset);
20089           emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
20090           offset += 2;
20091         }
20092       if ((countval & 0x01) && max_size > 1)
20093         {
20094           dest = adjust_automodify_address_nv (destmem, QImode, destptr, offset);
20095           emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20096           offset += 1;
20097         }
20098       return;
20099     }
20100   if (max_size > 32)
20101     {
20102       expand_setmem_epilogue_via_loop (destmem, destptr, value, count, max_size);
20103       return;
20104     }
20105   if (max_size > 16)
20106     {
20107       rtx label = ix86_expand_aligntest (count, 16, true);
20108       if (TARGET_64BIT)
20109         {
20110           dest = change_address (destmem, DImode, destptr);
20111           emit_insn (gen_strset (destptr, dest, value));
20112           emit_insn (gen_strset (destptr, dest, value));
20113         }
20114       else
20115         {
20116           dest = change_address (destmem, SImode, destptr);
20117           emit_insn (gen_strset (destptr, dest, value));
20118           emit_insn (gen_strset (destptr, dest, value));
20119           emit_insn (gen_strset (destptr, dest, value));
20120           emit_insn (gen_strset (destptr, dest, value));
20121         }
20122       emit_label (label);
20123       LABEL_NUSES (label) = 1;
20124     }
20125   if (max_size > 8)
20126     {
20127       rtx label = ix86_expand_aligntest (count, 8, true);
20128       if (TARGET_64BIT)
20129         {
20130           dest = change_address (destmem, DImode, destptr);
20131           emit_insn (gen_strset (destptr, dest, value));
20132         }
20133       else
20134         {
20135           dest = change_address (destmem, SImode, destptr);
20136           emit_insn (gen_strset (destptr, dest, value));
20137           emit_insn (gen_strset (destptr, dest, value));
20138         }
20139       emit_label (label);
20140       LABEL_NUSES (label) = 1;
20141     }
20142   if (max_size > 4)
20143     {
20144       rtx label = ix86_expand_aligntest (count, 4, true);
20145       dest = change_address (destmem, SImode, destptr);
20146       emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
20147       emit_label (label);
20148       LABEL_NUSES (label) = 1;
20149     }
20150   if (max_size > 2)
20151     {
20152       rtx label = ix86_expand_aligntest (count, 2, true);
20153       dest = change_address (destmem, HImode, destptr);
20154       emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
20155       emit_label (label);
20156       LABEL_NUSES (label) = 1;
20157     }
20158   if (max_size > 1)
20159     {
20160       rtx label = ix86_expand_aligntest (count, 1, true);
20161       dest = change_address (destmem, QImode, destptr);
20162       emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
20163       emit_label (label);
20164       LABEL_NUSES (label) = 1;
20165     }
20166 }
20167
20168 /* Copy enough from DEST to SRC to align DEST known to by aligned by ALIGN to
20169    DESIRED_ALIGNMENT.  */
20170 static void
20171 expand_movmem_prologue (rtx destmem, rtx srcmem,
20172                         rtx destptr, rtx srcptr, rtx count,
20173                         int align, int desired_alignment)
20174 {
20175   if (align <= 1 && desired_alignment > 1)
20176     {
20177       rtx label = ix86_expand_aligntest (destptr, 1, false);
20178       srcmem = change_address (srcmem, QImode, srcptr);
20179       destmem = change_address (destmem, QImode, destptr);
20180       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20181       ix86_adjust_counter (count, 1);
20182       emit_label (label);
20183       LABEL_NUSES (label) = 1;
20184     }
20185   if (align <= 2 && desired_alignment > 2)
20186     {
20187       rtx label = ix86_expand_aligntest (destptr, 2, false);
20188       srcmem = change_address (srcmem, HImode, srcptr);
20189       destmem = change_address (destmem, HImode, destptr);
20190       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20191       ix86_adjust_counter (count, 2);
20192       emit_label (label);
20193       LABEL_NUSES (label) = 1;
20194     }
20195   if (align <= 4 && desired_alignment > 4)
20196     {
20197       rtx label = ix86_expand_aligntest (destptr, 4, false);
20198       srcmem = change_address (srcmem, SImode, srcptr);
20199       destmem = change_address (destmem, SImode, destptr);
20200       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
20201       ix86_adjust_counter (count, 4);
20202       emit_label (label);
20203       LABEL_NUSES (label) = 1;
20204     }
20205   gcc_assert (desired_alignment <= 8);
20206 }
20207
20208 /* Copy enough from DST to SRC to align DST known to DESIRED_ALIGN.
20209    ALIGN_BYTES is how many bytes need to be copied.  */
20210 static rtx
20211 expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg,
20212                                  int desired_align, int align_bytes)
20213 {
20214   rtx src = *srcp;
20215   rtx orig_dst = dst;
20216   rtx orig_src = src;
20217   int off = 0;
20218   int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT);
20219   if (src_align_bytes >= 0)
20220     src_align_bytes = desired_align - src_align_bytes;
20221   if (align_bytes & 1)
20222     {
20223       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
20224       src = adjust_automodify_address_nv (src, QImode, srcreg, 0);
20225       off = 1;
20226       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20227     }
20228   if (align_bytes & 2)
20229     {
20230       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
20231       src = adjust_automodify_address_nv (src, HImode, srcreg, off);
20232       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
20233         set_mem_align (dst, 2 * BITS_PER_UNIT);
20234       if (src_align_bytes >= 0
20235           && (src_align_bytes & 1) == (align_bytes & 1)
20236           && MEM_ALIGN (src) < 2 * BITS_PER_UNIT)
20237         set_mem_align (src, 2 * BITS_PER_UNIT);
20238       off = 2;
20239       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20240     }
20241   if (align_bytes & 4)
20242     {
20243       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
20244       src = adjust_automodify_address_nv (src, SImode, srcreg, off);
20245       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
20246         set_mem_align (dst, 4 * BITS_PER_UNIT);
20247       if (src_align_bytes >= 0)
20248         {
20249           unsigned int src_align = 0;
20250           if ((src_align_bytes & 3) == (align_bytes & 3))
20251             src_align = 4;
20252           else if ((src_align_bytes & 1) == (align_bytes & 1))
20253             src_align = 2;
20254           if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20255             set_mem_align (src, src_align * BITS_PER_UNIT);
20256         }
20257       off = 4;
20258       emit_insn (gen_strmov (destreg, dst, srcreg, src));
20259     }
20260   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
20261   src = adjust_automodify_address_nv (src, BLKmode, srcreg, off);
20262   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
20263     set_mem_align (dst, desired_align * BITS_PER_UNIT);
20264   if (src_align_bytes >= 0)
20265     {
20266       unsigned int src_align = 0;
20267       if ((src_align_bytes & 7) == (align_bytes & 7))
20268         src_align = 8;
20269       else if ((src_align_bytes & 3) == (align_bytes & 3))
20270         src_align = 4;
20271       else if ((src_align_bytes & 1) == (align_bytes & 1))
20272         src_align = 2;
20273       if (src_align > (unsigned int) desired_align)
20274         src_align = desired_align;
20275       if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
20276         set_mem_align (src, src_align * BITS_PER_UNIT);
20277     }
20278   if (MEM_SIZE_KNOWN_P (orig_dst))
20279     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
20280   if (MEM_SIZE_KNOWN_P (orig_src))
20281     set_mem_size (src, MEM_SIZE (orig_src) - align_bytes);
20282   *srcp = src;
20283   return dst;
20284 }
20285
20286 /* Set enough from DEST to align DEST known to by aligned by ALIGN to
20287    DESIRED_ALIGNMENT.  */
20288 static void
20289 expand_setmem_prologue (rtx destmem, rtx destptr, rtx value, rtx count,
20290                         int align, int desired_alignment)
20291 {
20292   if (align <= 1 && desired_alignment > 1)
20293     {
20294       rtx label = ix86_expand_aligntest (destptr, 1, false);
20295       destmem = change_address (destmem, QImode, destptr);
20296       emit_insn (gen_strset (destptr, destmem, gen_lowpart (QImode, value)));
20297       ix86_adjust_counter (count, 1);
20298       emit_label (label);
20299       LABEL_NUSES (label) = 1;
20300     }
20301   if (align <= 2 && desired_alignment > 2)
20302     {
20303       rtx label = ix86_expand_aligntest (destptr, 2, false);
20304       destmem = change_address (destmem, HImode, destptr);
20305       emit_insn (gen_strset (destptr, destmem, gen_lowpart (HImode, value)));
20306       ix86_adjust_counter (count, 2);
20307       emit_label (label);
20308       LABEL_NUSES (label) = 1;
20309     }
20310   if (align <= 4 && desired_alignment > 4)
20311     {
20312       rtx label = ix86_expand_aligntest (destptr, 4, false);
20313       destmem = change_address (destmem, SImode, destptr);
20314       emit_insn (gen_strset (destptr, destmem, gen_lowpart (SImode, value)));
20315       ix86_adjust_counter (count, 4);
20316       emit_label (label);
20317       LABEL_NUSES (label) = 1;
20318     }
20319   gcc_assert (desired_alignment <= 8);
20320 }
20321
20322 /* Set enough from DST to align DST known to by aligned by ALIGN to
20323    DESIRED_ALIGN.  ALIGN_BYTES is how many bytes need to be stored.  */
20324 static rtx
20325 expand_constant_setmem_prologue (rtx dst, rtx destreg, rtx value,
20326                                  int desired_align, int align_bytes)
20327 {
20328   int off = 0;
20329   rtx orig_dst = dst;
20330   if (align_bytes & 1)
20331     {
20332       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
20333       off = 1;
20334       emit_insn (gen_strset (destreg, dst,
20335                              gen_lowpart (QImode, value)));
20336     }
20337   if (align_bytes & 2)
20338     {
20339       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
20340       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
20341         set_mem_align (dst, 2 * BITS_PER_UNIT);
20342       off = 2;
20343       emit_insn (gen_strset (destreg, dst,
20344                              gen_lowpart (HImode, value)));
20345     }
20346   if (align_bytes & 4)
20347     {
20348       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
20349       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
20350         set_mem_align (dst, 4 * BITS_PER_UNIT);
20351       off = 4;
20352       emit_insn (gen_strset (destreg, dst,
20353                              gen_lowpart (SImode, value)));
20354     }
20355   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
20356   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
20357     set_mem_align (dst, desired_align * BITS_PER_UNIT);
20358   if (MEM_SIZE_KNOWN_P (orig_dst))
20359     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
20360   return dst;
20361 }
20362
20363 /* Given COUNT and EXPECTED_SIZE, decide on codegen of string operation.  */
20364 static enum stringop_alg
20365 decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset,
20366             int *dynamic_check)
20367 {
20368   const struct stringop_algs * algs;
20369   bool optimize_for_speed;
20370   /* Algorithms using the rep prefix want at least edi and ecx;
20371      additionally, memset wants eax and memcpy wants esi.  Don't
20372      consider such algorithms if the user has appropriated those
20373      registers for their own purposes.  */
20374   bool rep_prefix_usable = !(fixed_regs[CX_REG] || fixed_regs[DI_REG]
20375                              || (memset
20376                                  ? fixed_regs[AX_REG] : fixed_regs[SI_REG]));
20377
20378 #define ALG_USABLE_P(alg) (rep_prefix_usable                    \
20379                            || (alg != rep_prefix_1_byte         \
20380                                && alg != rep_prefix_4_byte      \
20381                                && alg != rep_prefix_8_byte))
20382   const struct processor_costs *cost;
20383
20384   /* Even if the string operation call is cold, we still might spend a lot
20385      of time processing large blocks.  */
20386   if (optimize_function_for_size_p (cfun)
20387       || (optimize_insn_for_size_p ()
20388           && expected_size != -1 && expected_size < 256))
20389     optimize_for_speed = false;
20390   else
20391     optimize_for_speed = true;
20392
20393   cost = optimize_for_speed ? ix86_cost : &ix86_size_cost;
20394
20395   *dynamic_check = -1;
20396   if (memset)
20397     algs = &cost->memset[TARGET_64BIT != 0];
20398   else
20399     algs = &cost->memcpy[TARGET_64BIT != 0];
20400   if (ix86_stringop_alg != no_stringop && ALG_USABLE_P (ix86_stringop_alg))
20401     return ix86_stringop_alg;
20402   /* rep; movq or rep; movl is the smallest variant.  */
20403   else if (!optimize_for_speed)
20404     {
20405       if (!count || (count & 3))
20406         return rep_prefix_usable ? rep_prefix_1_byte : loop_1_byte;
20407       else
20408         return rep_prefix_usable ? rep_prefix_4_byte : loop;
20409     }
20410   /* Very tiny blocks are best handled via the loop, REP is expensive to setup.
20411    */
20412   else if (expected_size != -1 && expected_size < 4)
20413     return loop_1_byte;
20414   else if (expected_size != -1)
20415     {
20416       unsigned int i;
20417       enum stringop_alg alg = libcall;
20418       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
20419         {
20420           /* We get here if the algorithms that were not libcall-based
20421              were rep-prefix based and we are unable to use rep prefixes
20422              based on global register usage.  Break out of the loop and
20423              use the heuristic below.  */
20424           if (algs->size[i].max == 0)
20425             break;
20426           if (algs->size[i].max >= expected_size || algs->size[i].max == -1)
20427             {
20428               enum stringop_alg candidate = algs->size[i].alg;
20429
20430               if (candidate != libcall && ALG_USABLE_P (candidate))
20431                 alg = candidate;
20432               /* Honor TARGET_INLINE_ALL_STRINGOPS by picking
20433                  last non-libcall inline algorithm.  */
20434               if (TARGET_INLINE_ALL_STRINGOPS)
20435                 {
20436                   /* When the current size is best to be copied by a libcall,
20437                      but we are still forced to inline, run the heuristic below
20438                      that will pick code for medium sized blocks.  */
20439                   if (alg != libcall)
20440                     return alg;
20441                   break;
20442                 }
20443               else if (ALG_USABLE_P (candidate))
20444                 return candidate;
20445             }
20446         }
20447       gcc_assert (TARGET_INLINE_ALL_STRINGOPS || !rep_prefix_usable);
20448     }
20449   /* When asked to inline the call anyway, try to pick meaningful choice.
20450      We look for maximal size of block that is faster to copy by hand and
20451      take blocks of at most of that size guessing that average size will
20452      be roughly half of the block.
20453
20454      If this turns out to be bad, we might simply specify the preferred
20455      choice in ix86_costs.  */
20456   if ((TARGET_INLINE_ALL_STRINGOPS || TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20457       && (algs->unknown_size == libcall || !ALG_USABLE_P (algs->unknown_size)))
20458     {
20459       int max = -1;
20460       enum stringop_alg alg;
20461       int i;
20462       bool any_alg_usable_p = true;
20463
20464       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
20465         {
20466           enum stringop_alg candidate = algs->size[i].alg;
20467           any_alg_usable_p = any_alg_usable_p && ALG_USABLE_P (candidate);
20468
20469           if (candidate != libcall && candidate
20470               && ALG_USABLE_P (candidate))
20471               max = algs->size[i].max;
20472         }
20473       /* If there aren't any usable algorithms, then recursing on
20474          smaller sizes isn't going to find anything.  Just return the
20475          simple byte-at-a-time copy loop.  */
20476       if (!any_alg_usable_p)
20477         {
20478           /* Pick something reasonable.  */
20479           if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20480             *dynamic_check = 128;
20481           return loop_1_byte;
20482         }
20483       if (max == -1)
20484         max = 4096;
20485       alg = decide_alg (count, max / 2, memset, dynamic_check);
20486       gcc_assert (*dynamic_check == -1);
20487       gcc_assert (alg != libcall);
20488       if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
20489         *dynamic_check = max;
20490       return alg;
20491     }
20492   return ALG_USABLE_P (algs->unknown_size) ? algs->unknown_size : libcall;
20493 #undef ALG_USABLE_P
20494 }
20495
20496 /* Decide on alignment.  We know that the operand is already aligned to ALIGN
20497    (ALIGN can be based on profile feedback and thus it is not 100% guaranteed).  */
20498 static int
20499 decide_alignment (int align,
20500                   enum stringop_alg alg,
20501                   int expected_size)
20502 {
20503   int desired_align = 0;
20504   switch (alg)
20505     {
20506       case no_stringop:
20507         gcc_unreachable ();
20508       case loop:
20509       case unrolled_loop:
20510         desired_align = GET_MODE_SIZE (Pmode);
20511         break;
20512       case rep_prefix_8_byte:
20513         desired_align = 8;
20514         break;
20515       case rep_prefix_4_byte:
20516         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
20517            copying whole cacheline at once.  */
20518         if (TARGET_PENTIUMPRO)
20519           desired_align = 8;
20520         else
20521           desired_align = 4;
20522         break;
20523       case rep_prefix_1_byte:
20524         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
20525            copying whole cacheline at once.  */
20526         if (TARGET_PENTIUMPRO)
20527           desired_align = 8;
20528         else
20529           desired_align = 1;
20530         break;
20531       case loop_1_byte:
20532         desired_align = 1;
20533         break;
20534       case libcall:
20535         return 0;
20536     }
20537
20538   if (optimize_size)
20539     desired_align = 1;
20540   if (desired_align < align)
20541     desired_align = align;
20542   if (expected_size != -1 && expected_size < 4)
20543     desired_align = align;
20544   return desired_align;
20545 }
20546
20547 /* Return the smallest power of 2 greater than VAL.  */
20548 static int
20549 smallest_pow2_greater_than (int val)
20550 {
20551   int ret = 1;
20552   while (ret <= val)
20553     ret <<= 1;
20554   return ret;
20555 }
20556
20557 /* Expand string move (memcpy) operation.  Use i386 string operations
20558    when profitable.  expand_setmem contains similar code.  The code
20559    depends upon architecture, block size and alignment, but always has
20560    the same overall structure:
20561
20562    1) Prologue guard: Conditional that jumps up to epilogues for small
20563       blocks that can be handled by epilogue alone.  This is faster
20564       but also needed for correctness, since prologue assume the block
20565       is larger than the desired alignment.
20566
20567       Optional dynamic check for size and libcall for large
20568       blocks is emitted here too, with -minline-stringops-dynamically.
20569
20570    2) Prologue: copy first few bytes in order to get destination
20571       aligned to DESIRED_ALIGN.  It is emitted only when ALIGN is less
20572       than DESIRED_ALIGN and up to DESIRED_ALIGN - ALIGN bytes can be
20573       copied.  We emit either a jump tree on power of two sized
20574       blocks, or a byte loop.
20575
20576    3) Main body: the copying loop itself, copying in SIZE_NEEDED chunks
20577       with specified algorithm.
20578
20579    4) Epilogue: code copying tail of the block that is too small to be
20580       handled by main body (or up to size guarded by prologue guard).  */
20581
20582 bool
20583 ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
20584                     rtx expected_align_exp, rtx expected_size_exp)
20585 {
20586   rtx destreg;
20587   rtx srcreg;
20588   rtx label = NULL;
20589   rtx tmp;
20590   rtx jump_around_label = NULL;
20591   HOST_WIDE_INT align = 1;
20592   unsigned HOST_WIDE_INT count = 0;
20593   HOST_WIDE_INT expected_size = -1;
20594   int size_needed = 0, epilogue_size_needed;
20595   int desired_align = 0, align_bytes = 0;
20596   enum stringop_alg alg;
20597   int dynamic_check;
20598   bool need_zero_guard = false;
20599
20600   if (CONST_INT_P (align_exp))
20601     align = INTVAL (align_exp);
20602   /* i386 can do misaligned access on reasonably increased cost.  */
20603   if (CONST_INT_P (expected_align_exp)
20604       && INTVAL (expected_align_exp) > align)
20605     align = INTVAL (expected_align_exp);
20606   /* ALIGN is the minimum of destination and source alignment, but we care here
20607      just about destination alignment.  */
20608   else if (MEM_ALIGN (dst) > (unsigned HOST_WIDE_INT) align * BITS_PER_UNIT)
20609     align = MEM_ALIGN (dst) / BITS_PER_UNIT;
20610
20611   if (CONST_INT_P (count_exp))
20612     count = expected_size = INTVAL (count_exp);
20613   if (CONST_INT_P (expected_size_exp) && count == 0)
20614     expected_size = INTVAL (expected_size_exp);
20615
20616   /* Make sure we don't need to care about overflow later on.  */
20617   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
20618     return false;
20619
20620   /* Step 0: Decide on preferred algorithm, desired alignment and
20621      size of chunks to be copied by main loop.  */
20622
20623   alg = decide_alg (count, expected_size, false, &dynamic_check);
20624   desired_align = decide_alignment (align, alg, expected_size);
20625
20626   if (!TARGET_ALIGN_STRINGOPS)
20627     align = desired_align;
20628
20629   if (alg == libcall)
20630     return false;
20631   gcc_assert (alg != no_stringop);
20632   if (!count)
20633     count_exp = copy_to_mode_reg (GET_MODE (count_exp), count_exp);
20634   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
20635   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
20636   switch (alg)
20637     {
20638     case libcall:
20639     case no_stringop:
20640       gcc_unreachable ();
20641     case loop:
20642       need_zero_guard = true;
20643       size_needed = GET_MODE_SIZE (Pmode);
20644       break;
20645     case unrolled_loop:
20646       need_zero_guard = true;
20647       size_needed = GET_MODE_SIZE (Pmode) * (TARGET_64BIT ? 4 : 2);
20648       break;
20649     case rep_prefix_8_byte:
20650       size_needed = 8;
20651       break;
20652     case rep_prefix_4_byte:
20653       size_needed = 4;
20654       break;
20655     case rep_prefix_1_byte:
20656       size_needed = 1;
20657       break;
20658     case loop_1_byte:
20659       need_zero_guard = true;
20660       size_needed = 1;
20661       break;
20662     }
20663
20664   epilogue_size_needed = size_needed;
20665
20666   /* Step 1: Prologue guard.  */
20667
20668   /* Alignment code needs count to be in register.  */
20669   if (CONST_INT_P (count_exp) && desired_align > align)
20670     {
20671       if (INTVAL (count_exp) > desired_align
20672           && INTVAL (count_exp) > size_needed)
20673         {
20674           align_bytes
20675             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
20676           if (align_bytes <= 0)
20677             align_bytes = 0;
20678           else
20679             align_bytes = desired_align - align_bytes;
20680         }
20681       if (align_bytes == 0)
20682         count_exp = force_reg (counter_mode (count_exp), count_exp);
20683     }
20684   gcc_assert (desired_align >= 1 && align >= 1);
20685
20686   /* Ensure that alignment prologue won't copy past end of block.  */
20687   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
20688     {
20689       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
20690       /* Epilogue always copies COUNT_EXP & EPILOGUE_SIZE_NEEDED bytes.
20691          Make sure it is power of 2.  */
20692       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
20693
20694       if (count)
20695         {
20696           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
20697             {
20698               /* If main algorithm works on QImode, no epilogue is needed.
20699                  For small sizes just don't align anything.  */
20700               if (size_needed == 1)
20701                 desired_align = align;
20702               else
20703                 goto epilogue;
20704             }
20705         }
20706       else
20707         {
20708           label = gen_label_rtx ();
20709           emit_cmp_and_jump_insns (count_exp,
20710                                    GEN_INT (epilogue_size_needed),
20711                                    LTU, 0, counter_mode (count_exp), 1, label);
20712           if (expected_size == -1 || expected_size < epilogue_size_needed)
20713             predict_jump (REG_BR_PROB_BASE * 60 / 100);
20714           else
20715             predict_jump (REG_BR_PROB_BASE * 20 / 100);
20716         }
20717     }
20718
20719   /* Emit code to decide on runtime whether library call or inline should be
20720      used.  */
20721   if (dynamic_check != -1)
20722     {
20723       if (CONST_INT_P (count_exp))
20724         {
20725           if (UINTVAL (count_exp) >= (unsigned HOST_WIDE_INT)dynamic_check)
20726             {
20727               emit_block_move_via_libcall (dst, src, count_exp, false);
20728               count_exp = const0_rtx;
20729               goto epilogue;
20730             }
20731         }
20732       else
20733         {
20734           rtx hot_label = gen_label_rtx ();
20735           jump_around_label = gen_label_rtx ();
20736           emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
20737                                    LEU, 0, GET_MODE (count_exp), 1, hot_label);
20738           predict_jump (REG_BR_PROB_BASE * 90 / 100);
20739           emit_block_move_via_libcall (dst, src, count_exp, false);
20740           emit_jump (jump_around_label);
20741           emit_label (hot_label);
20742         }
20743     }
20744
20745   /* Step 2: Alignment prologue.  */
20746
20747   if (desired_align > align)
20748     {
20749       if (align_bytes == 0)
20750         {
20751           /* Except for the first move in epilogue, we no longer know
20752              constant offset in aliasing info.  It don't seems to worth
20753              the pain to maintain it for the first move, so throw away
20754              the info early.  */
20755           src = change_address (src, BLKmode, srcreg);
20756           dst = change_address (dst, BLKmode, destreg);
20757           expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align,
20758                                   desired_align);
20759         }
20760       else
20761         {
20762           /* If we know how many bytes need to be stored before dst is
20763              sufficiently aligned, maintain aliasing info accurately.  */
20764           dst = expand_constant_movmem_prologue (dst, &src, destreg, srcreg,
20765                                                  desired_align, align_bytes);
20766           count_exp = plus_constant (count_exp, -align_bytes);
20767           count -= align_bytes;
20768         }
20769       if (need_zero_guard
20770           && (count < (unsigned HOST_WIDE_INT) size_needed
20771               || (align_bytes == 0
20772                   && count < ((unsigned HOST_WIDE_INT) size_needed
20773                               + desired_align - align))))
20774         {
20775           /* It is possible that we copied enough so the main loop will not
20776              execute.  */
20777           gcc_assert (size_needed > 1);
20778           if (label == NULL_RTX)
20779             label = gen_label_rtx ();
20780           emit_cmp_and_jump_insns (count_exp,
20781                                    GEN_INT (size_needed),
20782                                    LTU, 0, counter_mode (count_exp), 1, label);
20783           if (expected_size == -1
20784               || expected_size < (desired_align - align) / 2 + size_needed)
20785             predict_jump (REG_BR_PROB_BASE * 20 / 100);
20786           else
20787             predict_jump (REG_BR_PROB_BASE * 60 / 100);
20788         }
20789     }
20790   if (label && size_needed == 1)
20791     {
20792       emit_label (label);
20793       LABEL_NUSES (label) = 1;
20794       label = NULL;
20795       epilogue_size_needed = 1;
20796     }
20797   else if (label == NULL_RTX)
20798     epilogue_size_needed = size_needed;
20799
20800   /* Step 3: Main loop.  */
20801
20802   switch (alg)
20803     {
20804     case libcall:
20805     case no_stringop:
20806       gcc_unreachable ();
20807     case loop_1_byte:
20808       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20809                                      count_exp, QImode, 1, expected_size);
20810       break;
20811     case loop:
20812       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20813                                      count_exp, Pmode, 1, expected_size);
20814       break;
20815     case unrolled_loop:
20816       /* Unroll only by factor of 2 in 32bit mode, since we don't have enough
20817          registers for 4 temporaries anyway.  */
20818       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
20819                                      count_exp, Pmode, TARGET_64BIT ? 4 : 2,
20820                                      expected_size);
20821       break;
20822     case rep_prefix_8_byte:
20823       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20824                                  DImode);
20825       break;
20826     case rep_prefix_4_byte:
20827       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20828                                  SImode);
20829       break;
20830     case rep_prefix_1_byte:
20831       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
20832                                  QImode);
20833       break;
20834     }
20835   /* Adjust properly the offset of src and dest memory for aliasing.  */
20836   if (CONST_INT_P (count_exp))
20837     {
20838       src = adjust_automodify_address_nv (src, BLKmode, srcreg,
20839                                           (count / size_needed) * size_needed);
20840       dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
20841                                           (count / size_needed) * size_needed);
20842     }
20843   else
20844     {
20845       src = change_address (src, BLKmode, srcreg);
20846       dst = change_address (dst, BLKmode, destreg);
20847     }
20848
20849   /* Step 4: Epilogue to copy the remaining bytes.  */
20850  epilogue:
20851   if (label)
20852     {
20853       /* When the main loop is done, COUNT_EXP might hold original count,
20854          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
20855          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
20856          bytes. Compensate if needed.  */
20857
20858       if (size_needed < epilogue_size_needed)
20859         {
20860           tmp =
20861             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
20862                                  GEN_INT (size_needed - 1), count_exp, 1,
20863                                  OPTAB_DIRECT);
20864           if (tmp != count_exp)
20865             emit_move_insn (count_exp, tmp);
20866         }
20867       emit_label (label);
20868       LABEL_NUSES (label) = 1;
20869     }
20870
20871   if (count_exp != const0_rtx && epilogue_size_needed > 1)
20872     expand_movmem_epilogue (dst, src, destreg, srcreg, count_exp,
20873                             epilogue_size_needed);
20874   if (jump_around_label)
20875     emit_label (jump_around_label);
20876   return true;
20877 }
20878
20879 /* Helper function for memcpy.  For QImode value 0xXY produce
20880    0xXYXYXYXY of wide specified by MODE.  This is essentially
20881    a * 0x10101010, but we can do slightly better than
20882    synth_mult by unwinding the sequence by hand on CPUs with
20883    slow multiply.  */
20884 static rtx
20885 promote_duplicated_reg (enum machine_mode mode, rtx val)
20886 {
20887   enum machine_mode valmode = GET_MODE (val);
20888   rtx tmp;
20889   int nops = mode == DImode ? 3 : 2;
20890
20891   gcc_assert (mode == SImode || mode == DImode);
20892   if (val == const0_rtx)
20893     return copy_to_mode_reg (mode, const0_rtx);
20894   if (CONST_INT_P (val))
20895     {
20896       HOST_WIDE_INT v = INTVAL (val) & 255;
20897
20898       v |= v << 8;
20899       v |= v << 16;
20900       if (mode == DImode)
20901         v |= (v << 16) << 16;
20902       return copy_to_mode_reg (mode, gen_int_mode (v, mode));
20903     }
20904
20905   if (valmode == VOIDmode)
20906     valmode = QImode;
20907   if (valmode != QImode)
20908     val = gen_lowpart (QImode, val);
20909   if (mode == QImode)
20910     return val;
20911   if (!TARGET_PARTIAL_REG_STALL)
20912     nops--;
20913   if (ix86_cost->mult_init[mode == DImode ? 3 : 2]
20914       + ix86_cost->mult_bit * (mode == DImode ? 8 : 4)
20915       <= (ix86_cost->shift_const + ix86_cost->add) * nops
20916           + (COSTS_N_INSNS (TARGET_PARTIAL_REG_STALL == 0)))
20917     {
20918       rtx reg = convert_modes (mode, QImode, val, true);
20919       tmp = promote_duplicated_reg (mode, const1_rtx);
20920       return expand_simple_binop (mode, MULT, reg, tmp, NULL, 1,
20921                                   OPTAB_DIRECT);
20922     }
20923   else
20924     {
20925       rtx reg = convert_modes (mode, QImode, val, true);
20926
20927       if (!TARGET_PARTIAL_REG_STALL)
20928         if (mode == SImode)
20929           emit_insn (gen_movsi_insv_1 (reg, reg));
20930         else
20931           emit_insn (gen_movdi_insv_1 (reg, reg));
20932       else
20933         {
20934           tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (8),
20935                                      NULL, 1, OPTAB_DIRECT);
20936           reg =
20937             expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20938         }
20939       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (16),
20940                                  NULL, 1, OPTAB_DIRECT);
20941       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20942       if (mode == SImode)
20943         return reg;
20944       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (32),
20945                                  NULL, 1, OPTAB_DIRECT);
20946       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
20947       return reg;
20948     }
20949 }
20950
20951 /* Duplicate value VAL using promote_duplicated_reg into maximal size that will
20952    be needed by main loop copying SIZE_NEEDED chunks and prologue getting
20953    alignment from ALIGN to DESIRED_ALIGN.  */
20954 static rtx
20955 promote_duplicated_reg_to_size (rtx val, int size_needed, int desired_align, int align)
20956 {
20957   rtx promoted_val;
20958
20959   if (TARGET_64BIT
20960       && (size_needed > 4 || (desired_align > align && desired_align > 4)))
20961     promoted_val = promote_duplicated_reg (DImode, val);
20962   else if (size_needed > 2 || (desired_align > align && desired_align > 2))
20963     promoted_val = promote_duplicated_reg (SImode, val);
20964   else if (size_needed > 1 || (desired_align > align && desired_align > 1))
20965     promoted_val = promote_duplicated_reg (HImode, val);
20966   else
20967     promoted_val = val;
20968
20969   return promoted_val;
20970 }
20971
20972 /* Expand string clear operation (bzero).  Use i386 string operations when
20973    profitable.  See expand_movmem comment for explanation of individual
20974    steps performed.  */
20975 bool
20976 ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp,
20977                     rtx expected_align_exp, rtx expected_size_exp)
20978 {
20979   rtx destreg;
20980   rtx label = NULL;
20981   rtx tmp;
20982   rtx jump_around_label = NULL;
20983   HOST_WIDE_INT align = 1;
20984   unsigned HOST_WIDE_INT count = 0;
20985   HOST_WIDE_INT expected_size = -1;
20986   int size_needed = 0, epilogue_size_needed;
20987   int desired_align = 0, align_bytes = 0;
20988   enum stringop_alg alg;
20989   rtx promoted_val = NULL;
20990   bool force_loopy_epilogue = false;
20991   int dynamic_check;
20992   bool need_zero_guard = false;
20993
20994   if (CONST_INT_P (align_exp))
20995     align = INTVAL (align_exp);
20996   /* i386 can do misaligned access on reasonably increased cost.  */
20997   if (CONST_INT_P (expected_align_exp)
20998       && INTVAL (expected_align_exp) > align)
20999     align = INTVAL (expected_align_exp);
21000   if (CONST_INT_P (count_exp))
21001     count = expected_size = INTVAL (count_exp);
21002   if (CONST_INT_P (expected_size_exp) && count == 0)
21003     expected_size = INTVAL (expected_size_exp);
21004
21005   /* Make sure we don't need to care about overflow later on.  */
21006   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
21007     return false;
21008
21009   /* Step 0: Decide on preferred algorithm, desired alignment and
21010      size of chunks to be copied by main loop.  */
21011
21012   alg = decide_alg (count, expected_size, true, &dynamic_check);
21013   desired_align = decide_alignment (align, alg, expected_size);
21014
21015   if (!TARGET_ALIGN_STRINGOPS)
21016     align = desired_align;
21017
21018   if (alg == libcall)
21019     return false;
21020   gcc_assert (alg != no_stringop);
21021   if (!count)
21022     count_exp = copy_to_mode_reg (counter_mode (count_exp), count_exp);
21023   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
21024   switch (alg)
21025     {
21026     case libcall:
21027     case no_stringop:
21028       gcc_unreachable ();
21029     case loop:
21030       need_zero_guard = true;
21031       size_needed = GET_MODE_SIZE (Pmode);
21032       break;
21033     case unrolled_loop:
21034       need_zero_guard = true;
21035       size_needed = GET_MODE_SIZE (Pmode) * 4;
21036       break;
21037     case rep_prefix_8_byte:
21038       size_needed = 8;
21039       break;
21040     case rep_prefix_4_byte:
21041       size_needed = 4;
21042       break;
21043     case rep_prefix_1_byte:
21044       size_needed = 1;
21045       break;
21046     case loop_1_byte:
21047       need_zero_guard = true;
21048       size_needed = 1;
21049       break;
21050     }
21051   epilogue_size_needed = size_needed;
21052
21053   /* Step 1: Prologue guard.  */
21054
21055   /* Alignment code needs count to be in register.  */
21056   if (CONST_INT_P (count_exp) && desired_align > align)
21057     {
21058       if (INTVAL (count_exp) > desired_align
21059           && INTVAL (count_exp) > size_needed)
21060         {
21061           align_bytes
21062             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
21063           if (align_bytes <= 0)
21064             align_bytes = 0;
21065           else
21066             align_bytes = desired_align - align_bytes;
21067         }
21068       if (align_bytes == 0)
21069         {
21070           enum machine_mode mode = SImode;
21071           if (TARGET_64BIT && (count & ~0xffffffff))
21072             mode = DImode;
21073           count_exp = force_reg (mode, count_exp);
21074         }
21075     }
21076   /* Do the cheap promotion to allow better CSE across the
21077      main loop and epilogue (ie one load of the big constant in the
21078      front of all code.  */
21079   if (CONST_INT_P (val_exp))
21080     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
21081                                                    desired_align, align);
21082   /* Ensure that alignment prologue won't copy past end of block.  */
21083   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
21084     {
21085       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
21086       /* Epilogue always copies COUNT_EXP & (EPILOGUE_SIZE_NEEDED - 1) bytes.
21087          Make sure it is power of 2.  */
21088       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
21089
21090       /* To improve performance of small blocks, we jump around the VAL
21091          promoting mode.  This mean that if the promoted VAL is not constant,
21092          we might not use it in the epilogue and have to use byte
21093          loop variant.  */
21094       if (epilogue_size_needed > 2 && !promoted_val)
21095         force_loopy_epilogue = true;
21096       if (count)
21097         {
21098           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
21099             {
21100               /* If main algorithm works on QImode, no epilogue is needed.
21101                  For small sizes just don't align anything.  */
21102               if (size_needed == 1)
21103                 desired_align = align;
21104               else
21105                 goto epilogue;
21106             }
21107         }
21108       else
21109         {
21110           label = gen_label_rtx ();
21111           emit_cmp_and_jump_insns (count_exp,
21112                                    GEN_INT (epilogue_size_needed),
21113                                    LTU, 0, counter_mode (count_exp), 1, label);
21114           if (expected_size == -1 || expected_size <= epilogue_size_needed)
21115             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21116           else
21117             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21118         }
21119     }
21120   if (dynamic_check != -1)
21121     {
21122       rtx hot_label = gen_label_rtx ();
21123       jump_around_label = gen_label_rtx ();
21124       emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
21125                                LEU, 0, counter_mode (count_exp), 1, hot_label);
21126       predict_jump (REG_BR_PROB_BASE * 90 / 100);
21127       set_storage_via_libcall (dst, count_exp, val_exp, false);
21128       emit_jump (jump_around_label);
21129       emit_label (hot_label);
21130     }
21131
21132   /* Step 2: Alignment prologue.  */
21133
21134   /* Do the expensive promotion once we branched off the small blocks.  */
21135   if (!promoted_val)
21136     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
21137                                                    desired_align, align);
21138   gcc_assert (desired_align >= 1 && align >= 1);
21139
21140   if (desired_align > align)
21141     {
21142       if (align_bytes == 0)
21143         {
21144           /* Except for the first move in epilogue, we no longer know
21145              constant offset in aliasing info.  It don't seems to worth
21146              the pain to maintain it for the first move, so throw away
21147              the info early.  */
21148           dst = change_address (dst, BLKmode, destreg);
21149           expand_setmem_prologue (dst, destreg, promoted_val, count_exp, align,
21150                                   desired_align);
21151         }
21152       else
21153         {
21154           /* If we know how many bytes need to be stored before dst is
21155              sufficiently aligned, maintain aliasing info accurately.  */
21156           dst = expand_constant_setmem_prologue (dst, destreg, promoted_val,
21157                                                  desired_align, align_bytes);
21158           count_exp = plus_constant (count_exp, -align_bytes);
21159           count -= align_bytes;
21160         }
21161       if (need_zero_guard
21162           && (count < (unsigned HOST_WIDE_INT) size_needed
21163               || (align_bytes == 0
21164                   && count < ((unsigned HOST_WIDE_INT) size_needed
21165                               + desired_align - align))))
21166         {
21167           /* It is possible that we copied enough so the main loop will not
21168              execute.  */
21169           gcc_assert (size_needed > 1);
21170           if (label == NULL_RTX)
21171             label = gen_label_rtx ();
21172           emit_cmp_and_jump_insns (count_exp,
21173                                    GEN_INT (size_needed),
21174                                    LTU, 0, counter_mode (count_exp), 1, label);
21175           if (expected_size == -1
21176               || expected_size < (desired_align - align) / 2 + size_needed)
21177             predict_jump (REG_BR_PROB_BASE * 20 / 100);
21178           else
21179             predict_jump (REG_BR_PROB_BASE * 60 / 100);
21180         }
21181     }
21182   if (label && size_needed == 1)
21183     {
21184       emit_label (label);
21185       LABEL_NUSES (label) = 1;
21186       label = NULL;
21187       promoted_val = val_exp;
21188       epilogue_size_needed = 1;
21189     }
21190   else if (label == NULL_RTX)
21191     epilogue_size_needed = size_needed;
21192
21193   /* Step 3: Main loop.  */
21194
21195   switch (alg)
21196     {
21197     case libcall:
21198     case no_stringop:
21199       gcc_unreachable ();
21200     case loop_1_byte:
21201       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21202                                      count_exp, QImode, 1, expected_size);
21203       break;
21204     case loop:
21205       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21206                                      count_exp, Pmode, 1, expected_size);
21207       break;
21208     case unrolled_loop:
21209       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
21210                                      count_exp, Pmode, 4, expected_size);
21211       break;
21212     case rep_prefix_8_byte:
21213       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21214                                   DImode, val_exp);
21215       break;
21216     case rep_prefix_4_byte:
21217       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21218                                   SImode, val_exp);
21219       break;
21220     case rep_prefix_1_byte:
21221       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
21222                                   QImode, val_exp);
21223       break;
21224     }
21225   /* Adjust properly the offset of src and dest memory for aliasing.  */
21226   if (CONST_INT_P (count_exp))
21227     dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
21228                                         (count / size_needed) * size_needed);
21229   else
21230     dst = change_address (dst, BLKmode, destreg);
21231
21232   /* Step 4: Epilogue to copy the remaining bytes.  */
21233
21234   if (label)
21235     {
21236       /* When the main loop is done, COUNT_EXP might hold original count,
21237          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
21238          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
21239          bytes. Compensate if needed.  */
21240
21241       if (size_needed < epilogue_size_needed)
21242         {
21243           tmp =
21244             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
21245                                  GEN_INT (size_needed - 1), count_exp, 1,
21246                                  OPTAB_DIRECT);
21247           if (tmp != count_exp)
21248             emit_move_insn (count_exp, tmp);
21249         }
21250       emit_label (label);
21251       LABEL_NUSES (label) = 1;
21252     }
21253  epilogue:
21254   if (count_exp != const0_rtx && epilogue_size_needed > 1)
21255     {
21256       if (force_loopy_epilogue)
21257         expand_setmem_epilogue_via_loop (dst, destreg, val_exp, count_exp,
21258                                          epilogue_size_needed);
21259       else
21260         expand_setmem_epilogue (dst, destreg, promoted_val, count_exp,
21261                                 epilogue_size_needed);
21262     }
21263   if (jump_around_label)
21264     emit_label (jump_around_label);
21265   return true;
21266 }
21267
21268 /* Expand the appropriate insns for doing strlen if not just doing
21269    repnz; scasb
21270
21271    out = result, initialized with the start address
21272    align_rtx = alignment of the address.
21273    scratch = scratch register, initialized with the startaddress when
21274         not aligned, otherwise undefined
21275
21276    This is just the body. It needs the initializations mentioned above and
21277    some address computing at the end.  These things are done in i386.md.  */
21278
21279 static void
21280 ix86_expand_strlensi_unroll_1 (rtx out, rtx src, rtx align_rtx)
21281 {
21282   int align;
21283   rtx tmp;
21284   rtx align_2_label = NULL_RTX;
21285   rtx align_3_label = NULL_RTX;
21286   rtx align_4_label = gen_label_rtx ();
21287   rtx end_0_label = gen_label_rtx ();
21288   rtx mem;
21289   rtx tmpreg = gen_reg_rtx (SImode);
21290   rtx scratch = gen_reg_rtx (SImode);
21291   rtx cmp;
21292
21293   align = 0;
21294   if (CONST_INT_P (align_rtx))
21295     align = INTVAL (align_rtx);
21296
21297   /* Loop to check 1..3 bytes for null to get an aligned pointer.  */
21298
21299   /* Is there a known alignment and is it less than 4?  */
21300   if (align < 4)
21301     {
21302       rtx scratch1 = gen_reg_rtx (Pmode);
21303       emit_move_insn (scratch1, out);
21304       /* Is there a known alignment and is it not 2? */
21305       if (align != 2)
21306         {
21307           align_3_label = gen_label_rtx (); /* Label when aligned to 3-byte */
21308           align_2_label = gen_label_rtx (); /* Label when aligned to 2-byte */
21309
21310           /* Leave just the 3 lower bits.  */
21311           align_rtx = expand_binop (Pmode, and_optab, scratch1, GEN_INT (3),
21312                                     NULL_RTX, 0, OPTAB_WIDEN);
21313
21314           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
21315                                    Pmode, 1, align_4_label);
21316           emit_cmp_and_jump_insns (align_rtx, const2_rtx, EQ, NULL,
21317                                    Pmode, 1, align_2_label);
21318           emit_cmp_and_jump_insns (align_rtx, const2_rtx, GTU, NULL,
21319                                    Pmode, 1, align_3_label);
21320         }
21321       else
21322         {
21323           /* Since the alignment is 2, we have to check 2 or 0 bytes;
21324              check if is aligned to 4 - byte.  */
21325
21326           align_rtx = expand_binop (Pmode, and_optab, scratch1, const2_rtx,
21327                                     NULL_RTX, 0, OPTAB_WIDEN);
21328
21329           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
21330                                    Pmode, 1, align_4_label);
21331         }
21332
21333       mem = change_address (src, QImode, out);
21334
21335       /* Now compare the bytes.  */
21336
21337       /* Compare the first n unaligned byte on a byte per byte basis.  */
21338       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL,
21339                                QImode, 1, end_0_label);
21340
21341       /* Increment the address.  */
21342       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21343
21344       /* Not needed with an alignment of 2 */
21345       if (align != 2)
21346         {
21347           emit_label (align_2_label);
21348
21349           emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
21350                                    end_0_label);
21351
21352           emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21353
21354           emit_label (align_3_label);
21355         }
21356
21357       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
21358                                end_0_label);
21359
21360       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
21361     }
21362
21363   /* Generate loop to check 4 bytes at a time.  It is not a good idea to
21364      align this loop.  It gives only huge programs, but does not help to
21365      speed up.  */
21366   emit_label (align_4_label);
21367
21368   mem = change_address (src, SImode, out);
21369   emit_move_insn (scratch, mem);
21370   emit_insn (ix86_gen_add3 (out, out, GEN_INT (4)));
21371
21372   /* This formula yields a nonzero result iff one of the bytes is zero.
21373      This saves three branches inside loop and many cycles.  */
21374
21375   emit_insn (gen_addsi3 (tmpreg, scratch, GEN_INT (-0x01010101)));
21376   emit_insn (gen_one_cmplsi2 (scratch, scratch));
21377   emit_insn (gen_andsi3 (tmpreg, tmpreg, scratch));
21378   emit_insn (gen_andsi3 (tmpreg, tmpreg,
21379                          gen_int_mode (0x80808080, SImode)));
21380   emit_cmp_and_jump_insns (tmpreg, const0_rtx, EQ, 0, SImode, 1,
21381                            align_4_label);
21382
21383   if (TARGET_CMOVE)
21384     {
21385        rtx reg = gen_reg_rtx (SImode);
21386        rtx reg2 = gen_reg_rtx (Pmode);
21387        emit_move_insn (reg, tmpreg);
21388        emit_insn (gen_lshrsi3 (reg, reg, GEN_INT (16)));
21389
21390        /* If zero is not in the first two bytes, move two bytes forward.  */
21391        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
21392        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21393        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
21394        emit_insn (gen_rtx_SET (VOIDmode, tmpreg,
21395                                gen_rtx_IF_THEN_ELSE (SImode, tmp,
21396                                                      reg,
21397                                                      tmpreg)));
21398        /* Emit lea manually to avoid clobbering of flags.  */
21399        emit_insn (gen_rtx_SET (SImode, reg2,
21400                                gen_rtx_PLUS (Pmode, out, const2_rtx)));
21401
21402        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21403        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
21404        emit_insn (gen_rtx_SET (VOIDmode, out,
21405                                gen_rtx_IF_THEN_ELSE (Pmode, tmp,
21406                                                      reg2,
21407                                                      out)));
21408     }
21409   else
21410     {
21411        rtx end_2_label = gen_label_rtx ();
21412        /* Is zero in the first two bytes? */
21413
21414        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
21415        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
21416        tmp = gen_rtx_NE (VOIDmode, tmp, const0_rtx);
21417        tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
21418                             gen_rtx_LABEL_REF (VOIDmode, end_2_label),
21419                             pc_rtx);
21420        tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
21421        JUMP_LABEL (tmp) = end_2_label;
21422
21423        /* Not in the first two.  Move two bytes forward.  */
21424        emit_insn (gen_lshrsi3 (tmpreg, tmpreg, GEN_INT (16)));
21425        emit_insn (ix86_gen_add3 (out, out, const2_rtx));
21426
21427        emit_label (end_2_label);
21428
21429     }
21430
21431   /* Avoid branch in fixing the byte.  */
21432   tmpreg = gen_lowpart (QImode, tmpreg);
21433   emit_insn (gen_addqi3_cc (tmpreg, tmpreg, tmpreg));
21434   tmp = gen_rtx_REG (CCmode, FLAGS_REG);
21435   cmp = gen_rtx_LTU (VOIDmode, tmp, const0_rtx);
21436   emit_insn (ix86_gen_sub3_carry (out, out, GEN_INT (3), tmp, cmp));
21437
21438   emit_label (end_0_label);
21439 }
21440
21441 /* Expand strlen.  */
21442
21443 bool
21444 ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align)
21445 {
21446   rtx addr, scratch1, scratch2, scratch3, scratch4;
21447
21448   /* The generic case of strlen expander is long.  Avoid it's
21449      expanding unless TARGET_INLINE_ALL_STRINGOPS.  */
21450
21451   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
21452       && !TARGET_INLINE_ALL_STRINGOPS
21453       && !optimize_insn_for_size_p ()
21454       && (!CONST_INT_P (align) || INTVAL (align) < 4))
21455     return false;
21456
21457   addr = force_reg (Pmode, XEXP (src, 0));
21458   scratch1 = gen_reg_rtx (Pmode);
21459
21460   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
21461       && !optimize_insn_for_size_p ())
21462     {
21463       /* Well it seems that some optimizer does not combine a call like
21464          foo(strlen(bar), strlen(bar));
21465          when the move and the subtraction is done here.  It does calculate
21466          the length just once when these instructions are done inside of
21467          output_strlen_unroll().  But I think since &bar[strlen(bar)] is
21468          often used and I use one fewer register for the lifetime of
21469          output_strlen_unroll() this is better.  */
21470
21471       emit_move_insn (out, addr);
21472
21473       ix86_expand_strlensi_unroll_1 (out, src, align);
21474
21475       /* strlensi_unroll_1 returns the address of the zero at the end of
21476          the string, like memchr(), so compute the length by subtracting
21477          the start address.  */
21478       emit_insn (ix86_gen_sub3 (out, out, addr));
21479     }
21480   else
21481     {
21482       rtx unspec;
21483
21484       /* Can't use this if the user has appropriated eax, ecx, or edi.  */
21485       if (fixed_regs[AX_REG] || fixed_regs[CX_REG] || fixed_regs[DI_REG])
21486         return false;
21487
21488       scratch2 = gen_reg_rtx (Pmode);
21489       scratch3 = gen_reg_rtx (Pmode);
21490       scratch4 = force_reg (Pmode, constm1_rtx);
21491
21492       emit_move_insn (scratch3, addr);
21493       eoschar = force_reg (QImode, eoschar);
21494
21495       src = replace_equiv_address_nv (src, scratch3);
21496
21497       /* If .md starts supporting :P, this can be done in .md.  */
21498       unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (4, src, eoschar, align,
21499                                                  scratch4), UNSPEC_SCAS);
21500       emit_insn (gen_strlenqi_1 (scratch1, scratch3, unspec));
21501       emit_insn (ix86_gen_one_cmpl2 (scratch2, scratch1));
21502       emit_insn (ix86_gen_add3 (out, scratch2, constm1_rtx));
21503     }
21504   return true;
21505 }
21506
21507 /* For given symbol (function) construct code to compute address of it's PLT
21508    entry in large x86-64 PIC model.  */
21509 rtx
21510 construct_plt_address (rtx symbol)
21511 {
21512   rtx tmp = gen_reg_rtx (Pmode);
21513   rtx unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, symbol), UNSPEC_PLTOFF);
21514
21515   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
21516   gcc_assert (ix86_cmodel == CM_LARGE_PIC);
21517
21518   emit_move_insn (tmp, gen_rtx_CONST (Pmode, unspec));
21519   emit_insn (gen_adddi3 (tmp, tmp, pic_offset_table_rtx));
21520   return tmp;
21521 }
21522
21523 rtx
21524 ix86_expand_call (rtx retval, rtx fnaddr, rtx callarg1,
21525                   rtx callarg2,
21526                   rtx pop, bool sibcall)
21527 {
21528   /* We need to represent that SI and DI registers are clobbered
21529      by SYSV calls.  */
21530   static int clobbered_registers[] = {
21531         XMM6_REG, XMM7_REG, XMM8_REG,
21532         XMM9_REG, XMM10_REG, XMM11_REG,
21533         XMM12_REG, XMM13_REG, XMM14_REG,
21534         XMM15_REG, SI_REG, DI_REG
21535   };
21536   rtx vec[ARRAY_SIZE (clobbered_registers) + 3];
21537   rtx use = NULL, call;
21538   unsigned int vec_len;
21539
21540   if (pop == const0_rtx)
21541     pop = NULL;
21542   gcc_assert (!TARGET_64BIT || !pop);
21543
21544   if (TARGET_MACHO && !TARGET_64BIT)
21545     {
21546 #if TARGET_MACHO
21547       if (flag_pic && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF)
21548         fnaddr = machopic_indirect_call_target (fnaddr);
21549 #endif
21550     }
21551   else
21552     {
21553       /* Static functions and indirect calls don't need the pic register.  */
21554       if (flag_pic && (!TARGET_64BIT || ix86_cmodel == CM_LARGE_PIC)
21555           && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
21556           && ! SYMBOL_REF_LOCAL_P (XEXP (fnaddr, 0)))
21557         use_reg (&use, pic_offset_table_rtx);
21558     }
21559
21560   if (TARGET_64BIT && INTVAL (callarg2) >= 0)
21561     {
21562       rtx al = gen_rtx_REG (QImode, AX_REG);
21563       emit_move_insn (al, callarg2);
21564       use_reg (&use, al);
21565     }
21566
21567   if (ix86_cmodel == CM_LARGE_PIC
21568       && MEM_P (fnaddr)
21569       && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
21570       && !local_symbolic_operand (XEXP (fnaddr, 0), VOIDmode))
21571     fnaddr = gen_rtx_MEM (QImode, construct_plt_address (XEXP (fnaddr, 0)));
21572   else if (sibcall
21573            ? !sibcall_insn_operand (XEXP (fnaddr, 0), Pmode)
21574            : !call_insn_operand (XEXP (fnaddr, 0), Pmode))
21575     {
21576       fnaddr = XEXP (fnaddr, 0);
21577       if (GET_MODE (fnaddr) != Pmode)
21578         fnaddr = convert_to_mode (Pmode, fnaddr, 1);
21579       fnaddr = gen_rtx_MEM (QImode, copy_to_mode_reg (Pmode, fnaddr));
21580     }
21581
21582   vec_len = 0;
21583   call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
21584   if (retval)
21585     call = gen_rtx_SET (VOIDmode, retval, call);
21586   vec[vec_len++] = call;
21587
21588   if (pop)
21589     {
21590       pop = gen_rtx_PLUS (Pmode, stack_pointer_rtx, pop);
21591       pop = gen_rtx_SET (VOIDmode, stack_pointer_rtx, pop);
21592       vec[vec_len++] = pop;
21593     }
21594
21595   if (TARGET_64BIT_MS_ABI
21596       && (!callarg2 || INTVAL (callarg2) != -2))
21597     {
21598       unsigned i;
21599
21600       vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx),
21601                                        UNSPEC_MS_TO_SYSV_CALL);
21602
21603       for (i = 0; i < ARRAY_SIZE (clobbered_registers); i++)
21604         vec[vec_len++]
21605           = gen_rtx_CLOBBER (SSE_REGNO_P (clobbered_registers[i])
21606                              ? TImode : DImode,
21607                              gen_rtx_REG (SSE_REGNO_P (clobbered_registers[i])
21608                                           ? TImode : DImode,
21609                                           clobbered_registers[i]));
21610     }
21611
21612   /* Add UNSPEC_CALL_NEEDS_VZEROUPPER decoration.  */
21613   if (TARGET_VZEROUPPER)
21614     {
21615       int avx256;
21616       if (cfun->machine->callee_pass_avx256_p)
21617         {
21618           if (cfun->machine->callee_return_avx256_p)
21619             avx256 = callee_return_pass_avx256;
21620           else
21621             avx256 = callee_pass_avx256;
21622         }
21623       else if (cfun->machine->callee_return_avx256_p)
21624         avx256 = callee_return_avx256;
21625       else
21626         avx256 = call_no_avx256;
21627
21628       if (reload_completed)
21629         emit_insn (gen_avx_vzeroupper (GEN_INT (avx256)));
21630       else
21631         vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode,
21632                                          gen_rtvec (1, GEN_INT (avx256)),
21633                                          UNSPEC_CALL_NEEDS_VZEROUPPER);
21634     }
21635
21636   if (vec_len > 1)
21637     call = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (vec_len, vec));
21638   call = emit_call_insn (call);
21639   if (use)
21640     CALL_INSN_FUNCTION_USAGE (call) = use;
21641
21642   return call;
21643 }
21644
21645 void
21646 ix86_split_call_vzeroupper (rtx insn, rtx vzeroupper)
21647 {
21648   rtx pat = PATTERN (insn);
21649   rtvec vec = XVEC (pat, 0);
21650   int len = GET_NUM_ELEM (vec) - 1;
21651
21652   /* Strip off the last entry of the parallel.  */
21653   gcc_assert (GET_CODE (RTVEC_ELT (vec, len)) == UNSPEC);
21654   gcc_assert (XINT (RTVEC_ELT (vec, len), 1) == UNSPEC_CALL_NEEDS_VZEROUPPER);
21655   if (len == 1)
21656     pat = RTVEC_ELT (vec, 0);
21657   else
21658     pat = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (len, &RTVEC_ELT (vec, 0)));
21659
21660   emit_insn (gen_avx_vzeroupper (vzeroupper));
21661   emit_call_insn (pat);
21662 }
21663
21664 /* Output the assembly for a call instruction.  */
21665
21666 const char *
21667 ix86_output_call_insn (rtx insn, rtx call_op)
21668 {
21669   bool direct_p = constant_call_address_operand (call_op, Pmode);
21670   bool seh_nop_p = false;
21671   const char *xasm;
21672
21673   if (SIBLING_CALL_P (insn))
21674     {
21675       if (direct_p)
21676         xasm = "jmp\t%P0";
21677       /* SEH epilogue detection requires the indirect branch case
21678          to include REX.W.  */
21679       else if (TARGET_SEH)
21680         xasm = "rex.W jmp %A0";
21681       else
21682         xasm = "jmp\t%A0";
21683
21684       output_asm_insn (xasm, &call_op);
21685       return "";
21686     }
21687
21688   /* SEH unwinding can require an extra nop to be emitted in several
21689      circumstances.  Determine if we have one of those.  */
21690   if (TARGET_SEH)
21691     {
21692       rtx i;
21693
21694       for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
21695         {
21696           /* If we get to another real insn, we don't need the nop.  */
21697           if (INSN_P (i))
21698             break;
21699
21700           /* If we get to the epilogue note, prevent a catch region from
21701              being adjacent to the standard epilogue sequence.  If non-
21702              call-exceptions, we'll have done this during epilogue emission. */
21703           if (NOTE_P (i) && NOTE_KIND (i) == NOTE_INSN_EPILOGUE_BEG
21704               && !flag_non_call_exceptions
21705               && !can_throw_internal (insn))
21706             {
21707               seh_nop_p = true;
21708               break;
21709             }
21710         }
21711
21712       /* If we didn't find a real insn following the call, prevent the
21713          unwinder from looking into the next function.  */
21714       if (i == NULL)
21715         seh_nop_p = true;
21716     }
21717
21718   if (direct_p)
21719     xasm = "call\t%P0";
21720   else
21721     xasm = "call\t%A0";
21722
21723   output_asm_insn (xasm, &call_op);
21724
21725   if (seh_nop_p)
21726     return "nop";
21727
21728   return "";
21729 }
21730 \f
21731 /* Clear stack slot assignments remembered from previous functions.
21732    This is called from INIT_EXPANDERS once before RTL is emitted for each
21733    function.  */
21734
21735 static struct machine_function *
21736 ix86_init_machine_status (void)
21737 {
21738   struct machine_function *f;
21739
21740   f = ggc_alloc_cleared_machine_function ();
21741   f->use_fast_prologue_epilogue_nregs = -1;
21742   f->tls_descriptor_call_expanded_p = 0;
21743   f->call_abi = ix86_abi;
21744
21745   return f;
21746 }
21747
21748 /* Return a MEM corresponding to a stack slot with mode MODE.
21749    Allocate a new slot if necessary.
21750
21751    The RTL for a function can have several slots available: N is
21752    which slot to use.  */
21753
21754 rtx
21755 assign_386_stack_local (enum machine_mode mode, enum ix86_stack_slot n)
21756 {
21757   struct stack_local_entry *s;
21758
21759   gcc_assert (n < MAX_386_STACK_LOCALS);
21760
21761   /* Virtual slot is valid only before vregs are instantiated.  */
21762   gcc_assert ((n == SLOT_VIRTUAL) == !virtuals_instantiated);
21763
21764   for (s = ix86_stack_locals; s; s = s->next)
21765     if (s->mode == mode && s->n == n)
21766       return copy_rtx (s->rtl);
21767
21768   s = ggc_alloc_stack_local_entry ();
21769   s->n = n;
21770   s->mode = mode;
21771   s->rtl = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
21772
21773   s->next = ix86_stack_locals;
21774   ix86_stack_locals = s;
21775   return s->rtl;
21776 }
21777 \f
21778 /* Calculate the length of the memory address in the instruction
21779    encoding.  Does not include the one-byte modrm, opcode, or prefix.  */
21780
21781 int
21782 memory_address_length (rtx addr)
21783 {
21784   struct ix86_address parts;
21785   rtx base, index, disp;
21786   int len;
21787   int ok;
21788
21789   if (GET_CODE (addr) == PRE_DEC
21790       || GET_CODE (addr) == POST_INC
21791       || GET_CODE (addr) == PRE_MODIFY
21792       || GET_CODE (addr) == POST_MODIFY)
21793     return 0;
21794
21795   ok = ix86_decompose_address (addr, &parts);
21796   gcc_assert (ok);
21797
21798   if (parts.base && GET_CODE (parts.base) == SUBREG)
21799     parts.base = SUBREG_REG (parts.base);
21800   if (parts.index && GET_CODE (parts.index) == SUBREG)
21801     parts.index = SUBREG_REG (parts.index);
21802
21803   base = parts.base;
21804   index = parts.index;
21805   disp = parts.disp;
21806   len = 0;
21807
21808   /* Rule of thumb:
21809        - esp as the base always wants an index,
21810        - ebp as the base always wants a displacement,
21811        - r12 as the base always wants an index,
21812        - r13 as the base always wants a displacement.  */
21813
21814   /* Register Indirect.  */
21815   if (base && !index && !disp)
21816     {
21817       /* esp (for its index) and ebp (for its displacement) need
21818          the two-byte modrm form.  Similarly for r12 and r13 in 64-bit
21819          code.  */
21820       if (REG_P (addr)
21821           && (addr == arg_pointer_rtx
21822               || addr == frame_pointer_rtx
21823               || REGNO (addr) == SP_REG
21824               || REGNO (addr) == BP_REG
21825               || REGNO (addr) == R12_REG
21826               || REGNO (addr) == R13_REG))
21827         len = 1;
21828     }
21829
21830   /* Direct Addressing.  In 64-bit mode mod 00 r/m 5
21831      is not disp32, but disp32(%rip), so for disp32
21832      SIB byte is needed, unless print_operand_address
21833      optimizes it into disp32(%rip) or (%rip) is implied
21834      by UNSPEC.  */
21835   else if (disp && !base && !index)
21836     {
21837       len = 4;
21838       if (TARGET_64BIT)
21839         {
21840           rtx symbol = disp;
21841
21842           if (GET_CODE (disp) == CONST)
21843             symbol = XEXP (disp, 0);
21844           if (GET_CODE (symbol) == PLUS
21845               && CONST_INT_P (XEXP (symbol, 1)))
21846             symbol = XEXP (symbol, 0);
21847
21848           if (GET_CODE (symbol) != LABEL_REF
21849               && (GET_CODE (symbol) != SYMBOL_REF
21850                   || SYMBOL_REF_TLS_MODEL (symbol) != 0)
21851               && (GET_CODE (symbol) != UNSPEC
21852                   || (XINT (symbol, 1) != UNSPEC_GOTPCREL
21853                       && XINT (symbol, 1) != UNSPEC_PCREL
21854                       && XINT (symbol, 1) != UNSPEC_GOTNTPOFF)))
21855             len += 1;
21856         }
21857     }
21858
21859   else
21860     {
21861       /* Find the length of the displacement constant.  */
21862       if (disp)
21863         {
21864           if (base && satisfies_constraint_K (disp))
21865             len = 1;
21866           else
21867             len = 4;
21868         }
21869       /* ebp always wants a displacement.  Similarly r13.  */
21870       else if (base && REG_P (base)
21871                && (REGNO (base) == BP_REG || REGNO (base) == R13_REG))
21872         len = 1;
21873
21874       /* An index requires the two-byte modrm form....  */
21875       if (index
21876           /* ...like esp (or r12), which always wants an index.  */
21877           || base == arg_pointer_rtx
21878           || base == frame_pointer_rtx
21879           || (base && REG_P (base)
21880               && (REGNO (base) == SP_REG || REGNO (base) == R12_REG)))
21881         len += 1;
21882     }
21883
21884   switch (parts.seg)
21885     {
21886     case SEG_FS:
21887     case SEG_GS:
21888       len += 1;
21889       break;
21890     default:
21891       break;
21892     }
21893
21894   return len;
21895 }
21896
21897 /* Compute default value for "length_immediate" attribute.  When SHORTFORM
21898    is set, expect that insn have 8bit immediate alternative.  */
21899 int
21900 ix86_attr_length_immediate_default (rtx insn, bool shortform)
21901 {
21902   int len = 0;
21903   int i;
21904   extract_insn_cached (insn);
21905   for (i = recog_data.n_operands - 1; i >= 0; --i)
21906     if (CONSTANT_P (recog_data.operand[i]))
21907       {
21908         enum attr_mode mode = get_attr_mode (insn);
21909
21910         gcc_assert (!len);
21911         if (shortform && CONST_INT_P (recog_data.operand[i]))
21912           {
21913             HOST_WIDE_INT ival = INTVAL (recog_data.operand[i]);
21914             switch (mode)
21915               {
21916               case MODE_QI:
21917                 len = 1;
21918                 continue;
21919               case MODE_HI:
21920                 ival = trunc_int_for_mode (ival, HImode);
21921                 break;
21922               case MODE_SI:
21923                 ival = trunc_int_for_mode (ival, SImode);
21924                 break;
21925               default:
21926                 break;
21927               }
21928             if (IN_RANGE (ival, -128, 127))
21929               {
21930                 len = 1;
21931                 continue;
21932               }
21933           }
21934         switch (mode)
21935           {
21936           case MODE_QI:
21937             len = 1;
21938             break;
21939           case MODE_HI:
21940             len = 2;
21941             break;
21942           case MODE_SI:
21943             len = 4;
21944             break;
21945           /* Immediates for DImode instructions are encoded as 32bit sign extended values.  */
21946           case MODE_DI:
21947             len = 4;
21948             break;
21949           default:
21950             fatal_insn ("unknown insn mode", insn);
21951         }
21952       }
21953   return len;
21954 }
21955 /* Compute default value for "length_address" attribute.  */
21956 int
21957 ix86_attr_length_address_default (rtx insn)
21958 {
21959   int i;
21960
21961   if (get_attr_type (insn) == TYPE_LEA)
21962     {
21963       rtx set = PATTERN (insn), addr;
21964
21965       if (GET_CODE (set) == PARALLEL)
21966         set = XVECEXP (set, 0, 0);
21967
21968       gcc_assert (GET_CODE (set) == SET);
21969
21970       addr = SET_SRC (set);
21971       if (TARGET_64BIT && get_attr_mode (insn) == MODE_SI)
21972         {
21973           if (GET_CODE (addr) == ZERO_EXTEND)
21974             addr = XEXP (addr, 0);
21975           if (GET_CODE (addr) == SUBREG)
21976             addr = SUBREG_REG (addr);
21977         }
21978
21979       return memory_address_length (addr);
21980     }
21981
21982   extract_insn_cached (insn);
21983   for (i = recog_data.n_operands - 1; i >= 0; --i)
21984     if (MEM_P (recog_data.operand[i]))
21985       {
21986         constrain_operands_cached (reload_completed);
21987         if (which_alternative != -1)
21988           {
21989             const char *constraints = recog_data.constraints[i];
21990             int alt = which_alternative;
21991
21992             while (*constraints == '=' || *constraints == '+')
21993               constraints++;
21994             while (alt-- > 0)
21995               while (*constraints++ != ',')
21996                 ;
21997             /* Skip ignored operands.  */
21998             if (*constraints == 'X')
21999               continue;
22000           }
22001         return memory_address_length (XEXP (recog_data.operand[i], 0));
22002       }
22003   return 0;
22004 }
22005
22006 /* Compute default value for "length_vex" attribute. It includes
22007    2 or 3 byte VEX prefix and 1 opcode byte.  */
22008
22009 int
22010 ix86_attr_length_vex_default (rtx insn, bool has_0f_opcode, bool has_vex_w)
22011 {
22012   int i;
22013
22014   /* Only 0f opcode can use 2 byte VEX prefix and  VEX W bit uses 3
22015      byte VEX prefix.  */
22016   if (!has_0f_opcode || has_vex_w)
22017     return 3 + 1;
22018
22019  /* We can always use 2 byte VEX prefix in 32bit.  */
22020   if (!TARGET_64BIT)
22021     return 2 + 1;
22022
22023   extract_insn_cached (insn);
22024
22025   for (i = recog_data.n_operands - 1; i >= 0; --i)
22026     if (REG_P (recog_data.operand[i]))
22027       {
22028         /* REX.W bit uses 3 byte VEX prefix.  */
22029         if (GET_MODE (recog_data.operand[i]) == DImode
22030             && GENERAL_REG_P (recog_data.operand[i]))
22031           return 3 + 1;
22032       }
22033     else
22034       {
22035         /* REX.X or REX.B bits use 3 byte VEX prefix.  */
22036         if (MEM_P (recog_data.operand[i])
22037             && x86_extended_reg_mentioned_p (recog_data.operand[i]))
22038           return 3 + 1;
22039       }
22040
22041   return 2 + 1;
22042 }
22043 \f
22044 /* Return the maximum number of instructions a cpu can issue.  */
22045
22046 static int
22047 ix86_issue_rate (void)
22048 {
22049   switch (ix86_tune)
22050     {
22051     case PROCESSOR_PENTIUM:
22052     case PROCESSOR_ATOM:
22053     case PROCESSOR_K6:
22054       return 2;
22055
22056     case PROCESSOR_PENTIUMPRO:
22057     case PROCESSOR_PENTIUM4:
22058     case PROCESSOR_CORE2_32:
22059     case PROCESSOR_CORE2_64:
22060     case PROCESSOR_COREI7_32:
22061     case PROCESSOR_COREI7_64:
22062     case PROCESSOR_ATHLON:
22063     case PROCESSOR_K8:
22064     case PROCESSOR_AMDFAM10:
22065     case PROCESSOR_NOCONA:
22066     case PROCESSOR_GENERIC32:
22067     case PROCESSOR_GENERIC64:
22068     case PROCESSOR_BDVER1:
22069     case PROCESSOR_BDVER2:
22070     case PROCESSOR_BTVER1:
22071       return 3;
22072
22073     default:
22074       return 1;
22075     }
22076 }
22077
22078 /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
22079    by DEP_INSN and nothing set by DEP_INSN.  */
22080
22081 static bool
22082 ix86_flags_dependent (rtx insn, rtx dep_insn, enum attr_type insn_type)
22083 {
22084   rtx set, set2;
22085
22086   /* Simplify the test for uninteresting insns.  */
22087   if (insn_type != TYPE_SETCC
22088       && insn_type != TYPE_ICMOV
22089       && insn_type != TYPE_FCMOV
22090       && insn_type != TYPE_IBR)
22091     return false;
22092
22093   if ((set = single_set (dep_insn)) != 0)
22094     {
22095       set = SET_DEST (set);
22096       set2 = NULL_RTX;
22097     }
22098   else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
22099            && XVECLEN (PATTERN (dep_insn), 0) == 2
22100            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
22101            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
22102     {
22103       set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22104       set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
22105     }
22106   else
22107     return false;
22108
22109   if (!REG_P (set) || REGNO (set) != FLAGS_REG)
22110     return false;
22111
22112   /* This test is true if the dependent insn reads the flags but
22113      not any other potentially set register.  */
22114   if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
22115     return false;
22116
22117   if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
22118     return false;
22119
22120   return true;
22121 }
22122
22123 /* Return true iff USE_INSN has a memory address with operands set by
22124    SET_INSN.  */
22125
22126 bool
22127 ix86_agi_dependent (rtx set_insn, rtx use_insn)
22128 {
22129   int i;
22130   extract_insn_cached (use_insn);
22131   for (i = recog_data.n_operands - 1; i >= 0; --i)
22132     if (MEM_P (recog_data.operand[i]))
22133       {
22134         rtx addr = XEXP (recog_data.operand[i], 0);
22135         return modified_in_p (addr, set_insn) != 0;
22136       }
22137   return false;
22138 }
22139
22140 static int
22141 ix86_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
22142 {
22143   enum attr_type insn_type, dep_insn_type;
22144   enum attr_memory memory;
22145   rtx set, set2;
22146   int dep_insn_code_number;
22147
22148   /* Anti and output dependencies have zero cost on all CPUs.  */
22149   if (REG_NOTE_KIND (link) != 0)
22150     return 0;
22151
22152   dep_insn_code_number = recog_memoized (dep_insn);
22153
22154   /* If we can't recognize the insns, we can't really do anything.  */
22155   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
22156     return cost;
22157
22158   insn_type = get_attr_type (insn);
22159   dep_insn_type = get_attr_type (dep_insn);
22160
22161   switch (ix86_tune)
22162     {
22163     case PROCESSOR_PENTIUM:
22164       /* Address Generation Interlock adds a cycle of latency.  */
22165       if (insn_type == TYPE_LEA)
22166         {
22167           rtx addr = PATTERN (insn);
22168
22169           if (GET_CODE (addr) == PARALLEL)
22170             addr = XVECEXP (addr, 0, 0);
22171
22172           gcc_assert (GET_CODE (addr) == SET);
22173
22174           addr = SET_SRC (addr);
22175           if (modified_in_p (addr, dep_insn))
22176             cost += 1;
22177         }
22178       else if (ix86_agi_dependent (dep_insn, insn))
22179         cost += 1;
22180
22181       /* ??? Compares pair with jump/setcc.  */
22182       if (ix86_flags_dependent (insn, dep_insn, insn_type))
22183         cost = 0;
22184
22185       /* Floating point stores require value to be ready one cycle earlier.  */
22186       if (insn_type == TYPE_FMOV
22187           && get_attr_memory (insn) == MEMORY_STORE
22188           && !ix86_agi_dependent (dep_insn, insn))
22189         cost += 1;
22190       break;
22191
22192     case PROCESSOR_PENTIUMPRO:
22193       memory = get_attr_memory (insn);
22194
22195       /* INT->FP conversion is expensive.  */
22196       if (get_attr_fp_int_src (dep_insn))
22197         cost += 5;
22198
22199       /* There is one cycle extra latency between an FP op and a store.  */
22200       if (insn_type == TYPE_FMOV
22201           && (set = single_set (dep_insn)) != NULL_RTX
22202           && (set2 = single_set (insn)) != NULL_RTX
22203           && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
22204           && MEM_P (SET_DEST (set2)))
22205         cost += 1;
22206
22207       /* Show ability of reorder buffer to hide latency of load by executing
22208          in parallel with previous instruction in case
22209          previous instruction is not needed to compute the address.  */
22210       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22211           && !ix86_agi_dependent (dep_insn, insn))
22212         {
22213           /* Claim moves to take one cycle, as core can issue one load
22214              at time and the next load can start cycle later.  */
22215           if (dep_insn_type == TYPE_IMOV
22216               || dep_insn_type == TYPE_FMOV)
22217             cost = 1;
22218           else if (cost > 1)
22219             cost--;
22220         }
22221       break;
22222
22223     case PROCESSOR_K6:
22224       memory = get_attr_memory (insn);
22225
22226       /* The esp dependency is resolved before the instruction is really
22227          finished.  */
22228       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
22229           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
22230         return 1;
22231
22232       /* INT->FP conversion is expensive.  */
22233       if (get_attr_fp_int_src (dep_insn))
22234         cost += 5;
22235
22236       /* Show ability of reorder buffer to hide latency of load by executing
22237          in parallel with previous instruction in case
22238          previous instruction is not needed to compute the address.  */
22239       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22240           && !ix86_agi_dependent (dep_insn, insn))
22241         {
22242           /* Claim moves to take one cycle, as core can issue one load
22243              at time and the next load can start cycle later.  */
22244           if (dep_insn_type == TYPE_IMOV
22245               || dep_insn_type == TYPE_FMOV)
22246             cost = 1;
22247           else if (cost > 2)
22248             cost -= 2;
22249           else
22250             cost = 1;
22251         }
22252       break;
22253
22254     case PROCESSOR_ATHLON:
22255     case PROCESSOR_K8:
22256     case PROCESSOR_AMDFAM10:
22257     case PROCESSOR_BDVER1:
22258     case PROCESSOR_BDVER2:
22259     case PROCESSOR_BTVER1:
22260     case PROCESSOR_ATOM:
22261     case PROCESSOR_GENERIC32:
22262     case PROCESSOR_GENERIC64:
22263       memory = get_attr_memory (insn);
22264
22265       /* Show ability of reorder buffer to hide latency of load by executing
22266          in parallel with previous instruction in case
22267          previous instruction is not needed to compute the address.  */
22268       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
22269           && !ix86_agi_dependent (dep_insn, insn))
22270         {
22271           enum attr_unit unit = get_attr_unit (insn);
22272           int loadcost = 3;
22273
22274           /* Because of the difference between the length of integer and
22275              floating unit pipeline preparation stages, the memory operands
22276              for floating point are cheaper.
22277
22278              ??? For Athlon it the difference is most probably 2.  */
22279           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
22280             loadcost = 3;
22281           else
22282             loadcost = TARGET_ATHLON ? 2 : 0;
22283
22284           if (cost >= loadcost)
22285             cost -= loadcost;
22286           else
22287             cost = 0;
22288         }
22289
22290     default:
22291       break;
22292     }
22293
22294   return cost;
22295 }
22296
22297 /* How many alternative schedules to try.  This should be as wide as the
22298    scheduling freedom in the DFA, but no wider.  Making this value too
22299    large results extra work for the scheduler.  */
22300
22301 static int
22302 ia32_multipass_dfa_lookahead (void)
22303 {
22304   switch (ix86_tune)
22305     {
22306     case PROCESSOR_PENTIUM:
22307       return 2;
22308
22309     case PROCESSOR_PENTIUMPRO:
22310     case PROCESSOR_K6:
22311       return 1;
22312
22313     case PROCESSOR_CORE2_32:
22314     case PROCESSOR_CORE2_64:
22315     case PROCESSOR_COREI7_32:
22316     case PROCESSOR_COREI7_64:
22317       /* Generally, we want haifa-sched:max_issue() to look ahead as far
22318          as many instructions can be executed on a cycle, i.e.,
22319          issue_rate.  I wonder why tuning for many CPUs does not do this.  */
22320       return ix86_issue_rate ();
22321
22322     default:
22323       return 0;
22324     }
22325 }
22326
22327 \f
22328
22329 /* Model decoder of Core 2/i7.
22330    Below hooks for multipass scheduling (see haifa-sched.c:max_issue)
22331    track the instruction fetch block boundaries and make sure that long
22332    (9+ bytes) instructions are assigned to D0.  */
22333
22334 /* Maximum length of an insn that can be handled by
22335    a secondary decoder unit.  '8' for Core 2/i7.  */
22336 static int core2i7_secondary_decoder_max_insn_size;
22337
22338 /* Ifetch block size, i.e., number of bytes decoder reads per cycle.
22339    '16' for Core 2/i7.  */
22340 static int core2i7_ifetch_block_size;
22341
22342 /* Maximum number of instructions decoder can handle per cycle.
22343    '6' for Core 2/i7.  */
22344 static int core2i7_ifetch_block_max_insns;
22345
22346 typedef struct ix86_first_cycle_multipass_data_ *
22347   ix86_first_cycle_multipass_data_t;
22348 typedef const struct ix86_first_cycle_multipass_data_ *
22349   const_ix86_first_cycle_multipass_data_t;
22350
22351 /* A variable to store target state across calls to max_issue within
22352    one cycle.  */
22353 static struct ix86_first_cycle_multipass_data_ _ix86_first_cycle_multipass_data,
22354   *ix86_first_cycle_multipass_data = &_ix86_first_cycle_multipass_data;
22355
22356 /* Initialize DATA.  */
22357 static void
22358 core2i7_first_cycle_multipass_init (void *_data)
22359 {
22360   ix86_first_cycle_multipass_data_t data
22361     = (ix86_first_cycle_multipass_data_t) _data;
22362
22363   data->ifetch_block_len = 0;
22364   data->ifetch_block_n_insns = 0;
22365   data->ready_try_change = NULL;
22366   data->ready_try_change_size = 0;
22367 }
22368
22369 /* Advancing the cycle; reset ifetch block counts.  */
22370 static void
22371 core2i7_dfa_post_advance_cycle (void)
22372 {
22373   ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data;
22374
22375   gcc_assert (data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
22376
22377   data->ifetch_block_len = 0;
22378   data->ifetch_block_n_insns = 0;
22379 }
22380
22381 static int min_insn_size (rtx);
22382
22383 /* Filter out insns from ready_try that the core will not be able to issue
22384    on current cycle due to decoder.  */
22385 static void
22386 core2i7_first_cycle_multipass_filter_ready_try
22387 (const_ix86_first_cycle_multipass_data_t data,
22388  char *ready_try, int n_ready, bool first_cycle_insn_p)
22389 {
22390   while (n_ready--)
22391     {
22392       rtx insn;
22393       int insn_size;
22394
22395       if (ready_try[n_ready])
22396         continue;
22397
22398       insn = get_ready_element (n_ready);
22399       insn_size = min_insn_size (insn);
22400
22401       if (/* If this is a too long an insn for a secondary decoder ...  */
22402           (!first_cycle_insn_p
22403            && insn_size > core2i7_secondary_decoder_max_insn_size)
22404           /* ... or it would not fit into the ifetch block ...  */
22405           || data->ifetch_block_len + insn_size > core2i7_ifetch_block_size
22406           /* ... or the decoder is full already ...  */
22407           || data->ifetch_block_n_insns + 1 > core2i7_ifetch_block_max_insns)
22408         /* ... mask the insn out.  */
22409         {
22410           ready_try[n_ready] = 1;
22411
22412           if (data->ready_try_change)
22413             SET_BIT (data->ready_try_change, n_ready);
22414         }
22415     }
22416 }
22417
22418 /* Prepare for a new round of multipass lookahead scheduling.  */
22419 static void
22420 core2i7_first_cycle_multipass_begin (void *_data, char *ready_try, int n_ready,
22421                                      bool first_cycle_insn_p)
22422 {
22423   ix86_first_cycle_multipass_data_t data
22424     = (ix86_first_cycle_multipass_data_t) _data;
22425   const_ix86_first_cycle_multipass_data_t prev_data
22426     = ix86_first_cycle_multipass_data;
22427
22428   /* Restore the state from the end of the previous round.  */
22429   data->ifetch_block_len = prev_data->ifetch_block_len;
22430   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns;
22431
22432   /* Filter instructions that cannot be issued on current cycle due to
22433      decoder restrictions.  */
22434   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
22435                                                   first_cycle_insn_p);
22436 }
22437
22438 /* INSN is being issued in current solution.  Account for its impact on
22439    the decoder model.  */
22440 static void
22441 core2i7_first_cycle_multipass_issue (void *_data, char *ready_try, int n_ready,
22442                                      rtx insn, const void *_prev_data)
22443 {
22444   ix86_first_cycle_multipass_data_t data
22445     = (ix86_first_cycle_multipass_data_t) _data;
22446   const_ix86_first_cycle_multipass_data_t prev_data
22447     = (const_ix86_first_cycle_multipass_data_t) _prev_data;
22448
22449   int insn_size = min_insn_size (insn);
22450
22451   data->ifetch_block_len = prev_data->ifetch_block_len + insn_size;
22452   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns + 1;
22453   gcc_assert (data->ifetch_block_len <= core2i7_ifetch_block_size
22454               && data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
22455
22456   /* Allocate or resize the bitmap for storing INSN's effect on ready_try.  */
22457   if (!data->ready_try_change)
22458     {
22459       data->ready_try_change = sbitmap_alloc (n_ready);
22460       data->ready_try_change_size = n_ready;
22461     }
22462   else if (data->ready_try_change_size < n_ready)
22463     {
22464       data->ready_try_change = sbitmap_resize (data->ready_try_change,
22465                                                n_ready, 0);
22466       data->ready_try_change_size = n_ready;
22467     }
22468   sbitmap_zero (data->ready_try_change);
22469
22470   /* Filter out insns from ready_try that the core will not be able to issue
22471      on current cycle due to decoder.  */
22472   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
22473                                                   false);
22474 }
22475
22476 /* Revert the effect on ready_try.  */
22477 static void
22478 core2i7_first_cycle_multipass_backtrack (const void *_data,
22479                                          char *ready_try,
22480                                          int n_ready ATTRIBUTE_UNUSED)
22481 {
22482   const_ix86_first_cycle_multipass_data_t data
22483     = (const_ix86_first_cycle_multipass_data_t) _data;
22484   unsigned int i = 0;
22485   sbitmap_iterator sbi;
22486
22487   gcc_assert (sbitmap_last_set_bit (data->ready_try_change) < n_ready);
22488   EXECUTE_IF_SET_IN_SBITMAP (data->ready_try_change, 0, i, sbi)
22489     {
22490       ready_try[i] = 0;
22491     }
22492 }
22493
22494 /* Save the result of multipass lookahead scheduling for the next round.  */
22495 static void
22496 core2i7_first_cycle_multipass_end (const void *_data)
22497 {
22498   const_ix86_first_cycle_multipass_data_t data
22499     = (const_ix86_first_cycle_multipass_data_t) _data;
22500   ix86_first_cycle_multipass_data_t next_data
22501     = ix86_first_cycle_multipass_data;
22502
22503   if (data != NULL)
22504     {
22505       next_data->ifetch_block_len = data->ifetch_block_len;
22506       next_data->ifetch_block_n_insns = data->ifetch_block_n_insns;
22507     }
22508 }
22509
22510 /* Deallocate target data.  */
22511 static void
22512 core2i7_first_cycle_multipass_fini (void *_data)
22513 {
22514   ix86_first_cycle_multipass_data_t data
22515     = (ix86_first_cycle_multipass_data_t) _data;
22516
22517   if (data->ready_try_change)
22518     {
22519       sbitmap_free (data->ready_try_change);
22520       data->ready_try_change = NULL;
22521       data->ready_try_change_size = 0;
22522     }
22523 }
22524
22525 /* Prepare for scheduling pass.  */
22526 static void
22527 ix86_sched_init_global (FILE *dump ATTRIBUTE_UNUSED,
22528                         int verbose ATTRIBUTE_UNUSED,
22529                         int max_uid ATTRIBUTE_UNUSED)
22530 {
22531   /* Install scheduling hooks for current CPU.  Some of these hooks are used
22532      in time-critical parts of the scheduler, so we only set them up when
22533      they are actually used.  */
22534   switch (ix86_tune)
22535     {
22536     case PROCESSOR_CORE2_32:
22537     case PROCESSOR_CORE2_64:
22538     case PROCESSOR_COREI7_32:
22539     case PROCESSOR_COREI7_64:
22540       targetm.sched.dfa_post_advance_cycle
22541         = core2i7_dfa_post_advance_cycle;
22542       targetm.sched.first_cycle_multipass_init
22543         = core2i7_first_cycle_multipass_init;
22544       targetm.sched.first_cycle_multipass_begin
22545         = core2i7_first_cycle_multipass_begin;
22546       targetm.sched.first_cycle_multipass_issue
22547         = core2i7_first_cycle_multipass_issue;
22548       targetm.sched.first_cycle_multipass_backtrack
22549         = core2i7_first_cycle_multipass_backtrack;
22550       targetm.sched.first_cycle_multipass_end
22551         = core2i7_first_cycle_multipass_end;
22552       targetm.sched.first_cycle_multipass_fini
22553         = core2i7_first_cycle_multipass_fini;
22554
22555       /* Set decoder parameters.  */
22556       core2i7_secondary_decoder_max_insn_size = 8;
22557       core2i7_ifetch_block_size = 16;
22558       core2i7_ifetch_block_max_insns = 6;
22559       break;
22560
22561     default:
22562       targetm.sched.dfa_post_advance_cycle = NULL;
22563       targetm.sched.first_cycle_multipass_init = NULL;
22564       targetm.sched.first_cycle_multipass_begin = NULL;
22565       targetm.sched.first_cycle_multipass_issue = NULL;
22566       targetm.sched.first_cycle_multipass_backtrack = NULL;
22567       targetm.sched.first_cycle_multipass_end = NULL;
22568       targetm.sched.first_cycle_multipass_fini = NULL;
22569       break;
22570     }
22571 }
22572
22573 \f
22574 /* Compute the alignment given to a constant that is being placed in memory.
22575    EXP is the constant and ALIGN is the alignment that the object would
22576    ordinarily have.
22577    The value of this function is used instead of that alignment to align
22578    the object.  */
22579
22580 int
22581 ix86_constant_alignment (tree exp, int align)
22582 {
22583   if (TREE_CODE (exp) == REAL_CST || TREE_CODE (exp) == VECTOR_CST
22584       || TREE_CODE (exp) == INTEGER_CST)
22585     {
22586       if (TYPE_MODE (TREE_TYPE (exp)) == DFmode && align < 64)
22587         return 64;
22588       else if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (exp))) && align < 128)
22589         return 128;
22590     }
22591   else if (!optimize_size && TREE_CODE (exp) == STRING_CST
22592            && TREE_STRING_LENGTH (exp) >= 31 && align < BITS_PER_WORD)
22593     return BITS_PER_WORD;
22594
22595   return align;
22596 }
22597
22598 /* Compute the alignment for a static variable.
22599    TYPE is the data type, and ALIGN is the alignment that
22600    the object would ordinarily have.  The value of this function is used
22601    instead of that alignment to align the object.  */
22602
22603 int
22604 ix86_data_alignment (tree type, int align)
22605 {
22606   int max_align = optimize_size ? BITS_PER_WORD : MIN (256, MAX_OFILE_ALIGNMENT);
22607
22608   if (AGGREGATE_TYPE_P (type)
22609       && TYPE_SIZE (type)
22610       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22611       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align
22612           || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
22613       && align < max_align)
22614     align = max_align;
22615
22616   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
22617      to 16byte boundary.  */
22618   if (TARGET_64BIT)
22619     {
22620       if (AGGREGATE_TYPE_P (type)
22621            && TYPE_SIZE (type)
22622            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22623            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 128
22624                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
22625         return 128;
22626     }
22627
22628   if (TREE_CODE (type) == ARRAY_TYPE)
22629     {
22630       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
22631         return 64;
22632       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
22633         return 128;
22634     }
22635   else if (TREE_CODE (type) == COMPLEX_TYPE)
22636     {
22637
22638       if (TYPE_MODE (type) == DCmode && align < 64)
22639         return 64;
22640       if ((TYPE_MODE (type) == XCmode
22641            || TYPE_MODE (type) == TCmode) && align < 128)
22642         return 128;
22643     }
22644   else if ((TREE_CODE (type) == RECORD_TYPE
22645             || TREE_CODE (type) == UNION_TYPE
22646             || TREE_CODE (type) == QUAL_UNION_TYPE)
22647            && TYPE_FIELDS (type))
22648     {
22649       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
22650         return 64;
22651       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
22652         return 128;
22653     }
22654   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
22655            || TREE_CODE (type) == INTEGER_TYPE)
22656     {
22657       if (TYPE_MODE (type) == DFmode && align < 64)
22658         return 64;
22659       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
22660         return 128;
22661     }
22662
22663   return align;
22664 }
22665
22666 /* Compute the alignment for a local variable or a stack slot.  EXP is
22667    the data type or decl itself, MODE is the widest mode available and
22668    ALIGN is the alignment that the object would ordinarily have.  The
22669    value of this macro is used instead of that alignment to align the
22670    object.  */
22671
22672 unsigned int
22673 ix86_local_alignment (tree exp, enum machine_mode mode,
22674                       unsigned int align)
22675 {
22676   tree type, decl;
22677
22678   if (exp && DECL_P (exp))
22679     {
22680       type = TREE_TYPE (exp);
22681       decl = exp;
22682     }
22683   else
22684     {
22685       type = exp;
22686       decl = NULL;
22687     }
22688
22689   /* Don't do dynamic stack realignment for long long objects with
22690      -mpreferred-stack-boundary=2.  */
22691   if (!TARGET_64BIT
22692       && align == 64
22693       && ix86_preferred_stack_boundary < 64
22694       && (mode == DImode || (type && TYPE_MODE (type) == DImode))
22695       && (!type || !TYPE_USER_ALIGN (type))
22696       && (!decl || !DECL_USER_ALIGN (decl)))
22697     align = 32;
22698
22699   /* If TYPE is NULL, we are allocating a stack slot for caller-save
22700      register in MODE.  We will return the largest alignment of XF
22701      and DF.  */
22702   if (!type)
22703     {
22704       if (mode == XFmode && align < GET_MODE_ALIGNMENT (DFmode))
22705         align = GET_MODE_ALIGNMENT (DFmode);
22706       return align;
22707     }
22708
22709   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
22710      to 16byte boundary.  Exact wording is:
22711
22712      An array uses the same alignment as its elements, except that a local or
22713      global array variable of length at least 16 bytes or
22714      a C99 variable-length array variable always has alignment of at least 16 bytes.
22715
22716      This was added to allow use of aligned SSE instructions at arrays.  This
22717      rule is meant for static storage (where compiler can not do the analysis
22718      by itself).  We follow it for automatic variables only when convenient.
22719      We fully control everything in the function compiled and functions from
22720      other unit can not rely on the alignment.
22721
22722      Exclude va_list type.  It is the common case of local array where
22723      we can not benefit from the alignment.  */
22724   if (TARGET_64BIT && optimize_function_for_speed_p (cfun)
22725       && TARGET_SSE)
22726     {
22727       if (AGGREGATE_TYPE_P (type)
22728            && (va_list_type_node == NULL_TREE
22729                || (TYPE_MAIN_VARIANT (type)
22730                    != TYPE_MAIN_VARIANT (va_list_type_node)))
22731            && TYPE_SIZE (type)
22732            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
22733            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 16
22734                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
22735         return 128;
22736     }
22737   if (TREE_CODE (type) == ARRAY_TYPE)
22738     {
22739       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
22740         return 64;
22741       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
22742         return 128;
22743     }
22744   else if (TREE_CODE (type) == COMPLEX_TYPE)
22745     {
22746       if (TYPE_MODE (type) == DCmode && align < 64)
22747         return 64;
22748       if ((TYPE_MODE (type) == XCmode
22749            || TYPE_MODE (type) == TCmode) && align < 128)
22750         return 128;
22751     }
22752   else if ((TREE_CODE (type) == RECORD_TYPE
22753             || TREE_CODE (type) == UNION_TYPE
22754             || TREE_CODE (type) == QUAL_UNION_TYPE)
22755            && TYPE_FIELDS (type))
22756     {
22757       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
22758         return 64;
22759       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
22760         return 128;
22761     }
22762   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
22763            || TREE_CODE (type) == INTEGER_TYPE)
22764     {
22765
22766       if (TYPE_MODE (type) == DFmode && align < 64)
22767         return 64;
22768       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
22769         return 128;
22770     }
22771   return align;
22772 }
22773
22774 /* Compute the minimum required alignment for dynamic stack realignment
22775    purposes for a local variable, parameter or a stack slot.  EXP is
22776    the data type or decl itself, MODE is its mode and ALIGN is the
22777    alignment that the object would ordinarily have.  */
22778
22779 unsigned int
22780 ix86_minimum_alignment (tree exp, enum machine_mode mode,
22781                         unsigned int align)
22782 {
22783   tree type, decl;
22784
22785   if (exp && DECL_P (exp))
22786     {
22787       type = TREE_TYPE (exp);
22788       decl = exp;
22789     }
22790   else
22791     {
22792       type = exp;
22793       decl = NULL;
22794     }
22795
22796   if (TARGET_64BIT || align != 64 || ix86_preferred_stack_boundary >= 64)
22797     return align;
22798
22799   /* Don't do dynamic stack realignment for long long objects with
22800      -mpreferred-stack-boundary=2.  */
22801   if ((mode == DImode || (type && TYPE_MODE (type) == DImode))
22802       && (!type || !TYPE_USER_ALIGN (type))
22803       && (!decl || !DECL_USER_ALIGN (decl)))
22804     return 32;
22805
22806   return align;
22807 }
22808 \f
22809 /* Find a location for the static chain incoming to a nested function.
22810    This is a register, unless all free registers are used by arguments.  */
22811
22812 static rtx
22813 ix86_static_chain (const_tree fndecl, bool incoming_p)
22814 {
22815   unsigned regno;
22816
22817   if (!DECL_STATIC_CHAIN (fndecl))
22818     return NULL;
22819
22820   if (TARGET_64BIT)
22821     {
22822       /* We always use R10 in 64-bit mode.  */
22823       regno = R10_REG;
22824     }
22825   else
22826     {
22827       tree fntype;
22828       unsigned int ccvt;
22829
22830       /* By default in 32-bit mode we use ECX to pass the static chain.  */
22831       regno = CX_REG;
22832
22833       fntype = TREE_TYPE (fndecl);
22834       ccvt = ix86_get_callcvt (fntype);
22835       if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
22836         {
22837           /* Fastcall functions use ecx/edx for arguments, which leaves
22838              us with EAX for the static chain.
22839              Thiscall functions use ecx for arguments, which also
22840              leaves us with EAX for the static chain.  */
22841           regno = AX_REG;
22842         }
22843       else if (ix86_function_regparm (fntype, fndecl) == 3)
22844         {
22845           /* For regparm 3, we have no free call-clobbered registers in
22846              which to store the static chain.  In order to implement this,
22847              we have the trampoline push the static chain to the stack.
22848              However, we can't push a value below the return address when
22849              we call the nested function directly, so we have to use an
22850              alternate entry point.  For this we use ESI, and have the
22851              alternate entry point push ESI, so that things appear the
22852              same once we're executing the nested function.  */
22853           if (incoming_p)
22854             {
22855               if (fndecl == current_function_decl)
22856                 ix86_static_chain_on_stack = true;
22857               return gen_frame_mem (SImode,
22858                                     plus_constant (arg_pointer_rtx, -8));
22859             }
22860           regno = SI_REG;
22861         }
22862     }
22863
22864   return gen_rtx_REG (Pmode, regno);
22865 }
22866
22867 /* Emit RTL insns to initialize the variable parts of a trampoline.
22868    FNDECL is the decl of the target address; M_TRAMP is a MEM for
22869    the trampoline, and CHAIN_VALUE is an RTX for the static chain
22870    to be passed to the target function.  */
22871
22872 static void
22873 ix86_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
22874 {
22875   rtx mem, fnaddr;
22876   int opcode;
22877   int offset = 0;
22878
22879   fnaddr = XEXP (DECL_RTL (fndecl), 0);
22880
22881   if (TARGET_64BIT)
22882     {
22883       int size;
22884
22885       /* Load the function address to r11.  Try to load address using
22886          the shorter movl instead of movabs.  We may want to support
22887          movq for kernel mode, but kernel does not use trampolines at
22888          the moment.  */
22889       if (x86_64_zext_immediate_operand (fnaddr, VOIDmode))
22890         {
22891           fnaddr = copy_to_mode_reg (DImode, fnaddr);
22892
22893           mem = adjust_address (m_tramp, HImode, offset);
22894           emit_move_insn (mem, gen_int_mode (0xbb41, HImode));
22895
22896           mem = adjust_address (m_tramp, SImode, offset + 2);
22897           emit_move_insn (mem, gen_lowpart (SImode, fnaddr));
22898           offset += 6;
22899         }
22900       else
22901         {
22902           mem = adjust_address (m_tramp, HImode, offset);
22903           emit_move_insn (mem, gen_int_mode (0xbb49, HImode));
22904
22905           mem = adjust_address (m_tramp, DImode, offset + 2);
22906           emit_move_insn (mem, fnaddr);
22907           offset += 10;
22908         }
22909
22910       /* Load static chain using movabs to r10.  Use the
22911          shorter movl instead of movabs for x32.  */
22912       if (TARGET_X32)
22913         {
22914           opcode = 0xba41;
22915           size = 6;
22916         }
22917       else
22918         {
22919           opcode = 0xba49;
22920           size = 10;
22921         }
22922
22923       mem = adjust_address (m_tramp, HImode, offset);
22924       emit_move_insn (mem, gen_int_mode (opcode, HImode));
22925
22926       mem = adjust_address (m_tramp, ptr_mode, offset + 2);
22927       emit_move_insn (mem, chain_value);
22928       offset += size;
22929
22930       /* Jump to r11; the last (unused) byte is a nop, only there to
22931          pad the write out to a single 32-bit store.  */
22932       mem = adjust_address (m_tramp, SImode, offset);
22933       emit_move_insn (mem, gen_int_mode (0x90e3ff49, SImode));
22934       offset += 4;
22935     }
22936   else
22937     {
22938       rtx disp, chain;
22939
22940       /* Depending on the static chain location, either load a register
22941          with a constant, or push the constant to the stack.  All of the
22942          instructions are the same size.  */
22943       chain = ix86_static_chain (fndecl, true);
22944       if (REG_P (chain))
22945         {
22946           switch (REGNO (chain))
22947             {
22948             case AX_REG:
22949               opcode = 0xb8; break;
22950             case CX_REG:
22951               opcode = 0xb9; break;
22952             default:
22953               gcc_unreachable ();
22954             }
22955         }
22956       else
22957         opcode = 0x68;
22958
22959       mem = adjust_address (m_tramp, QImode, offset);
22960       emit_move_insn (mem, gen_int_mode (opcode, QImode));
22961
22962       mem = adjust_address (m_tramp, SImode, offset + 1);
22963       emit_move_insn (mem, chain_value);
22964       offset += 5;
22965
22966       mem = adjust_address (m_tramp, QImode, offset);
22967       emit_move_insn (mem, gen_int_mode (0xe9, QImode));
22968
22969       mem = adjust_address (m_tramp, SImode, offset + 1);
22970
22971       /* Compute offset from the end of the jmp to the target function.
22972          In the case in which the trampoline stores the static chain on
22973          the stack, we need to skip the first insn which pushes the
22974          (call-saved) register static chain; this push is 1 byte.  */
22975       offset += 5;
22976       disp = expand_binop (SImode, sub_optab, fnaddr,
22977                            plus_constant (XEXP (m_tramp, 0),
22978                                           offset - (MEM_P (chain) ? 1 : 0)),
22979                            NULL_RTX, 1, OPTAB_DIRECT);
22980       emit_move_insn (mem, disp);
22981     }
22982
22983   gcc_assert (offset <= TRAMPOLINE_SIZE);
22984
22985 #ifdef HAVE_ENABLE_EXECUTE_STACK
22986 #ifdef CHECK_EXECUTE_STACK_ENABLED
22987   if (CHECK_EXECUTE_STACK_ENABLED)
22988 #endif
22989   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
22990                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
22991 #endif
22992 }
22993 \f
22994 /* The following file contains several enumerations and data structures
22995    built from the definitions in i386-builtin-types.def.  */
22996
22997 #include "i386-builtin-types.inc"
22998
22999 /* Table for the ix86 builtin non-function types.  */
23000 static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1];
23001
23002 /* Retrieve an element from the above table, building some of
23003    the types lazily.  */
23004
23005 static tree
23006 ix86_get_builtin_type (enum ix86_builtin_type tcode)
23007 {
23008   unsigned int index;
23009   tree type, itype;
23010
23011   gcc_assert ((unsigned)tcode < ARRAY_SIZE(ix86_builtin_type_tab));
23012
23013   type = ix86_builtin_type_tab[(int) tcode];
23014   if (type != NULL)
23015     return type;
23016
23017   gcc_assert (tcode > IX86_BT_LAST_PRIM);
23018   if (tcode <= IX86_BT_LAST_VECT)
23019     {
23020       enum machine_mode mode;
23021
23022       index = tcode - IX86_BT_LAST_PRIM - 1;
23023       itype = ix86_get_builtin_type (ix86_builtin_type_vect_base[index]);
23024       mode = ix86_builtin_type_vect_mode[index];
23025
23026       type = build_vector_type_for_mode (itype, mode);
23027     }
23028   else
23029     {
23030       int quals;
23031
23032       index = tcode - IX86_BT_LAST_VECT - 1;
23033       if (tcode <= IX86_BT_LAST_PTR)
23034         quals = TYPE_UNQUALIFIED;
23035       else
23036         quals = TYPE_QUAL_CONST;
23037
23038       itype = ix86_get_builtin_type (ix86_builtin_type_ptr_base[index]);
23039       if (quals != TYPE_UNQUALIFIED)
23040         itype = build_qualified_type (itype, quals);
23041
23042       type = build_pointer_type (itype);
23043     }
23044
23045   ix86_builtin_type_tab[(int) tcode] = type;
23046   return type;
23047 }
23048
23049 /* Table for the ix86 builtin function types.  */
23050 static GTY(()) tree ix86_builtin_func_type_tab[(int) IX86_BT_LAST_ALIAS + 1];
23051
23052 /* Retrieve an element from the above table, building some of
23053    the types lazily.  */
23054
23055 static tree
23056 ix86_get_builtin_func_type (enum ix86_builtin_func_type tcode)
23057 {
23058   tree type;
23059
23060   gcc_assert ((unsigned)tcode < ARRAY_SIZE (ix86_builtin_func_type_tab));
23061
23062   type = ix86_builtin_func_type_tab[(int) tcode];
23063   if (type != NULL)
23064     return type;
23065
23066   if (tcode <= IX86_BT_LAST_FUNC)
23067     {
23068       unsigned start = ix86_builtin_func_start[(int) tcode];
23069       unsigned after = ix86_builtin_func_start[(int) tcode + 1];
23070       tree rtype, atype, args = void_list_node;
23071       unsigned i;
23072
23073       rtype = ix86_get_builtin_type (ix86_builtin_func_args[start]);
23074       for (i = after - 1; i > start; --i)
23075         {
23076           atype = ix86_get_builtin_type (ix86_builtin_func_args[i]);
23077           args = tree_cons (NULL, atype, args);
23078         }
23079
23080       type = build_function_type (rtype, args);
23081     }
23082   else
23083     {
23084       unsigned index = tcode - IX86_BT_LAST_FUNC - 1;
23085       enum ix86_builtin_func_type icode;
23086
23087       icode = ix86_builtin_func_alias_base[index];
23088       type = ix86_get_builtin_func_type (icode);
23089     }
23090
23091   ix86_builtin_func_type_tab[(int) tcode] = type;
23092   return type;
23093 }
23094
23095
23096 /* Codes for all the SSE/MMX builtins.  */
23097 enum ix86_builtins
23098 {
23099   IX86_BUILTIN_ADDPS,
23100   IX86_BUILTIN_ADDSS,
23101   IX86_BUILTIN_DIVPS,
23102   IX86_BUILTIN_DIVSS,
23103   IX86_BUILTIN_MULPS,
23104   IX86_BUILTIN_MULSS,
23105   IX86_BUILTIN_SUBPS,
23106   IX86_BUILTIN_SUBSS,
23107
23108   IX86_BUILTIN_CMPEQPS,
23109   IX86_BUILTIN_CMPLTPS,
23110   IX86_BUILTIN_CMPLEPS,
23111   IX86_BUILTIN_CMPGTPS,
23112   IX86_BUILTIN_CMPGEPS,
23113   IX86_BUILTIN_CMPNEQPS,
23114   IX86_BUILTIN_CMPNLTPS,
23115   IX86_BUILTIN_CMPNLEPS,
23116   IX86_BUILTIN_CMPNGTPS,
23117   IX86_BUILTIN_CMPNGEPS,
23118   IX86_BUILTIN_CMPORDPS,
23119   IX86_BUILTIN_CMPUNORDPS,
23120   IX86_BUILTIN_CMPEQSS,
23121   IX86_BUILTIN_CMPLTSS,
23122   IX86_BUILTIN_CMPLESS,
23123   IX86_BUILTIN_CMPNEQSS,
23124   IX86_BUILTIN_CMPNLTSS,
23125   IX86_BUILTIN_CMPNLESS,
23126   IX86_BUILTIN_CMPNGTSS,
23127   IX86_BUILTIN_CMPNGESS,
23128   IX86_BUILTIN_CMPORDSS,
23129   IX86_BUILTIN_CMPUNORDSS,
23130
23131   IX86_BUILTIN_COMIEQSS,
23132   IX86_BUILTIN_COMILTSS,
23133   IX86_BUILTIN_COMILESS,
23134   IX86_BUILTIN_COMIGTSS,
23135   IX86_BUILTIN_COMIGESS,
23136   IX86_BUILTIN_COMINEQSS,
23137   IX86_BUILTIN_UCOMIEQSS,
23138   IX86_BUILTIN_UCOMILTSS,
23139   IX86_BUILTIN_UCOMILESS,
23140   IX86_BUILTIN_UCOMIGTSS,
23141   IX86_BUILTIN_UCOMIGESS,
23142   IX86_BUILTIN_UCOMINEQSS,
23143
23144   IX86_BUILTIN_CVTPI2PS,
23145   IX86_BUILTIN_CVTPS2PI,
23146   IX86_BUILTIN_CVTSI2SS,
23147   IX86_BUILTIN_CVTSI642SS,
23148   IX86_BUILTIN_CVTSS2SI,
23149   IX86_BUILTIN_CVTSS2SI64,
23150   IX86_BUILTIN_CVTTPS2PI,
23151   IX86_BUILTIN_CVTTSS2SI,
23152   IX86_BUILTIN_CVTTSS2SI64,
23153
23154   IX86_BUILTIN_MAXPS,
23155   IX86_BUILTIN_MAXSS,
23156   IX86_BUILTIN_MINPS,
23157   IX86_BUILTIN_MINSS,
23158
23159   IX86_BUILTIN_LOADUPS,
23160   IX86_BUILTIN_STOREUPS,
23161   IX86_BUILTIN_MOVSS,
23162
23163   IX86_BUILTIN_MOVHLPS,
23164   IX86_BUILTIN_MOVLHPS,
23165   IX86_BUILTIN_LOADHPS,
23166   IX86_BUILTIN_LOADLPS,
23167   IX86_BUILTIN_STOREHPS,
23168   IX86_BUILTIN_STORELPS,
23169
23170   IX86_BUILTIN_MASKMOVQ,
23171   IX86_BUILTIN_MOVMSKPS,
23172   IX86_BUILTIN_PMOVMSKB,
23173
23174   IX86_BUILTIN_MOVNTPS,
23175   IX86_BUILTIN_MOVNTQ,
23176
23177   IX86_BUILTIN_LOADDQU,
23178   IX86_BUILTIN_STOREDQU,
23179
23180   IX86_BUILTIN_PACKSSWB,
23181   IX86_BUILTIN_PACKSSDW,
23182   IX86_BUILTIN_PACKUSWB,
23183
23184   IX86_BUILTIN_PADDB,
23185   IX86_BUILTIN_PADDW,
23186   IX86_BUILTIN_PADDD,
23187   IX86_BUILTIN_PADDQ,
23188   IX86_BUILTIN_PADDSB,
23189   IX86_BUILTIN_PADDSW,
23190   IX86_BUILTIN_PADDUSB,
23191   IX86_BUILTIN_PADDUSW,
23192   IX86_BUILTIN_PSUBB,
23193   IX86_BUILTIN_PSUBW,
23194   IX86_BUILTIN_PSUBD,
23195   IX86_BUILTIN_PSUBQ,
23196   IX86_BUILTIN_PSUBSB,
23197   IX86_BUILTIN_PSUBSW,
23198   IX86_BUILTIN_PSUBUSB,
23199   IX86_BUILTIN_PSUBUSW,
23200
23201   IX86_BUILTIN_PAND,
23202   IX86_BUILTIN_PANDN,
23203   IX86_BUILTIN_POR,
23204   IX86_BUILTIN_PXOR,
23205
23206   IX86_BUILTIN_PAVGB,
23207   IX86_BUILTIN_PAVGW,
23208
23209   IX86_BUILTIN_PCMPEQB,
23210   IX86_BUILTIN_PCMPEQW,
23211   IX86_BUILTIN_PCMPEQD,
23212   IX86_BUILTIN_PCMPGTB,
23213   IX86_BUILTIN_PCMPGTW,
23214   IX86_BUILTIN_PCMPGTD,
23215
23216   IX86_BUILTIN_PMADDWD,
23217
23218   IX86_BUILTIN_PMAXSW,
23219   IX86_BUILTIN_PMAXUB,
23220   IX86_BUILTIN_PMINSW,
23221   IX86_BUILTIN_PMINUB,
23222
23223   IX86_BUILTIN_PMULHUW,
23224   IX86_BUILTIN_PMULHW,
23225   IX86_BUILTIN_PMULLW,
23226
23227   IX86_BUILTIN_PSADBW,
23228   IX86_BUILTIN_PSHUFW,
23229
23230   IX86_BUILTIN_PSLLW,
23231   IX86_BUILTIN_PSLLD,
23232   IX86_BUILTIN_PSLLQ,
23233   IX86_BUILTIN_PSRAW,
23234   IX86_BUILTIN_PSRAD,
23235   IX86_BUILTIN_PSRLW,
23236   IX86_BUILTIN_PSRLD,
23237   IX86_BUILTIN_PSRLQ,
23238   IX86_BUILTIN_PSLLWI,
23239   IX86_BUILTIN_PSLLDI,
23240   IX86_BUILTIN_PSLLQI,
23241   IX86_BUILTIN_PSRAWI,
23242   IX86_BUILTIN_PSRADI,
23243   IX86_BUILTIN_PSRLWI,
23244   IX86_BUILTIN_PSRLDI,
23245   IX86_BUILTIN_PSRLQI,
23246
23247   IX86_BUILTIN_PUNPCKHBW,
23248   IX86_BUILTIN_PUNPCKHWD,
23249   IX86_BUILTIN_PUNPCKHDQ,
23250   IX86_BUILTIN_PUNPCKLBW,
23251   IX86_BUILTIN_PUNPCKLWD,
23252   IX86_BUILTIN_PUNPCKLDQ,
23253
23254   IX86_BUILTIN_SHUFPS,
23255
23256   IX86_BUILTIN_RCPPS,
23257   IX86_BUILTIN_RCPSS,
23258   IX86_BUILTIN_RSQRTPS,
23259   IX86_BUILTIN_RSQRTPS_NR,
23260   IX86_BUILTIN_RSQRTSS,
23261   IX86_BUILTIN_RSQRTF,
23262   IX86_BUILTIN_SQRTPS,
23263   IX86_BUILTIN_SQRTPS_NR,
23264   IX86_BUILTIN_SQRTSS,
23265
23266   IX86_BUILTIN_UNPCKHPS,
23267   IX86_BUILTIN_UNPCKLPS,
23268
23269   IX86_BUILTIN_ANDPS,
23270   IX86_BUILTIN_ANDNPS,
23271   IX86_BUILTIN_ORPS,
23272   IX86_BUILTIN_XORPS,
23273
23274   IX86_BUILTIN_EMMS,
23275   IX86_BUILTIN_LDMXCSR,
23276   IX86_BUILTIN_STMXCSR,
23277   IX86_BUILTIN_SFENCE,
23278
23279   /* 3DNow! Original */
23280   IX86_BUILTIN_FEMMS,
23281   IX86_BUILTIN_PAVGUSB,
23282   IX86_BUILTIN_PF2ID,
23283   IX86_BUILTIN_PFACC,
23284   IX86_BUILTIN_PFADD,
23285   IX86_BUILTIN_PFCMPEQ,
23286   IX86_BUILTIN_PFCMPGE,
23287   IX86_BUILTIN_PFCMPGT,
23288   IX86_BUILTIN_PFMAX,
23289   IX86_BUILTIN_PFMIN,
23290   IX86_BUILTIN_PFMUL,
23291   IX86_BUILTIN_PFRCP,
23292   IX86_BUILTIN_PFRCPIT1,
23293   IX86_BUILTIN_PFRCPIT2,
23294   IX86_BUILTIN_PFRSQIT1,
23295   IX86_BUILTIN_PFRSQRT,
23296   IX86_BUILTIN_PFSUB,
23297   IX86_BUILTIN_PFSUBR,
23298   IX86_BUILTIN_PI2FD,
23299   IX86_BUILTIN_PMULHRW,
23300
23301   /* 3DNow! Athlon Extensions */
23302   IX86_BUILTIN_PF2IW,
23303   IX86_BUILTIN_PFNACC,
23304   IX86_BUILTIN_PFPNACC,
23305   IX86_BUILTIN_PI2FW,
23306   IX86_BUILTIN_PSWAPDSI,
23307   IX86_BUILTIN_PSWAPDSF,
23308
23309   /* SSE2 */
23310   IX86_BUILTIN_ADDPD,
23311   IX86_BUILTIN_ADDSD,
23312   IX86_BUILTIN_DIVPD,
23313   IX86_BUILTIN_DIVSD,
23314   IX86_BUILTIN_MULPD,
23315   IX86_BUILTIN_MULSD,
23316   IX86_BUILTIN_SUBPD,
23317   IX86_BUILTIN_SUBSD,
23318
23319   IX86_BUILTIN_CMPEQPD,
23320   IX86_BUILTIN_CMPLTPD,
23321   IX86_BUILTIN_CMPLEPD,
23322   IX86_BUILTIN_CMPGTPD,
23323   IX86_BUILTIN_CMPGEPD,
23324   IX86_BUILTIN_CMPNEQPD,
23325   IX86_BUILTIN_CMPNLTPD,
23326   IX86_BUILTIN_CMPNLEPD,
23327   IX86_BUILTIN_CMPNGTPD,
23328   IX86_BUILTIN_CMPNGEPD,
23329   IX86_BUILTIN_CMPORDPD,
23330   IX86_BUILTIN_CMPUNORDPD,
23331   IX86_BUILTIN_CMPEQSD,
23332   IX86_BUILTIN_CMPLTSD,
23333   IX86_BUILTIN_CMPLESD,
23334   IX86_BUILTIN_CMPNEQSD,
23335   IX86_BUILTIN_CMPNLTSD,
23336   IX86_BUILTIN_CMPNLESD,
23337   IX86_BUILTIN_CMPORDSD,
23338   IX86_BUILTIN_CMPUNORDSD,
23339
23340   IX86_BUILTIN_COMIEQSD,
23341   IX86_BUILTIN_COMILTSD,
23342   IX86_BUILTIN_COMILESD,
23343   IX86_BUILTIN_COMIGTSD,
23344   IX86_BUILTIN_COMIGESD,
23345   IX86_BUILTIN_COMINEQSD,
23346   IX86_BUILTIN_UCOMIEQSD,
23347   IX86_BUILTIN_UCOMILTSD,
23348   IX86_BUILTIN_UCOMILESD,
23349   IX86_BUILTIN_UCOMIGTSD,
23350   IX86_BUILTIN_UCOMIGESD,
23351   IX86_BUILTIN_UCOMINEQSD,
23352
23353   IX86_BUILTIN_MAXPD,
23354   IX86_BUILTIN_MAXSD,
23355   IX86_BUILTIN_MINPD,
23356   IX86_BUILTIN_MINSD,
23357
23358   IX86_BUILTIN_ANDPD,
23359   IX86_BUILTIN_ANDNPD,
23360   IX86_BUILTIN_ORPD,
23361   IX86_BUILTIN_XORPD,
23362
23363   IX86_BUILTIN_SQRTPD,
23364   IX86_BUILTIN_SQRTSD,
23365
23366   IX86_BUILTIN_UNPCKHPD,
23367   IX86_BUILTIN_UNPCKLPD,
23368
23369   IX86_BUILTIN_SHUFPD,
23370
23371   IX86_BUILTIN_LOADUPD,
23372   IX86_BUILTIN_STOREUPD,
23373   IX86_BUILTIN_MOVSD,
23374
23375   IX86_BUILTIN_LOADHPD,
23376   IX86_BUILTIN_LOADLPD,
23377
23378   IX86_BUILTIN_CVTDQ2PD,
23379   IX86_BUILTIN_CVTDQ2PS,
23380
23381   IX86_BUILTIN_CVTPD2DQ,
23382   IX86_BUILTIN_CVTPD2PI,
23383   IX86_BUILTIN_CVTPD2PS,
23384   IX86_BUILTIN_CVTTPD2DQ,
23385   IX86_BUILTIN_CVTTPD2PI,
23386
23387   IX86_BUILTIN_CVTPI2PD,
23388   IX86_BUILTIN_CVTSI2SD,
23389   IX86_BUILTIN_CVTSI642SD,
23390
23391   IX86_BUILTIN_CVTSD2SI,
23392   IX86_BUILTIN_CVTSD2SI64,
23393   IX86_BUILTIN_CVTSD2SS,
23394   IX86_BUILTIN_CVTSS2SD,
23395   IX86_BUILTIN_CVTTSD2SI,
23396   IX86_BUILTIN_CVTTSD2SI64,
23397
23398   IX86_BUILTIN_CVTPS2DQ,
23399   IX86_BUILTIN_CVTPS2PD,
23400   IX86_BUILTIN_CVTTPS2DQ,
23401
23402   IX86_BUILTIN_MOVNTI,
23403   IX86_BUILTIN_MOVNTPD,
23404   IX86_BUILTIN_MOVNTDQ,
23405
23406   IX86_BUILTIN_MOVQ128,
23407
23408   /* SSE2 MMX */
23409   IX86_BUILTIN_MASKMOVDQU,
23410   IX86_BUILTIN_MOVMSKPD,
23411   IX86_BUILTIN_PMOVMSKB128,
23412
23413   IX86_BUILTIN_PACKSSWB128,
23414   IX86_BUILTIN_PACKSSDW128,
23415   IX86_BUILTIN_PACKUSWB128,
23416
23417   IX86_BUILTIN_PADDB128,
23418   IX86_BUILTIN_PADDW128,
23419   IX86_BUILTIN_PADDD128,
23420   IX86_BUILTIN_PADDQ128,
23421   IX86_BUILTIN_PADDSB128,
23422   IX86_BUILTIN_PADDSW128,
23423   IX86_BUILTIN_PADDUSB128,
23424   IX86_BUILTIN_PADDUSW128,
23425   IX86_BUILTIN_PSUBB128,
23426   IX86_BUILTIN_PSUBW128,
23427   IX86_BUILTIN_PSUBD128,
23428   IX86_BUILTIN_PSUBQ128,
23429   IX86_BUILTIN_PSUBSB128,
23430   IX86_BUILTIN_PSUBSW128,
23431   IX86_BUILTIN_PSUBUSB128,
23432   IX86_BUILTIN_PSUBUSW128,
23433
23434   IX86_BUILTIN_PAND128,
23435   IX86_BUILTIN_PANDN128,
23436   IX86_BUILTIN_POR128,
23437   IX86_BUILTIN_PXOR128,
23438
23439   IX86_BUILTIN_PAVGB128,
23440   IX86_BUILTIN_PAVGW128,
23441
23442   IX86_BUILTIN_PCMPEQB128,
23443   IX86_BUILTIN_PCMPEQW128,
23444   IX86_BUILTIN_PCMPEQD128,
23445   IX86_BUILTIN_PCMPGTB128,
23446   IX86_BUILTIN_PCMPGTW128,
23447   IX86_BUILTIN_PCMPGTD128,
23448
23449   IX86_BUILTIN_PMADDWD128,
23450
23451   IX86_BUILTIN_PMAXSW128,
23452   IX86_BUILTIN_PMAXUB128,
23453   IX86_BUILTIN_PMINSW128,
23454   IX86_BUILTIN_PMINUB128,
23455
23456   IX86_BUILTIN_PMULUDQ,
23457   IX86_BUILTIN_PMULUDQ128,
23458   IX86_BUILTIN_PMULHUW128,
23459   IX86_BUILTIN_PMULHW128,
23460   IX86_BUILTIN_PMULLW128,
23461
23462   IX86_BUILTIN_PSADBW128,
23463   IX86_BUILTIN_PSHUFHW,
23464   IX86_BUILTIN_PSHUFLW,
23465   IX86_BUILTIN_PSHUFD,
23466
23467   IX86_BUILTIN_PSLLDQI128,
23468   IX86_BUILTIN_PSLLWI128,
23469   IX86_BUILTIN_PSLLDI128,
23470   IX86_BUILTIN_PSLLQI128,
23471   IX86_BUILTIN_PSRAWI128,
23472   IX86_BUILTIN_PSRADI128,
23473   IX86_BUILTIN_PSRLDQI128,
23474   IX86_BUILTIN_PSRLWI128,
23475   IX86_BUILTIN_PSRLDI128,
23476   IX86_BUILTIN_PSRLQI128,
23477
23478   IX86_BUILTIN_PSLLDQ128,
23479   IX86_BUILTIN_PSLLW128,
23480   IX86_BUILTIN_PSLLD128,
23481   IX86_BUILTIN_PSLLQ128,
23482   IX86_BUILTIN_PSRAW128,
23483   IX86_BUILTIN_PSRAD128,
23484   IX86_BUILTIN_PSRLW128,
23485   IX86_BUILTIN_PSRLD128,
23486   IX86_BUILTIN_PSRLQ128,
23487
23488   IX86_BUILTIN_PUNPCKHBW128,
23489   IX86_BUILTIN_PUNPCKHWD128,
23490   IX86_BUILTIN_PUNPCKHDQ128,
23491   IX86_BUILTIN_PUNPCKHQDQ128,
23492   IX86_BUILTIN_PUNPCKLBW128,
23493   IX86_BUILTIN_PUNPCKLWD128,
23494   IX86_BUILTIN_PUNPCKLDQ128,
23495   IX86_BUILTIN_PUNPCKLQDQ128,
23496
23497   IX86_BUILTIN_CLFLUSH,
23498   IX86_BUILTIN_MFENCE,
23499   IX86_BUILTIN_LFENCE,
23500   IX86_BUILTIN_PAUSE,
23501
23502   IX86_BUILTIN_BSRSI,
23503   IX86_BUILTIN_BSRDI,
23504   IX86_BUILTIN_RDPMC,
23505   IX86_BUILTIN_RDTSC,
23506   IX86_BUILTIN_RDTSCP,
23507   IX86_BUILTIN_ROLQI,
23508   IX86_BUILTIN_ROLHI,
23509   IX86_BUILTIN_RORQI,
23510   IX86_BUILTIN_RORHI,
23511
23512   /* SSE3.  */
23513   IX86_BUILTIN_ADDSUBPS,
23514   IX86_BUILTIN_HADDPS,
23515   IX86_BUILTIN_HSUBPS,
23516   IX86_BUILTIN_MOVSHDUP,
23517   IX86_BUILTIN_MOVSLDUP,
23518   IX86_BUILTIN_ADDSUBPD,
23519   IX86_BUILTIN_HADDPD,
23520   IX86_BUILTIN_HSUBPD,
23521   IX86_BUILTIN_LDDQU,
23522
23523   IX86_BUILTIN_MONITOR,
23524   IX86_BUILTIN_MWAIT,
23525
23526   /* SSSE3.  */
23527   IX86_BUILTIN_PHADDW,
23528   IX86_BUILTIN_PHADDD,
23529   IX86_BUILTIN_PHADDSW,
23530   IX86_BUILTIN_PHSUBW,
23531   IX86_BUILTIN_PHSUBD,
23532   IX86_BUILTIN_PHSUBSW,
23533   IX86_BUILTIN_PMADDUBSW,
23534   IX86_BUILTIN_PMULHRSW,
23535   IX86_BUILTIN_PSHUFB,
23536   IX86_BUILTIN_PSIGNB,
23537   IX86_BUILTIN_PSIGNW,
23538   IX86_BUILTIN_PSIGND,
23539   IX86_BUILTIN_PALIGNR,
23540   IX86_BUILTIN_PABSB,
23541   IX86_BUILTIN_PABSW,
23542   IX86_BUILTIN_PABSD,
23543
23544   IX86_BUILTIN_PHADDW128,
23545   IX86_BUILTIN_PHADDD128,
23546   IX86_BUILTIN_PHADDSW128,
23547   IX86_BUILTIN_PHSUBW128,
23548   IX86_BUILTIN_PHSUBD128,
23549   IX86_BUILTIN_PHSUBSW128,
23550   IX86_BUILTIN_PMADDUBSW128,
23551   IX86_BUILTIN_PMULHRSW128,
23552   IX86_BUILTIN_PSHUFB128,
23553   IX86_BUILTIN_PSIGNB128,
23554   IX86_BUILTIN_PSIGNW128,
23555   IX86_BUILTIN_PSIGND128,
23556   IX86_BUILTIN_PALIGNR128,
23557   IX86_BUILTIN_PABSB128,
23558   IX86_BUILTIN_PABSW128,
23559   IX86_BUILTIN_PABSD128,
23560
23561   /* AMDFAM10 - SSE4A New Instructions.  */
23562   IX86_BUILTIN_MOVNTSD,
23563   IX86_BUILTIN_MOVNTSS,
23564   IX86_BUILTIN_EXTRQI,
23565   IX86_BUILTIN_EXTRQ,
23566   IX86_BUILTIN_INSERTQI,
23567   IX86_BUILTIN_INSERTQ,
23568
23569   /* SSE4.1.  */
23570   IX86_BUILTIN_BLENDPD,
23571   IX86_BUILTIN_BLENDPS,
23572   IX86_BUILTIN_BLENDVPD,
23573   IX86_BUILTIN_BLENDVPS,
23574   IX86_BUILTIN_PBLENDVB128,
23575   IX86_BUILTIN_PBLENDW128,
23576
23577   IX86_BUILTIN_DPPD,
23578   IX86_BUILTIN_DPPS,
23579
23580   IX86_BUILTIN_INSERTPS128,
23581
23582   IX86_BUILTIN_MOVNTDQA,
23583   IX86_BUILTIN_MPSADBW128,
23584   IX86_BUILTIN_PACKUSDW128,
23585   IX86_BUILTIN_PCMPEQQ,
23586   IX86_BUILTIN_PHMINPOSUW128,
23587
23588   IX86_BUILTIN_PMAXSB128,
23589   IX86_BUILTIN_PMAXSD128,
23590   IX86_BUILTIN_PMAXUD128,
23591   IX86_BUILTIN_PMAXUW128,
23592
23593   IX86_BUILTIN_PMINSB128,
23594   IX86_BUILTIN_PMINSD128,
23595   IX86_BUILTIN_PMINUD128,
23596   IX86_BUILTIN_PMINUW128,
23597
23598   IX86_BUILTIN_PMOVSXBW128,
23599   IX86_BUILTIN_PMOVSXBD128,
23600   IX86_BUILTIN_PMOVSXBQ128,
23601   IX86_BUILTIN_PMOVSXWD128,
23602   IX86_BUILTIN_PMOVSXWQ128,
23603   IX86_BUILTIN_PMOVSXDQ128,
23604
23605   IX86_BUILTIN_PMOVZXBW128,
23606   IX86_BUILTIN_PMOVZXBD128,
23607   IX86_BUILTIN_PMOVZXBQ128,
23608   IX86_BUILTIN_PMOVZXWD128,
23609   IX86_BUILTIN_PMOVZXWQ128,
23610   IX86_BUILTIN_PMOVZXDQ128,
23611
23612   IX86_BUILTIN_PMULDQ128,
23613   IX86_BUILTIN_PMULLD128,
23614
23615   IX86_BUILTIN_ROUNDPD,
23616   IX86_BUILTIN_ROUNDPS,
23617   IX86_BUILTIN_ROUNDSD,
23618   IX86_BUILTIN_ROUNDSS,
23619
23620   IX86_BUILTIN_FLOORPD,
23621   IX86_BUILTIN_CEILPD,
23622   IX86_BUILTIN_TRUNCPD,
23623   IX86_BUILTIN_RINTPD,
23624   IX86_BUILTIN_FLOORPS,
23625   IX86_BUILTIN_CEILPS,
23626   IX86_BUILTIN_TRUNCPS,
23627   IX86_BUILTIN_RINTPS,
23628
23629   IX86_BUILTIN_PTESTZ,
23630   IX86_BUILTIN_PTESTC,
23631   IX86_BUILTIN_PTESTNZC,
23632
23633   IX86_BUILTIN_VEC_INIT_V2SI,
23634   IX86_BUILTIN_VEC_INIT_V4HI,
23635   IX86_BUILTIN_VEC_INIT_V8QI,
23636   IX86_BUILTIN_VEC_EXT_V2DF,
23637   IX86_BUILTIN_VEC_EXT_V2DI,
23638   IX86_BUILTIN_VEC_EXT_V4SF,
23639   IX86_BUILTIN_VEC_EXT_V4SI,
23640   IX86_BUILTIN_VEC_EXT_V8HI,
23641   IX86_BUILTIN_VEC_EXT_V2SI,
23642   IX86_BUILTIN_VEC_EXT_V4HI,
23643   IX86_BUILTIN_VEC_EXT_V16QI,
23644   IX86_BUILTIN_VEC_SET_V2DI,
23645   IX86_BUILTIN_VEC_SET_V4SF,
23646   IX86_BUILTIN_VEC_SET_V4SI,
23647   IX86_BUILTIN_VEC_SET_V8HI,
23648   IX86_BUILTIN_VEC_SET_V4HI,
23649   IX86_BUILTIN_VEC_SET_V16QI,
23650
23651   IX86_BUILTIN_VEC_PACK_SFIX,
23652
23653   /* SSE4.2.  */
23654   IX86_BUILTIN_CRC32QI,
23655   IX86_BUILTIN_CRC32HI,
23656   IX86_BUILTIN_CRC32SI,
23657   IX86_BUILTIN_CRC32DI,
23658
23659   IX86_BUILTIN_PCMPESTRI128,
23660   IX86_BUILTIN_PCMPESTRM128,
23661   IX86_BUILTIN_PCMPESTRA128,
23662   IX86_BUILTIN_PCMPESTRC128,
23663   IX86_BUILTIN_PCMPESTRO128,
23664   IX86_BUILTIN_PCMPESTRS128,
23665   IX86_BUILTIN_PCMPESTRZ128,
23666   IX86_BUILTIN_PCMPISTRI128,
23667   IX86_BUILTIN_PCMPISTRM128,
23668   IX86_BUILTIN_PCMPISTRA128,
23669   IX86_BUILTIN_PCMPISTRC128,
23670   IX86_BUILTIN_PCMPISTRO128,
23671   IX86_BUILTIN_PCMPISTRS128,
23672   IX86_BUILTIN_PCMPISTRZ128,
23673
23674   IX86_BUILTIN_PCMPGTQ,
23675
23676   /* AES instructions */
23677   IX86_BUILTIN_AESENC128,
23678   IX86_BUILTIN_AESENCLAST128,
23679   IX86_BUILTIN_AESDEC128,
23680   IX86_BUILTIN_AESDECLAST128,
23681   IX86_BUILTIN_AESIMC128,
23682   IX86_BUILTIN_AESKEYGENASSIST128,
23683
23684   /* PCLMUL instruction */
23685   IX86_BUILTIN_PCLMULQDQ128,
23686
23687   /* AVX */
23688   IX86_BUILTIN_ADDPD256,
23689   IX86_BUILTIN_ADDPS256,
23690   IX86_BUILTIN_ADDSUBPD256,
23691   IX86_BUILTIN_ADDSUBPS256,
23692   IX86_BUILTIN_ANDPD256,
23693   IX86_BUILTIN_ANDPS256,
23694   IX86_BUILTIN_ANDNPD256,
23695   IX86_BUILTIN_ANDNPS256,
23696   IX86_BUILTIN_BLENDPD256,
23697   IX86_BUILTIN_BLENDPS256,
23698   IX86_BUILTIN_BLENDVPD256,
23699   IX86_BUILTIN_BLENDVPS256,
23700   IX86_BUILTIN_DIVPD256,
23701   IX86_BUILTIN_DIVPS256,
23702   IX86_BUILTIN_DPPS256,
23703   IX86_BUILTIN_HADDPD256,
23704   IX86_BUILTIN_HADDPS256,
23705   IX86_BUILTIN_HSUBPD256,
23706   IX86_BUILTIN_HSUBPS256,
23707   IX86_BUILTIN_MAXPD256,
23708   IX86_BUILTIN_MAXPS256,
23709   IX86_BUILTIN_MINPD256,
23710   IX86_BUILTIN_MINPS256,
23711   IX86_BUILTIN_MULPD256,
23712   IX86_BUILTIN_MULPS256,
23713   IX86_BUILTIN_ORPD256,
23714   IX86_BUILTIN_ORPS256,
23715   IX86_BUILTIN_SHUFPD256,
23716   IX86_BUILTIN_SHUFPS256,
23717   IX86_BUILTIN_SUBPD256,
23718   IX86_BUILTIN_SUBPS256,
23719   IX86_BUILTIN_XORPD256,
23720   IX86_BUILTIN_XORPS256,
23721   IX86_BUILTIN_CMPSD,
23722   IX86_BUILTIN_CMPSS,
23723   IX86_BUILTIN_CMPPD,
23724   IX86_BUILTIN_CMPPS,
23725   IX86_BUILTIN_CMPPD256,
23726   IX86_BUILTIN_CMPPS256,
23727   IX86_BUILTIN_CVTDQ2PD256,
23728   IX86_BUILTIN_CVTDQ2PS256,
23729   IX86_BUILTIN_CVTPD2PS256,
23730   IX86_BUILTIN_CVTPS2DQ256,
23731   IX86_BUILTIN_CVTPS2PD256,
23732   IX86_BUILTIN_CVTTPD2DQ256,
23733   IX86_BUILTIN_CVTPD2DQ256,
23734   IX86_BUILTIN_CVTTPS2DQ256,
23735   IX86_BUILTIN_EXTRACTF128PD256,
23736   IX86_BUILTIN_EXTRACTF128PS256,
23737   IX86_BUILTIN_EXTRACTF128SI256,
23738   IX86_BUILTIN_VZEROALL,
23739   IX86_BUILTIN_VZEROUPPER,
23740   IX86_BUILTIN_VPERMILVARPD,
23741   IX86_BUILTIN_VPERMILVARPS,
23742   IX86_BUILTIN_VPERMILVARPD256,
23743   IX86_BUILTIN_VPERMILVARPS256,
23744   IX86_BUILTIN_VPERMILPD,
23745   IX86_BUILTIN_VPERMILPS,
23746   IX86_BUILTIN_VPERMILPD256,
23747   IX86_BUILTIN_VPERMILPS256,
23748   IX86_BUILTIN_VPERMIL2PD,
23749   IX86_BUILTIN_VPERMIL2PS,
23750   IX86_BUILTIN_VPERMIL2PD256,
23751   IX86_BUILTIN_VPERMIL2PS256,
23752   IX86_BUILTIN_VPERM2F128PD256,
23753   IX86_BUILTIN_VPERM2F128PS256,
23754   IX86_BUILTIN_VPERM2F128SI256,
23755   IX86_BUILTIN_VBROADCASTSS,
23756   IX86_BUILTIN_VBROADCASTSD256,
23757   IX86_BUILTIN_VBROADCASTSS256,
23758   IX86_BUILTIN_VBROADCASTPD256,
23759   IX86_BUILTIN_VBROADCASTPS256,
23760   IX86_BUILTIN_VINSERTF128PD256,
23761   IX86_BUILTIN_VINSERTF128PS256,
23762   IX86_BUILTIN_VINSERTF128SI256,
23763   IX86_BUILTIN_LOADUPD256,
23764   IX86_BUILTIN_LOADUPS256,
23765   IX86_BUILTIN_STOREUPD256,
23766   IX86_BUILTIN_STOREUPS256,
23767   IX86_BUILTIN_LDDQU256,
23768   IX86_BUILTIN_MOVNTDQ256,
23769   IX86_BUILTIN_MOVNTPD256,
23770   IX86_BUILTIN_MOVNTPS256,
23771   IX86_BUILTIN_LOADDQU256,
23772   IX86_BUILTIN_STOREDQU256,
23773   IX86_BUILTIN_MASKLOADPD,
23774   IX86_BUILTIN_MASKLOADPS,
23775   IX86_BUILTIN_MASKSTOREPD,
23776   IX86_BUILTIN_MASKSTOREPS,
23777   IX86_BUILTIN_MASKLOADPD256,
23778   IX86_BUILTIN_MASKLOADPS256,
23779   IX86_BUILTIN_MASKSTOREPD256,
23780   IX86_BUILTIN_MASKSTOREPS256,
23781   IX86_BUILTIN_MOVSHDUP256,
23782   IX86_BUILTIN_MOVSLDUP256,
23783   IX86_BUILTIN_MOVDDUP256,
23784
23785   IX86_BUILTIN_SQRTPD256,
23786   IX86_BUILTIN_SQRTPS256,
23787   IX86_BUILTIN_SQRTPS_NR256,
23788   IX86_BUILTIN_RSQRTPS256,
23789   IX86_BUILTIN_RSQRTPS_NR256,
23790
23791   IX86_BUILTIN_RCPPS256,
23792
23793   IX86_BUILTIN_ROUNDPD256,
23794   IX86_BUILTIN_ROUNDPS256,
23795
23796   IX86_BUILTIN_FLOORPD256,
23797   IX86_BUILTIN_CEILPD256,
23798   IX86_BUILTIN_TRUNCPD256,
23799   IX86_BUILTIN_RINTPD256,
23800   IX86_BUILTIN_FLOORPS256,
23801   IX86_BUILTIN_CEILPS256,
23802   IX86_BUILTIN_TRUNCPS256,
23803   IX86_BUILTIN_RINTPS256,
23804
23805   IX86_BUILTIN_UNPCKHPD256,
23806   IX86_BUILTIN_UNPCKLPD256,
23807   IX86_BUILTIN_UNPCKHPS256,
23808   IX86_BUILTIN_UNPCKLPS256,
23809
23810   IX86_BUILTIN_SI256_SI,
23811   IX86_BUILTIN_PS256_PS,
23812   IX86_BUILTIN_PD256_PD,
23813   IX86_BUILTIN_SI_SI256,
23814   IX86_BUILTIN_PS_PS256,
23815   IX86_BUILTIN_PD_PD256,
23816
23817   IX86_BUILTIN_VTESTZPD,
23818   IX86_BUILTIN_VTESTCPD,
23819   IX86_BUILTIN_VTESTNZCPD,
23820   IX86_BUILTIN_VTESTZPS,
23821   IX86_BUILTIN_VTESTCPS,
23822   IX86_BUILTIN_VTESTNZCPS,
23823   IX86_BUILTIN_VTESTZPD256,
23824   IX86_BUILTIN_VTESTCPD256,
23825   IX86_BUILTIN_VTESTNZCPD256,
23826   IX86_BUILTIN_VTESTZPS256,
23827   IX86_BUILTIN_VTESTCPS256,
23828   IX86_BUILTIN_VTESTNZCPS256,
23829   IX86_BUILTIN_PTESTZ256,
23830   IX86_BUILTIN_PTESTC256,
23831   IX86_BUILTIN_PTESTNZC256,
23832
23833   IX86_BUILTIN_MOVMSKPD256,
23834   IX86_BUILTIN_MOVMSKPS256,
23835
23836   /* TFmode support builtins.  */
23837   IX86_BUILTIN_INFQ,
23838   IX86_BUILTIN_HUGE_VALQ,
23839   IX86_BUILTIN_FABSQ,
23840   IX86_BUILTIN_COPYSIGNQ,
23841
23842   /* Vectorizer support builtins.  */
23843   IX86_BUILTIN_CPYSGNPS,
23844   IX86_BUILTIN_CPYSGNPD,
23845   IX86_BUILTIN_CPYSGNPS256,
23846   IX86_BUILTIN_CPYSGNPD256,
23847
23848   IX86_BUILTIN_CVTUDQ2PS,
23849
23850   IX86_BUILTIN_VEC_PERM_V2DF,
23851   IX86_BUILTIN_VEC_PERM_V4SF,
23852   IX86_BUILTIN_VEC_PERM_V2DI,
23853   IX86_BUILTIN_VEC_PERM_V4SI,
23854   IX86_BUILTIN_VEC_PERM_V8HI,
23855   IX86_BUILTIN_VEC_PERM_V16QI,
23856   IX86_BUILTIN_VEC_PERM_V2DI_U,
23857   IX86_BUILTIN_VEC_PERM_V4SI_U,
23858   IX86_BUILTIN_VEC_PERM_V8HI_U,
23859   IX86_BUILTIN_VEC_PERM_V16QI_U,
23860   IX86_BUILTIN_VEC_PERM_V4DF,
23861   IX86_BUILTIN_VEC_PERM_V8SF,
23862
23863   /* FMA4 and XOP instructions.  */
23864   IX86_BUILTIN_VFMADDSS,
23865   IX86_BUILTIN_VFMADDSD,
23866   IX86_BUILTIN_VFMADDPS,
23867   IX86_BUILTIN_VFMADDPD,
23868   IX86_BUILTIN_VFMADDPS256,
23869   IX86_BUILTIN_VFMADDPD256,
23870   IX86_BUILTIN_VFMADDSUBPS,
23871   IX86_BUILTIN_VFMADDSUBPD,
23872   IX86_BUILTIN_VFMADDSUBPS256,
23873   IX86_BUILTIN_VFMADDSUBPD256,
23874
23875   IX86_BUILTIN_VPCMOV,
23876   IX86_BUILTIN_VPCMOV_V2DI,
23877   IX86_BUILTIN_VPCMOV_V4SI,
23878   IX86_BUILTIN_VPCMOV_V8HI,
23879   IX86_BUILTIN_VPCMOV_V16QI,
23880   IX86_BUILTIN_VPCMOV_V4SF,
23881   IX86_BUILTIN_VPCMOV_V2DF,
23882   IX86_BUILTIN_VPCMOV256,
23883   IX86_BUILTIN_VPCMOV_V4DI256,
23884   IX86_BUILTIN_VPCMOV_V8SI256,
23885   IX86_BUILTIN_VPCMOV_V16HI256,
23886   IX86_BUILTIN_VPCMOV_V32QI256,
23887   IX86_BUILTIN_VPCMOV_V8SF256,
23888   IX86_BUILTIN_VPCMOV_V4DF256,
23889
23890   IX86_BUILTIN_VPPERM,
23891
23892   IX86_BUILTIN_VPMACSSWW,
23893   IX86_BUILTIN_VPMACSWW,
23894   IX86_BUILTIN_VPMACSSWD,
23895   IX86_BUILTIN_VPMACSWD,
23896   IX86_BUILTIN_VPMACSSDD,
23897   IX86_BUILTIN_VPMACSDD,
23898   IX86_BUILTIN_VPMACSSDQL,
23899   IX86_BUILTIN_VPMACSSDQH,
23900   IX86_BUILTIN_VPMACSDQL,
23901   IX86_BUILTIN_VPMACSDQH,
23902   IX86_BUILTIN_VPMADCSSWD,
23903   IX86_BUILTIN_VPMADCSWD,
23904
23905   IX86_BUILTIN_VPHADDBW,
23906   IX86_BUILTIN_VPHADDBD,
23907   IX86_BUILTIN_VPHADDBQ,
23908   IX86_BUILTIN_VPHADDWD,
23909   IX86_BUILTIN_VPHADDWQ,
23910   IX86_BUILTIN_VPHADDDQ,
23911   IX86_BUILTIN_VPHADDUBW,
23912   IX86_BUILTIN_VPHADDUBD,
23913   IX86_BUILTIN_VPHADDUBQ,
23914   IX86_BUILTIN_VPHADDUWD,
23915   IX86_BUILTIN_VPHADDUWQ,
23916   IX86_BUILTIN_VPHADDUDQ,
23917   IX86_BUILTIN_VPHSUBBW,
23918   IX86_BUILTIN_VPHSUBWD,
23919   IX86_BUILTIN_VPHSUBDQ,
23920
23921   IX86_BUILTIN_VPROTB,
23922   IX86_BUILTIN_VPROTW,
23923   IX86_BUILTIN_VPROTD,
23924   IX86_BUILTIN_VPROTQ,
23925   IX86_BUILTIN_VPROTB_IMM,
23926   IX86_BUILTIN_VPROTW_IMM,
23927   IX86_BUILTIN_VPROTD_IMM,
23928   IX86_BUILTIN_VPROTQ_IMM,
23929
23930   IX86_BUILTIN_VPSHLB,
23931   IX86_BUILTIN_VPSHLW,
23932   IX86_BUILTIN_VPSHLD,
23933   IX86_BUILTIN_VPSHLQ,
23934   IX86_BUILTIN_VPSHAB,
23935   IX86_BUILTIN_VPSHAW,
23936   IX86_BUILTIN_VPSHAD,
23937   IX86_BUILTIN_VPSHAQ,
23938
23939   IX86_BUILTIN_VFRCZSS,
23940   IX86_BUILTIN_VFRCZSD,
23941   IX86_BUILTIN_VFRCZPS,
23942   IX86_BUILTIN_VFRCZPD,
23943   IX86_BUILTIN_VFRCZPS256,
23944   IX86_BUILTIN_VFRCZPD256,
23945
23946   IX86_BUILTIN_VPCOMEQUB,
23947   IX86_BUILTIN_VPCOMNEUB,
23948   IX86_BUILTIN_VPCOMLTUB,
23949   IX86_BUILTIN_VPCOMLEUB,
23950   IX86_BUILTIN_VPCOMGTUB,
23951   IX86_BUILTIN_VPCOMGEUB,
23952   IX86_BUILTIN_VPCOMFALSEUB,
23953   IX86_BUILTIN_VPCOMTRUEUB,
23954
23955   IX86_BUILTIN_VPCOMEQUW,
23956   IX86_BUILTIN_VPCOMNEUW,
23957   IX86_BUILTIN_VPCOMLTUW,
23958   IX86_BUILTIN_VPCOMLEUW,
23959   IX86_BUILTIN_VPCOMGTUW,
23960   IX86_BUILTIN_VPCOMGEUW,
23961   IX86_BUILTIN_VPCOMFALSEUW,
23962   IX86_BUILTIN_VPCOMTRUEUW,
23963
23964   IX86_BUILTIN_VPCOMEQUD,
23965   IX86_BUILTIN_VPCOMNEUD,
23966   IX86_BUILTIN_VPCOMLTUD,
23967   IX86_BUILTIN_VPCOMLEUD,
23968   IX86_BUILTIN_VPCOMGTUD,
23969   IX86_BUILTIN_VPCOMGEUD,
23970   IX86_BUILTIN_VPCOMFALSEUD,
23971   IX86_BUILTIN_VPCOMTRUEUD,
23972
23973   IX86_BUILTIN_VPCOMEQUQ,
23974   IX86_BUILTIN_VPCOMNEUQ,
23975   IX86_BUILTIN_VPCOMLTUQ,
23976   IX86_BUILTIN_VPCOMLEUQ,
23977   IX86_BUILTIN_VPCOMGTUQ,
23978   IX86_BUILTIN_VPCOMGEUQ,
23979   IX86_BUILTIN_VPCOMFALSEUQ,
23980   IX86_BUILTIN_VPCOMTRUEUQ,
23981
23982   IX86_BUILTIN_VPCOMEQB,
23983   IX86_BUILTIN_VPCOMNEB,
23984   IX86_BUILTIN_VPCOMLTB,
23985   IX86_BUILTIN_VPCOMLEB,
23986   IX86_BUILTIN_VPCOMGTB,
23987   IX86_BUILTIN_VPCOMGEB,
23988   IX86_BUILTIN_VPCOMFALSEB,
23989   IX86_BUILTIN_VPCOMTRUEB,
23990
23991   IX86_BUILTIN_VPCOMEQW,
23992   IX86_BUILTIN_VPCOMNEW,
23993   IX86_BUILTIN_VPCOMLTW,
23994   IX86_BUILTIN_VPCOMLEW,
23995   IX86_BUILTIN_VPCOMGTW,
23996   IX86_BUILTIN_VPCOMGEW,
23997   IX86_BUILTIN_VPCOMFALSEW,
23998   IX86_BUILTIN_VPCOMTRUEW,
23999
24000   IX86_BUILTIN_VPCOMEQD,
24001   IX86_BUILTIN_VPCOMNED,
24002   IX86_BUILTIN_VPCOMLTD,
24003   IX86_BUILTIN_VPCOMLED,
24004   IX86_BUILTIN_VPCOMGTD,
24005   IX86_BUILTIN_VPCOMGED,
24006   IX86_BUILTIN_VPCOMFALSED,
24007   IX86_BUILTIN_VPCOMTRUED,
24008
24009   IX86_BUILTIN_VPCOMEQQ,
24010   IX86_BUILTIN_VPCOMNEQ,
24011   IX86_BUILTIN_VPCOMLTQ,
24012   IX86_BUILTIN_VPCOMLEQ,
24013   IX86_BUILTIN_VPCOMGTQ,
24014   IX86_BUILTIN_VPCOMGEQ,
24015   IX86_BUILTIN_VPCOMFALSEQ,
24016   IX86_BUILTIN_VPCOMTRUEQ,
24017
24018   /* LWP instructions.  */
24019   IX86_BUILTIN_LLWPCB,
24020   IX86_BUILTIN_SLWPCB,
24021   IX86_BUILTIN_LWPVAL32,
24022   IX86_BUILTIN_LWPVAL64,
24023   IX86_BUILTIN_LWPINS32,
24024   IX86_BUILTIN_LWPINS64,
24025
24026   IX86_BUILTIN_CLZS,
24027
24028   /* BMI instructions.  */
24029   IX86_BUILTIN_BEXTR32,
24030   IX86_BUILTIN_BEXTR64,
24031   IX86_BUILTIN_CTZS,
24032
24033   /* TBM instructions.  */
24034   IX86_BUILTIN_BEXTRI32,
24035   IX86_BUILTIN_BEXTRI64,
24036
24037
24038   /* FSGSBASE instructions.  */
24039   IX86_BUILTIN_RDFSBASE32,
24040   IX86_BUILTIN_RDFSBASE64,
24041   IX86_BUILTIN_RDGSBASE32,
24042   IX86_BUILTIN_RDGSBASE64,
24043   IX86_BUILTIN_WRFSBASE32,
24044   IX86_BUILTIN_WRFSBASE64,
24045   IX86_BUILTIN_WRGSBASE32,
24046   IX86_BUILTIN_WRGSBASE64,
24047
24048   /* RDRND instructions.  */
24049   IX86_BUILTIN_RDRAND16_STEP,
24050   IX86_BUILTIN_RDRAND32_STEP,
24051   IX86_BUILTIN_RDRAND64_STEP,
24052
24053   /* F16C instructions.  */
24054   IX86_BUILTIN_CVTPH2PS,
24055   IX86_BUILTIN_CVTPH2PS256,
24056   IX86_BUILTIN_CVTPS2PH,
24057   IX86_BUILTIN_CVTPS2PH256,
24058
24059   /* CFString built-in for darwin */
24060   IX86_BUILTIN_CFSTRING,
24061
24062   IX86_BUILTIN_MAX
24063 };
24064
24065 /* Table for the ix86 builtin decls.  */
24066 static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX];
24067
24068 /* Table of all of the builtin functions that are possible with different ISA's
24069    but are waiting to be built until a function is declared to use that
24070    ISA.  */
24071 struct builtin_isa {
24072   const char *name;             /* function name */
24073   enum ix86_builtin_func_type tcode; /* type to use in the declaration */
24074   int isa;                      /* isa_flags this builtin is defined for */
24075   bool const_p;                 /* true if the declaration is constant */
24076   bool set_and_not_built_p;
24077 };
24078
24079 static struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX];
24080
24081
24082 /* Add an ix86 target builtin function with CODE, NAME and TYPE.  Save the MASK
24083    of which isa_flags to use in the ix86_builtins_isa array.  Stores the
24084    function decl in the ix86_builtins array.  Returns the function decl or
24085    NULL_TREE, if the builtin was not added.
24086
24087    If the front end has a special hook for builtin functions, delay adding
24088    builtin functions that aren't in the current ISA until the ISA is changed
24089    with function specific optimization.  Doing so, can save about 300K for the
24090    default compiler.  When the builtin is expanded, check at that time whether
24091    it is valid.
24092
24093    If the front end doesn't have a special hook, record all builtins, even if
24094    it isn't an instruction set in the current ISA in case the user uses
24095    function specific options for a different ISA, so that we don't get scope
24096    errors if a builtin is added in the middle of a function scope.  */
24097
24098 static inline tree
24099 def_builtin (int mask, const char *name, enum ix86_builtin_func_type tcode,
24100              enum ix86_builtins code)
24101 {
24102   tree decl = NULL_TREE;
24103
24104   if (!(mask & OPTION_MASK_ISA_64BIT) || TARGET_64BIT)
24105     {
24106       ix86_builtins_isa[(int) code].isa = mask;
24107
24108       mask &= ~OPTION_MASK_ISA_64BIT;
24109       if (mask == 0
24110           || (mask & ix86_isa_flags) != 0
24111           || (lang_hooks.builtin_function
24112               == lang_hooks.builtin_function_ext_scope))
24113
24114         {
24115           tree type = ix86_get_builtin_func_type (tcode);
24116           decl = add_builtin_function (name, type, code, BUILT_IN_MD,
24117                                        NULL, NULL_TREE);
24118           ix86_builtins[(int) code] = decl;
24119           ix86_builtins_isa[(int) code].set_and_not_built_p = false;
24120         }
24121       else
24122         {
24123           ix86_builtins[(int) code] = NULL_TREE;
24124           ix86_builtins_isa[(int) code].tcode = tcode;
24125           ix86_builtins_isa[(int) code].name = name;
24126           ix86_builtins_isa[(int) code].const_p = false;
24127           ix86_builtins_isa[(int) code].set_and_not_built_p = true;
24128         }
24129     }
24130
24131   return decl;
24132 }
24133
24134 /* Like def_builtin, but also marks the function decl "const".  */
24135
24136 static inline tree
24137 def_builtin_const (int mask, const char *name,
24138                    enum ix86_builtin_func_type tcode, enum ix86_builtins code)
24139 {
24140   tree decl = def_builtin (mask, name, tcode, code);
24141   if (decl)
24142     TREE_READONLY (decl) = 1;
24143   else
24144     ix86_builtins_isa[(int) code].const_p = true;
24145
24146   return decl;
24147 }
24148
24149 /* Add any new builtin functions for a given ISA that may not have been
24150    declared.  This saves a bit of space compared to adding all of the
24151    declarations to the tree, even if we didn't use them.  */
24152
24153 static void
24154 ix86_add_new_builtins (int isa)
24155 {
24156   int i;
24157
24158   for (i = 0; i < (int)IX86_BUILTIN_MAX; i++)
24159     {
24160       if ((ix86_builtins_isa[i].isa & isa) != 0
24161           && ix86_builtins_isa[i].set_and_not_built_p)
24162         {
24163           tree decl, type;
24164
24165           /* Don't define the builtin again.  */
24166           ix86_builtins_isa[i].set_and_not_built_p = false;
24167
24168           type = ix86_get_builtin_func_type (ix86_builtins_isa[i].tcode);
24169           decl = add_builtin_function_ext_scope (ix86_builtins_isa[i].name,
24170                                                  type, i, BUILT_IN_MD, NULL,
24171                                                  NULL_TREE);
24172
24173           ix86_builtins[i] = decl;
24174           if (ix86_builtins_isa[i].const_p)
24175             TREE_READONLY (decl) = 1;
24176         }
24177     }
24178 }
24179
24180 /* Bits for builtin_description.flag.  */
24181
24182 /* Set when we don't support the comparison natively, and should
24183    swap_comparison in order to support it.  */
24184 #define BUILTIN_DESC_SWAP_OPERANDS      1
24185
24186 struct builtin_description
24187 {
24188   const unsigned int mask;
24189   const enum insn_code icode;
24190   const char *const name;
24191   const enum ix86_builtins code;
24192   const enum rtx_code comparison;
24193   const int flag;
24194 };
24195
24196 static const struct builtin_description bdesc_comi[] =
24197 {
24198   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comieq", IX86_BUILTIN_COMIEQSS, UNEQ, 0 },
24199   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comilt", IX86_BUILTIN_COMILTSS, UNLT, 0 },
24200   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comile", IX86_BUILTIN_COMILESS, UNLE, 0 },
24201   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comigt", IX86_BUILTIN_COMIGTSS, GT, 0 },
24202   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comige", IX86_BUILTIN_COMIGESS, GE, 0 },
24203   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comineq", IX86_BUILTIN_COMINEQSS, LTGT, 0 },
24204   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomieq", IX86_BUILTIN_UCOMIEQSS, UNEQ, 0 },
24205   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomilt", IX86_BUILTIN_UCOMILTSS, UNLT, 0 },
24206   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomile", IX86_BUILTIN_UCOMILESS, UNLE, 0 },
24207   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomigt", IX86_BUILTIN_UCOMIGTSS, GT, 0 },
24208   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomige", IX86_BUILTIN_UCOMIGESS, GE, 0 },
24209   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomineq", IX86_BUILTIN_UCOMINEQSS, LTGT, 0 },
24210   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdeq", IX86_BUILTIN_COMIEQSD, UNEQ, 0 },
24211   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdlt", IX86_BUILTIN_COMILTSD, UNLT, 0 },
24212   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdle", IX86_BUILTIN_COMILESD, UNLE, 0 },
24213   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdgt", IX86_BUILTIN_COMIGTSD, GT, 0 },
24214   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdge", IX86_BUILTIN_COMIGESD, GE, 0 },
24215   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdneq", IX86_BUILTIN_COMINEQSD, LTGT, 0 },
24216   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdeq", IX86_BUILTIN_UCOMIEQSD, UNEQ, 0 },
24217   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdlt", IX86_BUILTIN_UCOMILTSD, UNLT, 0 },
24218   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdle", IX86_BUILTIN_UCOMILESD, UNLE, 0 },
24219   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdgt", IX86_BUILTIN_UCOMIGTSD, GT, 0 },
24220   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdge", IX86_BUILTIN_UCOMIGESD, GE, 0 },
24221   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdneq", IX86_BUILTIN_UCOMINEQSD, LTGT, 0 },
24222 };
24223
24224 static const struct builtin_description bdesc_pcmpestr[] =
24225 {
24226   /* SSE4.2 */
24227   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestri128", IX86_BUILTIN_PCMPESTRI128, UNKNOWN, 0 },
24228   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrm128", IX86_BUILTIN_PCMPESTRM128, UNKNOWN, 0 },
24229   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestria128", IX86_BUILTIN_PCMPESTRA128, UNKNOWN, (int) CCAmode },
24230   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestric128", IX86_BUILTIN_PCMPESTRC128, UNKNOWN, (int) CCCmode },
24231   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrio128", IX86_BUILTIN_PCMPESTRO128, UNKNOWN, (int) CCOmode },
24232   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestris128", IX86_BUILTIN_PCMPESTRS128, UNKNOWN, (int) CCSmode },
24233   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestriz128", IX86_BUILTIN_PCMPESTRZ128, UNKNOWN, (int) CCZmode },
24234 };
24235
24236 static const struct builtin_description bdesc_pcmpistr[] =
24237 {
24238   /* SSE4.2 */
24239   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistri128", IX86_BUILTIN_PCMPISTRI128, UNKNOWN, 0 },
24240   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrm128", IX86_BUILTIN_PCMPISTRM128, UNKNOWN, 0 },
24241   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistria128", IX86_BUILTIN_PCMPISTRA128, UNKNOWN, (int) CCAmode },
24242   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistric128", IX86_BUILTIN_PCMPISTRC128, UNKNOWN, (int) CCCmode },
24243   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrio128", IX86_BUILTIN_PCMPISTRO128, UNKNOWN, (int) CCOmode },
24244   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistris128", IX86_BUILTIN_PCMPISTRS128, UNKNOWN, (int) CCSmode },
24245   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistriz128", IX86_BUILTIN_PCMPISTRZ128, UNKNOWN, (int) CCZmode },
24246 };
24247
24248 /* Special builtins with variable number of arguments.  */
24249 static const struct builtin_description bdesc_special_args[] =
24250 {
24251   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtsc, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID },
24252   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtscp, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED },
24253   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID },
24254
24255   /* MMX */
24256   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_emms, "__builtin_ia32_emms", IX86_BUILTIN_EMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
24257
24258   /* 3DNow! */
24259   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_femms, "__builtin_ia32_femms", IX86_BUILTIN_FEMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
24260
24261   /* SSE */
24262   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_storeups", IX86_BUILTIN_STOREUPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24263   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movntv4sf, "__builtin_ia32_movntps", IX86_BUILTIN_MOVNTPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24264   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_loadups", IX86_BUILTIN_LOADUPS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
24265
24266   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadhps_exp, "__builtin_ia32_loadhps", IX86_BUILTIN_LOADHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
24267   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadlps_exp, "__builtin_ia32_loadlps", IX86_BUILTIN_LOADLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
24268   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storehps, "__builtin_ia32_storehps", IX86_BUILTIN_STOREHPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
24269   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storelps, "__builtin_ia32_storelps", IX86_BUILTIN_STORELPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
24270
24271   /* SSE or 3DNow!A  */
24272   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_sfence, "__builtin_ia32_sfence", IX86_BUILTIN_SFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24273   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_movntdi, "__builtin_ia32_movntq", IX86_BUILTIN_MOVNTQ, UNKNOWN, (int) VOID_FTYPE_PULONGLONG_ULONGLONG },
24274
24275   /* SSE2 */
24276   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lfence, "__builtin_ia32_lfence", IX86_BUILTIN_LFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24277   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_mfence, 0, IX86_BUILTIN_MFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
24278   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_storeupd", IX86_BUILTIN_STOREUPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24279   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_storedqu", IX86_BUILTIN_STOREDQU, UNKNOWN, (int) VOID_FTYPE_PCHAR_V16QI },
24280   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2df, "__builtin_ia32_movntpd", IX86_BUILTIN_MOVNTPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24281   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2di, "__builtin_ia32_movntdq", IX86_BUILTIN_MOVNTDQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI },
24282   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntsi, "__builtin_ia32_movnti", IX86_BUILTIN_MOVNTI, UNKNOWN, (int) VOID_FTYPE_PINT_INT },
24283   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_loadupd", IX86_BUILTIN_LOADUPD, UNKNOWN, (int) V2DF_FTYPE_PCDOUBLE },
24284   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_loaddqu", IX86_BUILTIN_LOADDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
24285
24286   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadhpd_exp, "__builtin_ia32_loadhpd", IX86_BUILTIN_LOADHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
24287   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadlpd_exp, "__builtin_ia32_loadlpd", IX86_BUILTIN_LOADLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
24288
24289   /* SSE3 */
24290   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_lddqu, "__builtin_ia32_lddqu", IX86_BUILTIN_LDDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
24291
24292   /* SSE4.1 */
24293   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_movntdqa, "__builtin_ia32_movntdqa", IX86_BUILTIN_MOVNTDQA, UNKNOWN, (int) V2DI_FTYPE_PV2DI },
24294
24295   /* SSE4A */
24296   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv2df, "__builtin_ia32_movntsd", IX86_BUILTIN_MOVNTSD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
24297   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv4sf, "__builtin_ia32_movntss", IX86_BUILTIN_MOVNTSS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
24298
24299   /* AVX */
24300   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroall, "__builtin_ia32_vzeroall", IX86_BUILTIN_VZEROALL, UNKNOWN, (int) VOID_FTYPE_VOID },
24301   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroupper, "__builtin_ia32_vzeroupper", IX86_BUILTIN_VZEROUPPER, UNKNOWN, (int) VOID_FTYPE_VOID },
24302
24303   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4sf, "__builtin_ia32_vbroadcastss", IX86_BUILTIN_VBROADCASTSS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
24304   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4df, "__builtin_ia32_vbroadcastsd256", IX86_BUILTIN_VBROADCASTSD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
24305   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv8sf, "__builtin_ia32_vbroadcastss256", IX86_BUILTIN_VBROADCASTSS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
24306   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v4df, "__builtin_ia32_vbroadcastf128_pd256", IX86_BUILTIN_VBROADCASTPD256, UNKNOWN, (int) V4DF_FTYPE_PCV2DF },
24307   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v8sf, "__builtin_ia32_vbroadcastf128_ps256", IX86_BUILTIN_VBROADCASTPS256, UNKNOWN, (int) V8SF_FTYPE_PCV4SF },
24308
24309   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_loadupd256", IX86_BUILTIN_LOADUPD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
24310   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_loadups256", IX86_BUILTIN_LOADUPS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
24311   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_storeupd256", IX86_BUILTIN_STOREUPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
24312   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_storeups256", IX86_BUILTIN_STOREUPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
24313   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_loaddqu256", IX86_BUILTIN_LOADDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
24314   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_storedqu256", IX86_BUILTIN_STOREDQU256, UNKNOWN, (int) VOID_FTYPE_PCHAR_V32QI },
24315   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_lddqu256, "__builtin_ia32_lddqu256", IX86_BUILTIN_LDDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
24316
24317   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4di, "__builtin_ia32_movntdq256", IX86_BUILTIN_MOVNTDQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI },
24318   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4df, "__builtin_ia32_movntpd256", IX86_BUILTIN_MOVNTPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
24319   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv8sf, "__builtin_ia32_movntps256", IX86_BUILTIN_MOVNTPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
24320
24321   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd, "__builtin_ia32_maskloadpd", IX86_BUILTIN_MASKLOADPD, UNKNOWN, (int) V2DF_FTYPE_PCV2DF_V2DI },
24322   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps, "__builtin_ia32_maskloadps", IX86_BUILTIN_MASKLOADPS, UNKNOWN, (int) V4SF_FTYPE_PCV4SF_V4SI },
24323   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd256, "__builtin_ia32_maskloadpd256", IX86_BUILTIN_MASKLOADPD256, UNKNOWN, (int) V4DF_FTYPE_PCV4DF_V4DI },
24324   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps256, "__builtin_ia32_maskloadps256", IX86_BUILTIN_MASKLOADPS256, UNKNOWN, (int) V8SF_FTYPE_PCV8SF_V8SI },
24325   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd, "__builtin_ia32_maskstorepd", IX86_BUILTIN_MASKSTOREPD, UNKNOWN, (int) VOID_FTYPE_PV2DF_V2DI_V2DF },
24326   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps, "__builtin_ia32_maskstoreps", IX86_BUILTIN_MASKSTOREPS, UNKNOWN, (int) VOID_FTYPE_PV4SF_V4SI_V4SF },
24327   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd256, "__builtin_ia32_maskstorepd256", IX86_BUILTIN_MASKSTOREPD256, UNKNOWN, (int) VOID_FTYPE_PV4DF_V4DI_V4DF },
24328   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps256, "__builtin_ia32_maskstoreps256", IX86_BUILTIN_MASKSTOREPS256, UNKNOWN, (int) VOID_FTYPE_PV8SF_V8SI_V8SF },
24329
24330   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_llwpcb, "__builtin_ia32_llwpcb", IX86_BUILTIN_LLWPCB, UNKNOWN, (int) VOID_FTYPE_PVOID },
24331   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_slwpcb, "__builtin_ia32_slwpcb", IX86_BUILTIN_SLWPCB, UNKNOWN, (int) PVOID_FTYPE_VOID },
24332   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvalsi3, "__builtin_ia32_lwpval32", IX86_BUILTIN_LWPVAL32, UNKNOWN, (int) VOID_FTYPE_UINT_UINT_UINT },
24333   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvaldi3, "__builtin_ia32_lwpval64", IX86_BUILTIN_LWPVAL64, UNKNOWN, (int) VOID_FTYPE_UINT64_UINT_UINT },
24334   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinssi3, "__builtin_ia32_lwpins32", IX86_BUILTIN_LWPINS32, UNKNOWN, (int) UCHAR_FTYPE_UINT_UINT_UINT },
24335   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinsdi3, "__builtin_ia32_lwpins64", IX86_BUILTIN_LWPINS64, UNKNOWN, (int) UCHAR_FTYPE_UINT64_UINT_UINT },
24336
24337   /* FSGSBASE */
24338   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasesi, "__builtin_ia32_rdfsbase32", IX86_BUILTIN_RDFSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
24339   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasedi, "__builtin_ia32_rdfsbase64", IX86_BUILTIN_RDFSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
24340   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasesi, "__builtin_ia32_rdgsbase32", IX86_BUILTIN_RDGSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
24341   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasedi, "__builtin_ia32_rdgsbase64", IX86_BUILTIN_RDGSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
24342   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasesi, "__builtin_ia32_wrfsbase32", IX86_BUILTIN_WRFSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
24343   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasedi, "__builtin_ia32_wrfsbase64", IX86_BUILTIN_WRFSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
24344   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasesi, "__builtin_ia32_wrgsbase32", IX86_BUILTIN_WRGSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
24345   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasedi, "__builtin_ia32_wrgsbase64", IX86_BUILTIN_WRGSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
24346 };
24347
24348 /* Builtins with variable number of arguments.  */
24349 static const struct builtin_description bdesc_args[] =
24350 {
24351   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT },
24352   { OPTION_MASK_ISA_64BIT, CODE_FOR_bsr_rex64, "__builtin_ia32_bsrdi", IX86_BUILTIN_BSRDI, UNKNOWN, (int) INT64_FTYPE_INT64 },
24353   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdpmc, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT },
24354   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
24355   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
24356   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
24357   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
24358
24359   /* MMX */
24360   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv8qi3, "__builtin_ia32_paddb", IX86_BUILTIN_PADDB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24361   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv4hi3, "__builtin_ia32_paddw", IX86_BUILTIN_PADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24362   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv2si3, "__builtin_ia32_paddd", IX86_BUILTIN_PADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24363   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv8qi3, "__builtin_ia32_psubb", IX86_BUILTIN_PSUBB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24364   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv4hi3, "__builtin_ia32_psubw", IX86_BUILTIN_PSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24365   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv2si3, "__builtin_ia32_psubd", IX86_BUILTIN_PSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24366
24367   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv8qi3, "__builtin_ia32_paddsb", IX86_BUILTIN_PADDSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24368   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv4hi3, "__builtin_ia32_paddsw", IX86_BUILTIN_PADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24369   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv8qi3, "__builtin_ia32_psubsb", IX86_BUILTIN_PSUBSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24370   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv4hi3, "__builtin_ia32_psubsw", IX86_BUILTIN_PSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24371   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv8qi3, "__builtin_ia32_paddusb", IX86_BUILTIN_PADDUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24372   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv4hi3, "__builtin_ia32_paddusw", IX86_BUILTIN_PADDUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24373   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv8qi3, "__builtin_ia32_psubusb", IX86_BUILTIN_PSUBUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24374   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv4hi3, "__builtin_ia32_psubusw", IX86_BUILTIN_PSUBUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24375
24376   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_mulv4hi3, "__builtin_ia32_pmullw", IX86_BUILTIN_PMULLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24377   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_smulv4hi3_highpart, "__builtin_ia32_pmulhw", IX86_BUILTIN_PMULHW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24378
24379   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andv2si3, "__builtin_ia32_pand", IX86_BUILTIN_PAND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24380   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andnotv2si3, "__builtin_ia32_pandn", IX86_BUILTIN_PANDN, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24381   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_iorv2si3, "__builtin_ia32_por", IX86_BUILTIN_POR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24382   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_xorv2si3, "__builtin_ia32_pxor", IX86_BUILTIN_PXOR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24383
24384   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv8qi3, "__builtin_ia32_pcmpeqb", IX86_BUILTIN_PCMPEQB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24385   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv4hi3, "__builtin_ia32_pcmpeqw", IX86_BUILTIN_PCMPEQW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24386   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv2si3, "__builtin_ia32_pcmpeqd", IX86_BUILTIN_PCMPEQD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24387   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv8qi3, "__builtin_ia32_pcmpgtb", IX86_BUILTIN_PCMPGTB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24388   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv4hi3, "__builtin_ia32_pcmpgtw", IX86_BUILTIN_PCMPGTW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24389   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv2si3, "__builtin_ia32_pcmpgtd", IX86_BUILTIN_PCMPGTD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24390
24391   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhbw, "__builtin_ia32_punpckhbw", IX86_BUILTIN_PUNPCKHBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24392   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhwd, "__builtin_ia32_punpckhwd", IX86_BUILTIN_PUNPCKHWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24393   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhdq, "__builtin_ia32_punpckhdq", IX86_BUILTIN_PUNPCKHDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24394   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklbw, "__builtin_ia32_punpcklbw", IX86_BUILTIN_PUNPCKLBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24395   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklwd, "__builtin_ia32_punpcklwd", IX86_BUILTIN_PUNPCKLWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI},
24396   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckldq, "__builtin_ia32_punpckldq", IX86_BUILTIN_PUNPCKLDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI},
24397
24398   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packsswb, "__builtin_ia32_packsswb", IX86_BUILTIN_PACKSSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
24399   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packssdw, "__builtin_ia32_packssdw", IX86_BUILTIN_PACKSSDW, UNKNOWN, (int) V4HI_FTYPE_V2SI_V2SI },
24400   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packuswb, "__builtin_ia32_packuswb", IX86_BUILTIN_PACKUSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
24401
24402   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_pmaddwd, "__builtin_ia32_pmaddwd", IX86_BUILTIN_PMADDWD, UNKNOWN, (int) V2SI_FTYPE_V4HI_V4HI },
24403
24404   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllwi", IX86_BUILTIN_PSLLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24405   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslldi", IX86_BUILTIN_PSLLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24406   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllqi", IX86_BUILTIN_PSLLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
24407   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllw", IX86_BUILTIN_PSLLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24408   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslld", IX86_BUILTIN_PSLLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24409   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllq", IX86_BUILTIN_PSLLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
24410
24411   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlwi", IX86_BUILTIN_PSRLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24412   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrldi", IX86_BUILTIN_PSRLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24413   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlqi", IX86_BUILTIN_PSRLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
24414   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlw", IX86_BUILTIN_PSRLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24415   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrld", IX86_BUILTIN_PSRLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24416   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlq", IX86_BUILTIN_PSRLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
24417
24418   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psrawi", IX86_BUILTIN_PSRAWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
24419   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psradi", IX86_BUILTIN_PSRADI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
24420   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psraw", IX86_BUILTIN_PSRAW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
24421   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psrad", IX86_BUILTIN_PSRAD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
24422
24423   /* 3DNow! */
24424   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pf2id, "__builtin_ia32_pf2id", IX86_BUILTIN_PF2ID, UNKNOWN, (int) V2SI_FTYPE_V2SF },
24425   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_floatv2si2, "__builtin_ia32_pi2fd", IX86_BUILTIN_PI2FD, UNKNOWN, (int) V2SF_FTYPE_V2SI },
24426   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpv2sf2, "__builtin_ia32_pfrcp", IX86_BUILTIN_PFRCP, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24427   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqrtv2sf2, "__builtin_ia32_pfrsqrt", IX86_BUILTIN_PFRSQRT, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24428
24429   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_uavgv8qi3, "__builtin_ia32_pavgusb", IX86_BUILTIN_PAVGUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24430   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_haddv2sf3, "__builtin_ia32_pfacc", IX86_BUILTIN_PFACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24431   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_addv2sf3, "__builtin_ia32_pfadd", IX86_BUILTIN_PFADD, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24432   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_eqv2sf3, "__builtin_ia32_pfcmpeq", IX86_BUILTIN_PFCMPEQ, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24433   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gev2sf3, "__builtin_ia32_pfcmpge", IX86_BUILTIN_PFCMPGE, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24434   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gtv2sf3, "__builtin_ia32_pfcmpgt", IX86_BUILTIN_PFCMPGT, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
24435   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_smaxv2sf3, "__builtin_ia32_pfmax", IX86_BUILTIN_PFMAX, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24436   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_sminv2sf3, "__builtin_ia32_pfmin", IX86_BUILTIN_PFMIN, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24437   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_mulv2sf3, "__builtin_ia32_pfmul", IX86_BUILTIN_PFMUL, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24438   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit1v2sf3, "__builtin_ia32_pfrcpit1", IX86_BUILTIN_PFRCPIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24439   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit2v2sf3, "__builtin_ia32_pfrcpit2", IX86_BUILTIN_PFRCPIT2, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24440   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqit1v2sf3, "__builtin_ia32_pfrsqit1", IX86_BUILTIN_PFRSQIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24441   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subv2sf3, "__builtin_ia32_pfsub", IX86_BUILTIN_PFSUB, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24442   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subrv2sf3, "__builtin_ia32_pfsubr", IX86_BUILTIN_PFSUBR, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24443   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pmulhrwv4hi3, "__builtin_ia32_pmulhrw", IX86_BUILTIN_PMULHRW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24444
24445   /* 3DNow!A */
24446   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pf2iw, "__builtin_ia32_pf2iw", IX86_BUILTIN_PF2IW, UNKNOWN, (int) V2SI_FTYPE_V2SF },
24447   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pi2fw, "__builtin_ia32_pi2fw", IX86_BUILTIN_PI2FW, UNKNOWN, (int) V2SF_FTYPE_V2SI },
24448   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2si2, "__builtin_ia32_pswapdsi", IX86_BUILTIN_PSWAPDSI, UNKNOWN, (int) V2SI_FTYPE_V2SI },
24449   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2sf2, "__builtin_ia32_pswapdsf", IX86_BUILTIN_PSWAPDSF, UNKNOWN, (int) V2SF_FTYPE_V2SF },
24450   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_hsubv2sf3, "__builtin_ia32_pfnacc", IX86_BUILTIN_PFNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24451   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_addsubv2sf3, "__builtin_ia32_pfpnacc", IX86_BUILTIN_PFPNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
24452
24453   /* SSE */
24454   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movmskps, "__builtin_ia32_movmskps", IX86_BUILTIN_MOVMSKPS, UNKNOWN, (int) INT_FTYPE_V4SF },
24455   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_sqrtv4sf2, "__builtin_ia32_sqrtps", IX86_BUILTIN_SQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24456   { OPTION_MASK_ISA_SSE, CODE_FOR_sqrtv4sf2, "__builtin_ia32_sqrtps_nr", IX86_BUILTIN_SQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24457   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rsqrtv4sf2, "__builtin_ia32_rsqrtps", IX86_BUILTIN_RSQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24458   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtv4sf2, "__builtin_ia32_rsqrtps_nr", IX86_BUILTIN_RSQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24459   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rcpv4sf2, "__builtin_ia32_rcpps", IX86_BUILTIN_RCPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24460   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtps2pi, "__builtin_ia32_cvtps2pi", IX86_BUILTIN_CVTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
24461   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtss2si, "__builtin_ia32_cvtss2si", IX86_BUILTIN_CVTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
24462   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtss2siq, "__builtin_ia32_cvtss2si64", IX86_BUILTIN_CVTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
24463   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttps2pi, "__builtin_ia32_cvttps2pi", IX86_BUILTIN_CVTTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
24464   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttss2si, "__builtin_ia32_cvttss2si", IX86_BUILTIN_CVTTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
24465   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvttss2siq, "__builtin_ia32_cvttss2si64", IX86_BUILTIN_CVTTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
24466
24467   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_shufps, "__builtin_ia32_shufps", IX86_BUILTIN_SHUFPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24468
24469   { OPTION_MASK_ISA_SSE, CODE_FOR_addv4sf3, "__builtin_ia32_addps", IX86_BUILTIN_ADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24470   { OPTION_MASK_ISA_SSE, CODE_FOR_subv4sf3, "__builtin_ia32_subps", IX86_BUILTIN_SUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24471   { OPTION_MASK_ISA_SSE, CODE_FOR_mulv4sf3, "__builtin_ia32_mulps", IX86_BUILTIN_MULPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24472   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_divv4sf3, "__builtin_ia32_divps", IX86_BUILTIN_DIVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24473   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmaddv4sf3,  "__builtin_ia32_addss", IX86_BUILTIN_ADDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24474   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsubv4sf3,  "__builtin_ia32_subss", IX86_BUILTIN_SUBSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24475   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmulv4sf3,  "__builtin_ia32_mulss", IX86_BUILTIN_MULSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24476   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmdivv4sf3,  "__builtin_ia32_divss", IX86_BUILTIN_DIVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24477
24478   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpeqps", IX86_BUILTIN_CMPEQPS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
24479   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpltps", IX86_BUILTIN_CMPLTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
24480   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpleps", IX86_BUILTIN_CMPLEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
24481   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgtps", IX86_BUILTIN_CMPGTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24482   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgeps", IX86_BUILTIN_CMPGEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24483   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpunordps", IX86_BUILTIN_CMPUNORDPS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24484   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpneqps", IX86_BUILTIN_CMPNEQPS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
24485   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnltps", IX86_BUILTIN_CMPNLTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
24486   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnleps", IX86_BUILTIN_CMPNLEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
24487   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngtps", IX86_BUILTIN_CMPNGTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24488   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngeps", IX86_BUILTIN_CMPNGEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP},
24489   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpordps", IX86_BUILTIN_CMPORDPS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24490   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpeqss", IX86_BUILTIN_CMPEQSS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
24491   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpltss", IX86_BUILTIN_CMPLTSS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
24492   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpless", IX86_BUILTIN_CMPLESS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
24493   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpunordss", IX86_BUILTIN_CMPUNORDSS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24494   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpneqss", IX86_BUILTIN_CMPNEQSS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
24495   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnltss", IX86_BUILTIN_CMPNLTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
24496   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnless", IX86_BUILTIN_CMPNLESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
24497   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngtss", IX86_BUILTIN_CMPNGTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24498   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngess", IX86_BUILTIN_CMPNGESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
24499   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpordss", IX86_BUILTIN_CMPORDSS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
24500
24501   { OPTION_MASK_ISA_SSE, CODE_FOR_sminv4sf3, "__builtin_ia32_minps", IX86_BUILTIN_MINPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24502   { OPTION_MASK_ISA_SSE, CODE_FOR_smaxv4sf3, "__builtin_ia32_maxps", IX86_BUILTIN_MAXPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24503   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsminv4sf3, "__builtin_ia32_minss", IX86_BUILTIN_MINSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24504   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsmaxv4sf3, "__builtin_ia32_maxss", IX86_BUILTIN_MAXSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24505
24506   { OPTION_MASK_ISA_SSE, CODE_FOR_andv4sf3, "__builtin_ia32_andps", IX86_BUILTIN_ANDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24507   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_andnotv4sf3,  "__builtin_ia32_andnps", IX86_BUILTIN_ANDNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24508   { OPTION_MASK_ISA_SSE, CODE_FOR_iorv4sf3, "__builtin_ia32_orps", IX86_BUILTIN_ORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24509   { OPTION_MASK_ISA_SSE, CODE_FOR_xorv4sf3,  "__builtin_ia32_xorps", IX86_BUILTIN_XORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24510
24511   { OPTION_MASK_ISA_SSE, CODE_FOR_copysignv4sf3,  "__builtin_ia32_copysignps", IX86_BUILTIN_CPYSGNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24512
24513   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movss,  "__builtin_ia32_movss", IX86_BUILTIN_MOVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24514   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movhlps_exp,  "__builtin_ia32_movhlps", IX86_BUILTIN_MOVHLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24515   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movlhps_exp,  "__builtin_ia32_movlhps", IX86_BUILTIN_MOVLHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24516   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_highv4sf, "__builtin_ia32_unpckhps", IX86_BUILTIN_UNPCKHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24517   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_lowv4sf, "__builtin_ia32_unpcklps", IX86_BUILTIN_UNPCKLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24518
24519   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtpi2ps, "__builtin_ia32_cvtpi2ps", IX86_BUILTIN_CVTPI2PS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2SI },
24520   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtsi2ss, "__builtin_ia32_cvtsi2ss", IX86_BUILTIN_CVTSI2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_SI },
24521   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtsi2ssq, "__builtin_ia32_cvtsi642ss", IX86_BUILTIN_CVTSI642SS, UNKNOWN, V4SF_FTYPE_V4SF_DI },
24522
24523   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtsf2, "__builtin_ia32_rsqrtf", IX86_BUILTIN_RSQRTF, UNKNOWN, (int) FLOAT_FTYPE_FLOAT },
24524
24525   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsqrtv4sf2, "__builtin_ia32_sqrtss", IX86_BUILTIN_SQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24526   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrsqrtv4sf2, "__builtin_ia32_rsqrtss", IX86_BUILTIN_RSQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24527   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrcpv4sf2, "__builtin_ia32_rcpss", IX86_BUILTIN_RCPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
24528
24529   /* SSE MMX or 3Dnow!A */
24530   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_uavgv8qi3, "__builtin_ia32_pavgb", IX86_BUILTIN_PAVGB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24531   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_uavgv4hi3, "__builtin_ia32_pavgw", IX86_BUILTIN_PAVGW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24532   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_umulv4hi3_highpart, "__builtin_ia32_pmulhuw", IX86_BUILTIN_PMULHUW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24533
24534   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_umaxv8qi3, "__builtin_ia32_pmaxub", IX86_BUILTIN_PMAXUB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24535   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_smaxv4hi3, "__builtin_ia32_pmaxsw", IX86_BUILTIN_PMAXSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24536   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_uminv8qi3, "__builtin_ia32_pminub", IX86_BUILTIN_PMINUB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24537   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_sminv4hi3, "__builtin_ia32_pminsw", IX86_BUILTIN_PMINSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24538
24539   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_psadbw, "__builtin_ia32_psadbw", IX86_BUILTIN_PSADBW, UNKNOWN, (int) V1DI_FTYPE_V8QI_V8QI },
24540   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pmovmskb, "__builtin_ia32_pmovmskb", IX86_BUILTIN_PMOVMSKB, UNKNOWN, (int) INT_FTYPE_V8QI },
24541
24542   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pshufw, "__builtin_ia32_pshufw", IX86_BUILTIN_PSHUFW, UNKNOWN, (int) V4HI_FTYPE_V4HI_INT },
24543
24544   /* SSE2 */
24545   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_shufpd, "__builtin_ia32_shufpd", IX86_BUILTIN_SHUFPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24546
24547   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2df", IX86_BUILTIN_VEC_PERM_V2DF, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DI },
24548   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4sf", IX86_BUILTIN_VEC_PERM_V4SF, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SI },
24549   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2di", IX86_BUILTIN_VEC_PERM_V2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_V2DI },
24550   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4si", IX86_BUILTIN_VEC_PERM_V4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_V4SI },
24551   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8hi", IX86_BUILTIN_VEC_PERM_V8HI, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI },
24552   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v16qi", IX86_BUILTIN_VEC_PERM_V16QI, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
24553   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v2di_u", IX86_BUILTIN_VEC_PERM_V2DI_U, UNKNOWN, (int) V2UDI_FTYPE_V2UDI_V2UDI_V2UDI },
24554   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4si_u", IX86_BUILTIN_VEC_PERM_V4SI_U, UNKNOWN, (int) V4USI_FTYPE_V4USI_V4USI_V4USI },
24555   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8hi_u", IX86_BUILTIN_VEC_PERM_V8HI_U, UNKNOWN, (int) V8UHI_FTYPE_V8UHI_V8UHI_V8UHI },
24556   { OPTION_MASK_ISA_SSE2, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v16qi_u", IX86_BUILTIN_VEC_PERM_V16QI_U, UNKNOWN, (int) V16UQI_FTYPE_V16UQI_V16UQI_V16UQI },
24557   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v4df", IX86_BUILTIN_VEC_PERM_V4DF, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DI },
24558   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin_ia32_vec_perm_v8sf", IX86_BUILTIN_VEC_PERM_V8SF, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SI },
24559
24560   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movmskpd, "__builtin_ia32_movmskpd", IX86_BUILTIN_MOVMSKPD, UNKNOWN, (int) INT_FTYPE_V2DF  },
24561   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmovmskb, "__builtin_ia32_pmovmskb128", IX86_BUILTIN_PMOVMSKB128, UNKNOWN, (int) INT_FTYPE_V16QI },
24562   { OPTION_MASK_ISA_SSE2, CODE_FOR_sqrtv2df2, "__builtin_ia32_sqrtpd", IX86_BUILTIN_SQRTPD, UNKNOWN, (int) V2DF_FTYPE_V2DF },
24563   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2pd, "__builtin_ia32_cvtdq2pd", IX86_BUILTIN_CVTDQ2PD, UNKNOWN, (int) V2DF_FTYPE_V4SI },
24564   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2ps, "__builtin_ia32_cvtdq2ps", IX86_BUILTIN_CVTDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
24565   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtudq2ps, "__builtin_ia32_cvtudq2ps", IX86_BUILTIN_CVTUDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
24566
24567   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2dq, "__builtin_ia32_cvtpd2dq", IX86_BUILTIN_CVTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
24568   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2pi, "__builtin_ia32_cvtpd2pi", IX86_BUILTIN_CVTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
24569   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2ps, "__builtin_ia32_cvtpd2ps", IX86_BUILTIN_CVTPD2PS, UNKNOWN, (int) V4SF_FTYPE_V2DF },
24570   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2dq, "__builtin_ia32_cvttpd2dq", IX86_BUILTIN_CVTTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
24571   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2pi, "__builtin_ia32_cvttpd2pi", IX86_BUILTIN_CVTTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
24572
24573   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpi2pd, "__builtin_ia32_cvtpi2pd", IX86_BUILTIN_CVTPI2PD, UNKNOWN, (int) V2DF_FTYPE_V2SI },
24574
24575   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2si, "__builtin_ia32_cvtsd2si", IX86_BUILTIN_CVTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
24576   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttsd2si, "__builtin_ia32_cvttsd2si", IX86_BUILTIN_CVTTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
24577   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsd2siq, "__builtin_ia32_cvtsd2si64", IX86_BUILTIN_CVTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
24578   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvttsd2siq, "__builtin_ia32_cvttsd2si64", IX86_BUILTIN_CVTTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
24579
24580   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2dq, "__builtin_ia32_cvtps2dq", IX86_BUILTIN_CVTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
24581   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2pd, "__builtin_ia32_cvtps2pd", IX86_BUILTIN_CVTPS2PD, UNKNOWN, (int) V2DF_FTYPE_V4SF },
24582   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttps2dq, "__builtin_ia32_cvttps2dq", IX86_BUILTIN_CVTTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
24583
24584   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2df3, "__builtin_ia32_addpd", IX86_BUILTIN_ADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24585   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2df3, "__builtin_ia32_subpd", IX86_BUILTIN_SUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24586   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv2df3, "__builtin_ia32_mulpd", IX86_BUILTIN_MULPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24587   { OPTION_MASK_ISA_SSE2, CODE_FOR_divv2df3, "__builtin_ia32_divpd", IX86_BUILTIN_DIVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24588   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmaddv2df3,  "__builtin_ia32_addsd", IX86_BUILTIN_ADDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24589   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsubv2df3,  "__builtin_ia32_subsd", IX86_BUILTIN_SUBSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24590   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmulv2df3,  "__builtin_ia32_mulsd", IX86_BUILTIN_MULSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24591   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmdivv2df3,  "__builtin_ia32_divsd", IX86_BUILTIN_DIVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24592
24593   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpeqpd", IX86_BUILTIN_CMPEQPD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
24594   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpltpd", IX86_BUILTIN_CMPLTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
24595   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmplepd", IX86_BUILTIN_CMPLEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
24596   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgtpd", IX86_BUILTIN_CMPGTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24597   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgepd", IX86_BUILTIN_CMPGEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP},
24598   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpunordpd", IX86_BUILTIN_CMPUNORDPD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24599   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpneqpd", IX86_BUILTIN_CMPNEQPD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
24600   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnltpd", IX86_BUILTIN_CMPNLTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
24601   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnlepd", IX86_BUILTIN_CMPNLEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
24602   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngtpd", IX86_BUILTIN_CMPNGTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24603   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngepd", IX86_BUILTIN_CMPNGEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
24604   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpordpd", IX86_BUILTIN_CMPORDPD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24605   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpeqsd", IX86_BUILTIN_CMPEQSD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
24606   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpltsd", IX86_BUILTIN_CMPLTSD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
24607   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmplesd", IX86_BUILTIN_CMPLESD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
24608   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpunordsd", IX86_BUILTIN_CMPUNORDSD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24609   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpneqsd", IX86_BUILTIN_CMPNEQSD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
24610   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnltsd", IX86_BUILTIN_CMPNLTSD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
24611   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnlesd", IX86_BUILTIN_CMPNLESD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
24612   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpordsd", IX86_BUILTIN_CMPORDSD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
24613
24614   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv2df3, "__builtin_ia32_minpd", IX86_BUILTIN_MINPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24615   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv2df3, "__builtin_ia32_maxpd", IX86_BUILTIN_MAXPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24616   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsminv2df3, "__builtin_ia32_minsd", IX86_BUILTIN_MINSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24617   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsmaxv2df3, "__builtin_ia32_maxsd", IX86_BUILTIN_MAXSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24618
24619   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2df3, "__builtin_ia32_andpd", IX86_BUILTIN_ANDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24620   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2df3,  "__builtin_ia32_andnpd", IX86_BUILTIN_ANDNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24621   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2df3, "__builtin_ia32_orpd", IX86_BUILTIN_ORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24622   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2df3,  "__builtin_ia32_xorpd", IX86_BUILTIN_XORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24623
24624   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysignv2df3,  "__builtin_ia32_copysignpd", IX86_BUILTIN_CPYSGNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24625
24626   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movsd,  "__builtin_ia32_movsd", IX86_BUILTIN_MOVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24627   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2df, "__builtin_ia32_unpckhpd", IX86_BUILTIN_UNPCKHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24628   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2df, "__builtin_ia32_unpcklpd", IX86_BUILTIN_UNPCKLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24629
24630   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_pack_sfix_v2df, "__builtin_ia32_vec_pack_sfix", IX86_BUILTIN_VEC_PACK_SFIX, UNKNOWN, (int) V4SI_FTYPE_V2DF_V2DF },
24631
24632   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv16qi3, "__builtin_ia32_paddb128", IX86_BUILTIN_PADDB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24633   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv8hi3, "__builtin_ia32_paddw128", IX86_BUILTIN_PADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24634   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv4si3, "__builtin_ia32_paddd128", IX86_BUILTIN_PADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24635   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2di3, "__builtin_ia32_paddq128", IX86_BUILTIN_PADDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24636   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv16qi3, "__builtin_ia32_psubb128", IX86_BUILTIN_PSUBB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24637   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv8hi3, "__builtin_ia32_psubw128", IX86_BUILTIN_PSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24638   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv4si3, "__builtin_ia32_psubd128", IX86_BUILTIN_PSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24639   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2di3, "__builtin_ia32_psubq128", IX86_BUILTIN_PSUBQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24640
24641   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv16qi3, "__builtin_ia32_paddsb128", IX86_BUILTIN_PADDSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24642   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv8hi3, "__builtin_ia32_paddsw128", IX86_BUILTIN_PADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24643   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv16qi3, "__builtin_ia32_psubsb128", IX86_BUILTIN_PSUBSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24644   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv8hi3, "__builtin_ia32_psubsw128", IX86_BUILTIN_PSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24645   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv16qi3, "__builtin_ia32_paddusb128", IX86_BUILTIN_PADDUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24646   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv8hi3, "__builtin_ia32_paddusw128", IX86_BUILTIN_PADDUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24647   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv16qi3, "__builtin_ia32_psubusb128", IX86_BUILTIN_PSUBUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24648   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv8hi3, "__builtin_ia32_psubusw128", IX86_BUILTIN_PSUBUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24649
24650   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv8hi3, "__builtin_ia32_pmullw128", IX86_BUILTIN_PMULLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24651   { OPTION_MASK_ISA_SSE2, CODE_FOR_smulv8hi3_highpart, "__builtin_ia32_pmulhw128", IX86_BUILTIN_PMULHW128, UNKNOWN,(int) V8HI_FTYPE_V8HI_V8HI },
24652
24653   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2di3, "__builtin_ia32_pand128", IX86_BUILTIN_PAND128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24654   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2di3, "__builtin_ia32_pandn128", IX86_BUILTIN_PANDN128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24655   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2di3, "__builtin_ia32_por128", IX86_BUILTIN_POR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24656   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2di3, "__builtin_ia32_pxor128", IX86_BUILTIN_PXOR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24657
24658   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv16qi3, "__builtin_ia32_pavgb128", IX86_BUILTIN_PAVGB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24659   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv8hi3, "__builtin_ia32_pavgw128", IX86_BUILTIN_PAVGW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24660
24661   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv16qi3, "__builtin_ia32_pcmpeqb128", IX86_BUILTIN_PCMPEQB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24662   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv8hi3, "__builtin_ia32_pcmpeqw128", IX86_BUILTIN_PCMPEQW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24663   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv4si3, "__builtin_ia32_pcmpeqd128", IX86_BUILTIN_PCMPEQD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
24664   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv16qi3, "__builtin_ia32_pcmpgtb128", IX86_BUILTIN_PCMPGTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24665   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv8hi3, "__builtin_ia32_pcmpgtw128", IX86_BUILTIN_PCMPGTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24666   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv4si3, "__builtin_ia32_pcmpgtd128", IX86_BUILTIN_PCMPGTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
24667
24668   { OPTION_MASK_ISA_SSE2, CODE_FOR_umaxv16qi3, "__builtin_ia32_pmaxub128", IX86_BUILTIN_PMAXUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24669   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv8hi3, "__builtin_ia32_pmaxsw128", IX86_BUILTIN_PMAXSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24670   { OPTION_MASK_ISA_SSE2, CODE_FOR_uminv16qi3, "__builtin_ia32_pminub128", IX86_BUILTIN_PMINUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24671   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv8hi3, "__builtin_ia32_pminsw128", IX86_BUILTIN_PMINSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24672
24673   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv16qi, "__builtin_ia32_punpckhbw128", IX86_BUILTIN_PUNPCKHBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24674   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv8hi, "__builtin_ia32_punpckhwd128", IX86_BUILTIN_PUNPCKHWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI  },
24675   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv4si, "__builtin_ia32_punpckhdq128", IX86_BUILTIN_PUNPCKHDQ128, UNKNOWN,  (int) V4SI_FTYPE_V4SI_V4SI },
24676   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2di, "__builtin_ia32_punpckhqdq128", IX86_BUILTIN_PUNPCKHQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24677   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv16qi, "__builtin_ia32_punpcklbw128", IX86_BUILTIN_PUNPCKLBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24678   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv8hi, "__builtin_ia32_punpcklwd128", IX86_BUILTIN_PUNPCKLWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24679   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv4si, "__builtin_ia32_punpckldq128", IX86_BUILTIN_PUNPCKLDQ128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24680   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2di, "__builtin_ia32_punpcklqdq128", IX86_BUILTIN_PUNPCKLQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24681
24682   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packsswb, "__builtin_ia32_packsswb128", IX86_BUILTIN_PACKSSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
24683   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packssdw, "__builtin_ia32_packssdw128", IX86_BUILTIN_PACKSSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
24684   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packuswb, "__builtin_ia32_packuswb128", IX86_BUILTIN_PACKUSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
24685
24686   { OPTION_MASK_ISA_SSE2, CODE_FOR_umulv8hi3_highpart, "__builtin_ia32_pmulhuw128", IX86_BUILTIN_PMULHUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24687   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_psadbw, "__builtin_ia32_psadbw128", IX86_BUILTIN_PSADBW128, UNKNOWN, (int) V2DI_FTYPE_V16QI_V16QI },
24688
24689   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv1siv1di3, "__builtin_ia32_pmuludq", IX86_BUILTIN_PMULUDQ, UNKNOWN, (int) V1DI_FTYPE_V2SI_V2SI },
24690   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv2siv2di3, "__builtin_ia32_pmuludq128", IX86_BUILTIN_PMULUDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
24691
24692   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmaddwd, "__builtin_ia32_pmaddwd128", IX86_BUILTIN_PMADDWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI_V8HI },
24693
24694   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsi2sd, "__builtin_ia32_cvtsi2sd", IX86_BUILTIN_CVTSI2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_SI },
24695   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsi2sdq, "__builtin_ia32_cvtsi642sd", IX86_BUILTIN_CVTSI642SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_DI },
24696   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2ss, "__builtin_ia32_cvtsd2ss", IX86_BUILTIN_CVTSD2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF },
24697   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtss2sd, "__builtin_ia32_cvtss2sd", IX86_BUILTIN_CVTSS2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V4SF },
24698
24699   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlv1ti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
24700   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllwi128", IX86_BUILTIN_PSLLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24701   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslldi128", IX86_BUILTIN_PSLLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24702   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllqi128", IX86_BUILTIN_PSLLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
24703   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllw128", IX86_BUILTIN_PSLLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24704   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslld128", IX86_BUILTIN_PSLLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24705   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllq128", IX86_BUILTIN_PSLLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
24706
24707   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrv1ti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
24708   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlwi128", IX86_BUILTIN_PSRLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24709   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrldi128", IX86_BUILTIN_PSRLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24710   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlqi128", IX86_BUILTIN_PSRLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
24711   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlw128", IX86_BUILTIN_PSRLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24712   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrld128", IX86_BUILTIN_PSRLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24713   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlq128", IX86_BUILTIN_PSRLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
24714
24715   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psrawi128", IX86_BUILTIN_PSRAWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
24716   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psradi128", IX86_BUILTIN_PSRADI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
24717   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psraw128", IX86_BUILTIN_PSRAW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
24718   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psrad128", IX86_BUILTIN_PSRAD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
24719
24720   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufd, "__builtin_ia32_pshufd", IX86_BUILTIN_PSHUFD, UNKNOWN, (int) V4SI_FTYPE_V4SI_INT },
24721   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshuflw, "__builtin_ia32_pshuflw", IX86_BUILTIN_PSHUFLW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
24722   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufhw, "__builtin_ia32_pshufhw", IX86_BUILTIN_PSHUFHW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
24723
24724   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsqrtv2df2, "__builtin_ia32_sqrtsd", IX86_BUILTIN_SQRTSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_VEC_MERGE },
24725
24726   { OPTION_MASK_ISA_SSE2, CODE_FOR_abstf2, 0, IX86_BUILTIN_FABSQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128 },
24727   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysigntf3, 0, IX86_BUILTIN_COPYSIGNQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128_FLOAT128 },
24728
24729   { OPTION_MASK_ISA_SSE, CODE_FOR_sse2_movq128, "__builtin_ia32_movq128", IX86_BUILTIN_MOVQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
24730
24731   /* SSE2 MMX */
24732   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_addv1di3, "__builtin_ia32_paddq", IX86_BUILTIN_PADDQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
24733   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_subv1di3, "__builtin_ia32_psubq", IX86_BUILTIN_PSUBQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
24734
24735   /* SSE3 */
24736   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movshdup, "__builtin_ia32_movshdup", IX86_BUILTIN_MOVSHDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF},
24737   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movsldup, "__builtin_ia32_movsldup", IX86_BUILTIN_MOVSLDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF },
24738
24739   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv4sf3, "__builtin_ia32_addsubps", IX86_BUILTIN_ADDSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24740   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv2df3, "__builtin_ia32_addsubpd", IX86_BUILTIN_ADDSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24741   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv4sf3, "__builtin_ia32_haddps", IX86_BUILTIN_HADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24742   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv2df3, "__builtin_ia32_haddpd", IX86_BUILTIN_HADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24743   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv4sf3, "__builtin_ia32_hsubps", IX86_BUILTIN_HSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
24744   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv2df3, "__builtin_ia32_hsubpd", IX86_BUILTIN_HSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
24745
24746   /* SSSE3 */
24747   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv16qi2, "__builtin_ia32_pabsb128", IX86_BUILTIN_PABSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
24748   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8qi2, "__builtin_ia32_pabsb", IX86_BUILTIN_PABSB, UNKNOWN, (int) V8QI_FTYPE_V8QI },
24749   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8hi2, "__builtin_ia32_pabsw128", IX86_BUILTIN_PABSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
24750   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4hi2, "__builtin_ia32_pabsw", IX86_BUILTIN_PABSW, UNKNOWN, (int) V4HI_FTYPE_V4HI },
24751   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4si2, "__builtin_ia32_pabsd128", IX86_BUILTIN_PABSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
24752   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv2si2, "__builtin_ia32_pabsd", IX86_BUILTIN_PABSD, UNKNOWN, (int) V2SI_FTYPE_V2SI },
24753
24754   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv8hi3, "__builtin_ia32_phaddw128", IX86_BUILTIN_PHADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24755   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv4hi3, "__builtin_ia32_phaddw", IX86_BUILTIN_PHADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24756   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv4si3, "__builtin_ia32_phaddd128", IX86_BUILTIN_PHADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24757   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv2si3, "__builtin_ia32_phaddd", IX86_BUILTIN_PHADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24758   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv8hi3, "__builtin_ia32_phaddsw128", IX86_BUILTIN_PHADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24759   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv4hi3, "__builtin_ia32_phaddsw", IX86_BUILTIN_PHADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24760   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv8hi3, "__builtin_ia32_phsubw128", IX86_BUILTIN_PHSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24761   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv4hi3, "__builtin_ia32_phsubw", IX86_BUILTIN_PHSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24762   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv4si3, "__builtin_ia32_phsubd128", IX86_BUILTIN_PHSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24763   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv2si3, "__builtin_ia32_phsubd", IX86_BUILTIN_PHSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24764   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv8hi3, "__builtin_ia32_phsubsw128", IX86_BUILTIN_PHSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24765   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv4hi3, "__builtin_ia32_phsubsw", IX86_BUILTIN_PHSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24766   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw128, "__builtin_ia32_pmaddubsw128", IX86_BUILTIN_PMADDUBSW128, UNKNOWN, (int) V8HI_FTYPE_V16QI_V16QI },
24767   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw, "__builtin_ia32_pmaddubsw", IX86_BUILTIN_PMADDUBSW, UNKNOWN, (int) V4HI_FTYPE_V8QI_V8QI },
24768   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv8hi3, "__builtin_ia32_pmulhrsw128", IX86_BUILTIN_PMULHRSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24769   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv4hi3, "__builtin_ia32_pmulhrsw", IX86_BUILTIN_PMULHRSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24770   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv16qi3, "__builtin_ia32_pshufb128", IX86_BUILTIN_PSHUFB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24771   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv8qi3, "__builtin_ia32_pshufb", IX86_BUILTIN_PSHUFB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24772   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv16qi3, "__builtin_ia32_psignb128", IX86_BUILTIN_PSIGNB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24773   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8qi3, "__builtin_ia32_psignb", IX86_BUILTIN_PSIGNB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
24774   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8hi3, "__builtin_ia32_psignw128", IX86_BUILTIN_PSIGNW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24775   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4hi3, "__builtin_ia32_psignw", IX86_BUILTIN_PSIGNW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
24776   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4si3, "__builtin_ia32_psignd128", IX86_BUILTIN_PSIGND128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24777   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv2si3, "__builtin_ia32_psignd", IX86_BUILTIN_PSIGND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
24778
24779   /* SSSE3.  */
24780   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT_CONVERT },
24781   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_INT_CONVERT },
24782
24783   /* SSE4.1 */
24784   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendpd, "__builtin_ia32_blendpd", IX86_BUILTIN_BLENDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24785   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendps, "__builtin_ia32_blendps", IX86_BUILTIN_BLENDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24786   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvpd, "__builtin_ia32_blendvpd", IX86_BUILTIN_BLENDVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DF },
24787   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvps, "__builtin_ia32_blendvps", IX86_BUILTIN_BLENDVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SF },
24788   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dppd, "__builtin_ia32_dppd", IX86_BUILTIN_DPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24789   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dpps, "__builtin_ia32_dpps", IX86_BUILTIN_DPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24790   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_insertps, "__builtin_ia32_insertps128", IX86_BUILTIN_INSERTPS128, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24791   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mpsadbw, "__builtin_ia32_mpsadbw128", IX86_BUILTIN_MPSADBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_INT },
24792   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendvb, "__builtin_ia32_pblendvb128", IX86_BUILTIN_PBLENDVB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
24793   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendw, "__builtin_ia32_pblendw128", IX86_BUILTIN_PBLENDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_INT },
24794
24795   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv8qiv8hi2, "__builtin_ia32_pmovsxbw128", IX86_BUILTIN_PMOVSXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
24796   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4qiv4si2, "__builtin_ia32_pmovsxbd128", IX86_BUILTIN_PMOVSXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
24797   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2qiv2di2, "__builtin_ia32_pmovsxbq128", IX86_BUILTIN_PMOVSXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
24798   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4hiv4si2, "__builtin_ia32_pmovsxwd128", IX86_BUILTIN_PMOVSXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
24799   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2hiv2di2, "__builtin_ia32_pmovsxwq128", IX86_BUILTIN_PMOVSXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
24800   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2siv2di2, "__builtin_ia32_pmovsxdq128", IX86_BUILTIN_PMOVSXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
24801   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv8qiv8hi2, "__builtin_ia32_pmovzxbw128", IX86_BUILTIN_PMOVZXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
24802   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4qiv4si2, "__builtin_ia32_pmovzxbd128", IX86_BUILTIN_PMOVZXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
24803   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2qiv2di2, "__builtin_ia32_pmovzxbq128", IX86_BUILTIN_PMOVZXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
24804   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4hiv4si2, "__builtin_ia32_pmovzxwd128", IX86_BUILTIN_PMOVZXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
24805   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2hiv2di2, "__builtin_ia32_pmovzxwq128", IX86_BUILTIN_PMOVZXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
24806   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2siv2di2, "__builtin_ia32_pmovzxdq128", IX86_BUILTIN_PMOVZXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
24807   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_phminposuw, "__builtin_ia32_phminposuw128", IX86_BUILTIN_PHMINPOSUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
24808
24809   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_packusdw, "__builtin_ia32_packusdw128", IX86_BUILTIN_PACKUSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
24810   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_eqv2di3, "__builtin_ia32_pcmpeqq", IX86_BUILTIN_PCMPEQQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24811   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv16qi3, "__builtin_ia32_pmaxsb128", IX86_BUILTIN_PMAXSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24812   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv4si3, "__builtin_ia32_pmaxsd128", IX86_BUILTIN_PMAXSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24813   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv4si3, "__builtin_ia32_pmaxud128", IX86_BUILTIN_PMAXUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24814   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv8hi3, "__builtin_ia32_pmaxuw128", IX86_BUILTIN_PMAXUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24815   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv16qi3, "__builtin_ia32_pminsb128", IX86_BUILTIN_PMINSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
24816   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv4si3, "__builtin_ia32_pminsd128", IX86_BUILTIN_PMINSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24817   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv4si3, "__builtin_ia32_pminud128", IX86_BUILTIN_PMINUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24818   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv8hi3, "__builtin_ia32_pminuw128", IX86_BUILTIN_PMINUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
24819   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mulv2siv2di3, "__builtin_ia32_pmuldq128", IX86_BUILTIN_PMULDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
24820   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_mulv4si3, "__builtin_ia32_pmulld128", IX86_BUILTIN_PMULLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
24821
24822   /* SSE4.1 */
24823   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_roundpd", IX86_BUILTIN_ROUNDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
24824   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_roundps", IX86_BUILTIN_ROUNDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
24825   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundsd, "__builtin_ia32_roundsd", IX86_BUILTIN_ROUNDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24826   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundss, "__builtin_ia32_roundss", IX86_BUILTIN_ROUNDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24827
24828   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_floorpd", IX86_BUILTIN_FLOORPD, (enum rtx_code) ROUND_FLOOR, (int) V2DF_FTYPE_V2DF_ROUND },
24829   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_ceilpd", IX86_BUILTIN_CEILPD, (enum rtx_code) ROUND_CEIL, (int) V2DF_FTYPE_V2DF_ROUND },
24830   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_truncpd", IX86_BUILTIN_TRUNCPD, (enum rtx_code) ROUND_TRUNC, (int) V2DF_FTYPE_V2DF_ROUND },
24831   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_rintpd", IX86_BUILTIN_RINTPD, (enum rtx_code) ROUND_MXCSR, (int) V2DF_FTYPE_V2DF_ROUND },
24832
24833   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_floorps", IX86_BUILTIN_FLOORPS, (enum rtx_code) ROUND_FLOOR, (int) V4SF_FTYPE_V4SF_ROUND },
24834   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_ceilps", IX86_BUILTIN_CEILPS, (enum rtx_code) ROUND_CEIL, (int) V4SF_FTYPE_V4SF_ROUND },
24835   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_truncps", IX86_BUILTIN_TRUNCPS, (enum rtx_code) ROUND_TRUNC, (int) V4SF_FTYPE_V4SF_ROUND },
24836   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_rintps", IX86_BUILTIN_RINTPS, (enum rtx_code) ROUND_MXCSR, (int) V4SF_FTYPE_V4SF_ROUND },
24837
24838   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestz128", IX86_BUILTIN_PTESTZ, EQ, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24839   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestc128", IX86_BUILTIN_PTESTC, LTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24840   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestnzc128", IX86_BUILTIN_PTESTNZC, GTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
24841
24842   /* SSE4.2 */
24843   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_gtv2di3, "__builtin_ia32_pcmpgtq", IX86_BUILTIN_PCMPGTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24844   { OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_CRC32, CODE_FOR_sse4_2_crc32qi, "__builtin_ia32_crc32qi", IX86_BUILTIN_CRC32QI, UNKNOWN, (int) UINT_FTYPE_UINT_UCHAR },
24845   { OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_CRC32, CODE_FOR_sse4_2_crc32hi, "__builtin_ia32_crc32hi", IX86_BUILTIN_CRC32HI, UNKNOWN, (int) UINT_FTYPE_UINT_USHORT },
24846   { OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_CRC32, CODE_FOR_sse4_2_crc32si, "__builtin_ia32_crc32si", IX86_BUILTIN_CRC32SI, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
24847   { OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_CRC32 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse4_2_crc32di, "__builtin_ia32_crc32di", IX86_BUILTIN_CRC32DI, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
24848
24849   /* SSE4A */
24850   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrqi, "__builtin_ia32_extrqi", IX86_BUILTIN_EXTRQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_UINT_UINT },
24851   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrq, "__builtin_ia32_extrq", IX86_BUILTIN_EXTRQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V16QI },
24852   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertqi, "__builtin_ia32_insertqi", IX86_BUILTIN_INSERTQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_UINT_UINT },
24853   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertq, "__builtin_ia32_insertq", IX86_BUILTIN_INSERTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24854
24855   /* AES */
24856   { OPTION_MASK_ISA_SSE2, CODE_FOR_aeskeygenassist, 0, IX86_BUILTIN_AESKEYGENASSIST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT },
24857   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesimc, 0, IX86_BUILTIN_AESIMC128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
24858
24859   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenc, 0, IX86_BUILTIN_AESENC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24860   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenclast, 0, IX86_BUILTIN_AESENCLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24861   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdec, 0, IX86_BUILTIN_AESDEC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24862   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdeclast, 0, IX86_BUILTIN_AESDECLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
24863
24864   /* PCLMUL */
24865   { OPTION_MASK_ISA_SSE2, CODE_FOR_pclmulqdq, 0, IX86_BUILTIN_PCLMULQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT },
24866
24867   /* AVX */
24868   { OPTION_MASK_ISA_AVX, CODE_FOR_addv4df3, "__builtin_ia32_addpd256", IX86_BUILTIN_ADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24869   { OPTION_MASK_ISA_AVX, CODE_FOR_addv8sf3, "__builtin_ia32_addps256", IX86_BUILTIN_ADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24870   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv4df3, "__builtin_ia32_addsubpd256", IX86_BUILTIN_ADDSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24871   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv8sf3, "__builtin_ia32_addsubps256", IX86_BUILTIN_ADDSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24872   { OPTION_MASK_ISA_AVX, CODE_FOR_andv4df3, "__builtin_ia32_andpd256", IX86_BUILTIN_ANDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24873   { OPTION_MASK_ISA_AVX, CODE_FOR_andv8sf3, "__builtin_ia32_andps256", IX86_BUILTIN_ANDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24874   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv4df3, "__builtin_ia32_andnpd256", IX86_BUILTIN_ANDNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24875   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv8sf3, "__builtin_ia32_andnps256", IX86_BUILTIN_ANDNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24876   { OPTION_MASK_ISA_AVX, CODE_FOR_divv4df3, "__builtin_ia32_divpd256", IX86_BUILTIN_DIVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24877   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_divv8sf3, "__builtin_ia32_divps256", IX86_BUILTIN_DIVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24878   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv4df3, "__builtin_ia32_haddpd256", IX86_BUILTIN_HADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24879   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv8sf3, "__builtin_ia32_hsubps256", IX86_BUILTIN_HSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24880   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv4df3, "__builtin_ia32_hsubpd256", IX86_BUILTIN_HSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24881   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv8sf3, "__builtin_ia32_haddps256", IX86_BUILTIN_HADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24882   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv4df3, "__builtin_ia32_maxpd256", IX86_BUILTIN_MAXPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24883   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv8sf3, "__builtin_ia32_maxps256", IX86_BUILTIN_MAXPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24884   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv4df3, "__builtin_ia32_minpd256", IX86_BUILTIN_MINPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24885   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv8sf3, "__builtin_ia32_minps256", IX86_BUILTIN_MINPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24886   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv4df3, "__builtin_ia32_mulpd256", IX86_BUILTIN_MULPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24887   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv8sf3, "__builtin_ia32_mulps256", IX86_BUILTIN_MULPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24888   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv4df3, "__builtin_ia32_orpd256", IX86_BUILTIN_ORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24889   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv8sf3, "__builtin_ia32_orps256", IX86_BUILTIN_ORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24890   { OPTION_MASK_ISA_AVX, CODE_FOR_subv4df3, "__builtin_ia32_subpd256", IX86_BUILTIN_SUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24891   { OPTION_MASK_ISA_AVX, CODE_FOR_subv8sf3, "__builtin_ia32_subps256", IX86_BUILTIN_SUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24892   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv4df3, "__builtin_ia32_xorpd256", IX86_BUILTIN_XORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24893   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv8sf3, "__builtin_ia32_xorps256", IX86_BUILTIN_XORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24894
24895   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv2df3, "__builtin_ia32_vpermilvarpd", IX86_BUILTIN_VPERMILVARPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DI },
24896   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4sf3, "__builtin_ia32_vpermilvarps", IX86_BUILTIN_VPERMILVARPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SI },
24897   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4df3, "__builtin_ia32_vpermilvarpd256", IX86_BUILTIN_VPERMILVARPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DI },
24898   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv8sf3, "__builtin_ia32_vpermilvarps256", IX86_BUILTIN_VPERMILVARPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SI },
24899
24900   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendpd256, "__builtin_ia32_blendpd256", IX86_BUILTIN_BLENDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24901   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendps256, "__builtin_ia32_blendps256", IX86_BUILTIN_BLENDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24902   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvpd256, "__builtin_ia32_blendvpd256", IX86_BUILTIN_BLENDVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DF },
24903   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvps256, "__builtin_ia32_blendvps256", IX86_BUILTIN_BLENDVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SF },
24904   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_dpps256, "__builtin_ia32_dpps256", IX86_BUILTIN_DPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24905   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufpd256, "__builtin_ia32_shufpd256", IX86_BUILTIN_SHUFPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24906   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufps256, "__builtin_ia32_shufps256", IX86_BUILTIN_SHUFPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24907   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv2df3, "__builtin_ia32_cmpsd", IX86_BUILTIN_CMPSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24908   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv4sf3, "__builtin_ia32_cmpss", IX86_BUILTIN_CMPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24909   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv2df3, "__builtin_ia32_cmppd", IX86_BUILTIN_CMPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
24910   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4sf3, "__builtin_ia32_cmpps", IX86_BUILTIN_CMPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
24911   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4df3, "__builtin_ia32_cmppd256", IX86_BUILTIN_CMPPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24912   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv8sf3, "__builtin_ia32_cmpps256", IX86_BUILTIN_CMPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24913   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v4df, "__builtin_ia32_vextractf128_pd256", IX86_BUILTIN_EXTRACTF128PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF_INT },
24914   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8sf, "__builtin_ia32_vextractf128_ps256", IX86_BUILTIN_EXTRACTF128PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF_INT },
24915   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8si, "__builtin_ia32_vextractf128_si256", IX86_BUILTIN_EXTRACTF128SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI_INT },
24916   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2pd256, "__builtin_ia32_cvtdq2pd256", IX86_BUILTIN_CVTDQ2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SI },
24917   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtdq2ps256, "__builtin_ia32_cvtdq2ps256", IX86_BUILTIN_CVTDQ2PS256, UNKNOWN, (int) V8SF_FTYPE_V8SI },
24918   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2ps256, "__builtin_ia32_cvtpd2ps256", IX86_BUILTIN_CVTPD2PS256, UNKNOWN, (int) V4SF_FTYPE_V4DF },
24919   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2dq256, "__builtin_ia32_cvtps2dq256", IX86_BUILTIN_CVTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
24920   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2pd256, "__builtin_ia32_cvtps2pd256", IX86_BUILTIN_CVTPS2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SF },
24921   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttpd2dq256, "__builtin_ia32_cvttpd2dq256", IX86_BUILTIN_CVTTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
24922   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2dq256, "__builtin_ia32_cvtpd2dq256", IX86_BUILTIN_CVTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
24923   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvttps2dq256, "__builtin_ia32_cvttps2dq256", IX86_BUILTIN_CVTTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
24924   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v4df3, "__builtin_ia32_vperm2f128_pd256", IX86_BUILTIN_VPERM2F128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
24925   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8sf3, "__builtin_ia32_vperm2f128_ps256", IX86_BUILTIN_VPERM2F128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
24926   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8si3, "__builtin_ia32_vperm2f128_si256", IX86_BUILTIN_VPERM2F128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
24927   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv2df, "__builtin_ia32_vpermilpd", IX86_BUILTIN_VPERMILPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
24928   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4sf, "__builtin_ia32_vpermilps", IX86_BUILTIN_VPERMILPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
24929   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4df, "__builtin_ia32_vpermilpd256", IX86_BUILTIN_VPERMILPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
24930   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv8sf, "__builtin_ia32_vpermilps256", IX86_BUILTIN_VPERMILPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
24931   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v4df, "__builtin_ia32_vinsertf128_pd256", IX86_BUILTIN_VINSERTF128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V2DF_INT },
24932   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8sf, "__builtin_ia32_vinsertf128_ps256", IX86_BUILTIN_VINSERTF128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V4SF_INT },
24933   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8si, "__builtin_ia32_vinsertf128_si256", IX86_BUILTIN_VINSERTF128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_INT },
24934
24935   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movshdup256, "__builtin_ia32_movshdup256", IX86_BUILTIN_MOVSHDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24936   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movsldup256, "__builtin_ia32_movsldup256", IX86_BUILTIN_MOVSLDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24937   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movddup256, "__builtin_ia32_movddup256", IX86_BUILTIN_MOVDDUP256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
24938
24939   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv4df2, "__builtin_ia32_sqrtpd256", IX86_BUILTIN_SQRTPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
24940   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_sqrtv8sf2, "__builtin_ia32_sqrtps256", IX86_BUILTIN_SQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24941   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv8sf2, "__builtin_ia32_sqrtps_nr256", IX86_BUILTIN_SQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24942   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rsqrtv8sf2, "__builtin_ia32_rsqrtps256", IX86_BUILTIN_RSQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24943   { OPTION_MASK_ISA_AVX, CODE_FOR_rsqrtv8sf2, "__builtin_ia32_rsqrtps_nr256", IX86_BUILTIN_RSQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24944
24945   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rcpv8sf2, "__builtin_ia32_rcpps256", IX86_BUILTIN_RCPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
24946
24947   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_roundpd256", IX86_BUILTIN_ROUNDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
24948   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_roundps256", IX86_BUILTIN_ROUNDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
24949
24950   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_floorpd256", IX86_BUILTIN_FLOORPD256, (enum rtx_code) ROUND_FLOOR, (int) V4DF_FTYPE_V4DF_ROUND },
24951   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_ceilpd256", IX86_BUILTIN_CEILPD256, (enum rtx_code) ROUND_CEIL, (int) V4DF_FTYPE_V4DF_ROUND },
24952   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_truncpd256", IX86_BUILTIN_TRUNCPD256, (enum rtx_code) ROUND_TRUNC, (int) V4DF_FTYPE_V4DF_ROUND },
24953   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_rintpd256", IX86_BUILTIN_RINTPD256, (enum rtx_code) ROUND_MXCSR, (int) V4DF_FTYPE_V4DF_ROUND },
24954
24955   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_floorps256", IX86_BUILTIN_FLOORPS256, (enum rtx_code) ROUND_FLOOR, (int) V8SF_FTYPE_V8SF_ROUND },
24956   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_ceilps256", IX86_BUILTIN_CEILPS256, (enum rtx_code) ROUND_CEIL, (int) V8SF_FTYPE_V8SF_ROUND },
24957   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_truncps256", IX86_BUILTIN_TRUNCPS256, (enum rtx_code) ROUND_TRUNC, (int) V8SF_FTYPE_V8SF_ROUND },
24958   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_rintps256", IX86_BUILTIN_RINTPS256, (enum rtx_code) ROUND_MXCSR, (int) V8SF_FTYPE_V8SF_ROUND },
24959
24960   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhpd256,  "__builtin_ia32_unpckhpd256", IX86_BUILTIN_UNPCKHPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24961   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklpd256,  "__builtin_ia32_unpcklpd256", IX86_BUILTIN_UNPCKLPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24962   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhps256,  "__builtin_ia32_unpckhps256", IX86_BUILTIN_UNPCKHPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24963   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklps256,  "__builtin_ia32_unpcklps256", IX86_BUILTIN_UNPCKLPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24964
24965   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_si256_si, "__builtin_ia32_si256_si", IX86_BUILTIN_SI256_SI, UNKNOWN, (int) V8SI_FTYPE_V4SI },
24966   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ps256_ps, "__builtin_ia32_ps256_ps", IX86_BUILTIN_PS256_PS, UNKNOWN, (int) V8SF_FTYPE_V4SF },
24967   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_pd256_pd, "__builtin_ia32_pd256_pd", IX86_BUILTIN_PD256_PD, UNKNOWN, (int) V4DF_FTYPE_V2DF },
24968   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8si, "__builtin_ia32_si_si256", IX86_BUILTIN_SI_SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI },
24969   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8sf, "__builtin_ia32_ps_ps256", IX86_BUILTIN_PS_PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF },
24970   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v4df, "__builtin_ia32_pd_pd256", IX86_BUILTIN_PD_PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF },
24971
24972   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestzpd", IX86_BUILTIN_VTESTZPD, EQ, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24973   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestcpd", IX86_BUILTIN_VTESTCPD, LTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24974   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestnzcpd", IX86_BUILTIN_VTESTNZCPD, GTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
24975   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestzps", IX86_BUILTIN_VTESTZPS, EQ, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24976   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestcps", IX86_BUILTIN_VTESTCPS, LTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24977   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestnzcps", IX86_BUILTIN_VTESTNZCPS, GTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
24978   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestzpd256", IX86_BUILTIN_VTESTZPD256, EQ, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24979   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestcpd256", IX86_BUILTIN_VTESTCPD256, LTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24980   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestnzcpd256", IX86_BUILTIN_VTESTNZCPD256, GTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
24981   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestzps256", IX86_BUILTIN_VTESTZPS256, EQ, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24982   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestcps256", IX86_BUILTIN_VTESTCPS256, LTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24983   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestnzcps256", IX86_BUILTIN_VTESTNZCPS256, GTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
24984   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestz256", IX86_BUILTIN_PTESTZ256, EQ, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24985   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestc256", IX86_BUILTIN_PTESTC256, LTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24986   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestnzc256", IX86_BUILTIN_PTESTNZC256, GTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
24987
24988   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskpd256, "__builtin_ia32_movmskpd256", IX86_BUILTIN_MOVMSKPD256, UNKNOWN, (int) INT_FTYPE_V4DF  },
24989   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskps256, "__builtin_ia32_movmskps256", IX86_BUILTIN_MOVMSKPS256, UNKNOWN, (int) INT_FTYPE_V8SF },
24990
24991   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv8sf3,  "__builtin_ia32_copysignps256", IX86_BUILTIN_CPYSGNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
24992   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv4df3,  "__builtin_ia32_copysignpd256", IX86_BUILTIN_CPYSGNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
24993
24994   { OPTION_MASK_ISA_LZCNT, CODE_FOR_clzhi2_lzcnt,   "__builtin_clzs",   IX86_BUILTIN_CLZS,    UNKNOWN,     (int) UINT16_FTYPE_UINT16 },
24995
24996   /* BMI */
24997   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_si, "__builtin_ia32_bextr_u32", IX86_BUILTIN_BEXTR32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
24998   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_di, "__builtin_ia32_bextr_u64", IX86_BUILTIN_BEXTR64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
24999   { OPTION_MASK_ISA_BMI, CODE_FOR_ctzhi2,       "__builtin_ctzs",           IX86_BUILTIN_CTZS,    UNKNOWN, (int) UINT16_FTYPE_UINT16 },
25000
25001   /* TBM */
25002   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_si, "__builtin_ia32_bextri_u32", IX86_BUILTIN_BEXTRI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
25003   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_di, "__builtin_ia32_bextri_u64", IX86_BUILTIN_BEXTRI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
25004
25005   /* F16C */
25006   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps, "__builtin_ia32_vcvtph2ps", IX86_BUILTIN_CVTPH2PS, UNKNOWN, (int) V4SF_FTYPE_V8HI },
25007   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps256, "__builtin_ia32_vcvtph2ps256", IX86_BUILTIN_CVTPH2PS256, UNKNOWN, (int) V8SF_FTYPE_V8HI },
25008   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph, "__builtin_ia32_vcvtps2ph", IX86_BUILTIN_CVTPS2PH, UNKNOWN, (int) V8HI_FTYPE_V4SF_INT },
25009   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph256, "__builtin_ia32_vcvtps2ph256", IX86_BUILTIN_CVTPS2PH256, UNKNOWN, (int) V8HI_FTYPE_V8SF_INT },
25010 };
25011
25012 /* FMA4 and XOP.  */
25013 #define MULTI_ARG_4_DF2_DI_I    V2DF_FTYPE_V2DF_V2DF_V2DI_INT
25014 #define MULTI_ARG_4_DF2_DI_I1   V4DF_FTYPE_V4DF_V4DF_V4DI_INT
25015 #define MULTI_ARG_4_SF2_SI_I    V4SF_FTYPE_V4SF_V4SF_V4SI_INT
25016 #define MULTI_ARG_4_SF2_SI_I1   V8SF_FTYPE_V8SF_V8SF_V8SI_INT
25017 #define MULTI_ARG_3_SF          V4SF_FTYPE_V4SF_V4SF_V4SF
25018 #define MULTI_ARG_3_DF          V2DF_FTYPE_V2DF_V2DF_V2DF
25019 #define MULTI_ARG_3_SF2         V8SF_FTYPE_V8SF_V8SF_V8SF
25020 #define MULTI_ARG_3_DF2         V4DF_FTYPE_V4DF_V4DF_V4DF
25021 #define MULTI_ARG_3_DI          V2DI_FTYPE_V2DI_V2DI_V2DI
25022 #define MULTI_ARG_3_SI          V4SI_FTYPE_V4SI_V4SI_V4SI
25023 #define MULTI_ARG_3_SI_DI       V4SI_FTYPE_V4SI_V4SI_V2DI
25024 #define MULTI_ARG_3_HI          V8HI_FTYPE_V8HI_V8HI_V8HI
25025 #define MULTI_ARG_3_HI_SI       V8HI_FTYPE_V8HI_V8HI_V4SI
25026 #define MULTI_ARG_3_QI          V16QI_FTYPE_V16QI_V16QI_V16QI
25027 #define MULTI_ARG_3_DI2         V4DI_FTYPE_V4DI_V4DI_V4DI
25028 #define MULTI_ARG_3_SI2         V8SI_FTYPE_V8SI_V8SI_V8SI
25029 #define MULTI_ARG_3_HI2         V16HI_FTYPE_V16HI_V16HI_V16HI
25030 #define MULTI_ARG_3_QI2         V32QI_FTYPE_V32QI_V32QI_V32QI
25031 #define MULTI_ARG_2_SF          V4SF_FTYPE_V4SF_V4SF
25032 #define MULTI_ARG_2_DF          V2DF_FTYPE_V2DF_V2DF
25033 #define MULTI_ARG_2_DI          V2DI_FTYPE_V2DI_V2DI
25034 #define MULTI_ARG_2_SI          V4SI_FTYPE_V4SI_V4SI
25035 #define MULTI_ARG_2_HI          V8HI_FTYPE_V8HI_V8HI
25036 #define MULTI_ARG_2_QI          V16QI_FTYPE_V16QI_V16QI
25037 #define MULTI_ARG_2_DI_IMM      V2DI_FTYPE_V2DI_SI
25038 #define MULTI_ARG_2_SI_IMM      V4SI_FTYPE_V4SI_SI
25039 #define MULTI_ARG_2_HI_IMM      V8HI_FTYPE_V8HI_SI
25040 #define MULTI_ARG_2_QI_IMM      V16QI_FTYPE_V16QI_SI
25041 #define MULTI_ARG_2_DI_CMP      V2DI_FTYPE_V2DI_V2DI_CMP
25042 #define MULTI_ARG_2_SI_CMP      V4SI_FTYPE_V4SI_V4SI_CMP
25043 #define MULTI_ARG_2_HI_CMP      V8HI_FTYPE_V8HI_V8HI_CMP
25044 #define MULTI_ARG_2_QI_CMP      V16QI_FTYPE_V16QI_V16QI_CMP
25045 #define MULTI_ARG_2_SF_TF       V4SF_FTYPE_V4SF_V4SF_TF
25046 #define MULTI_ARG_2_DF_TF       V2DF_FTYPE_V2DF_V2DF_TF
25047 #define MULTI_ARG_2_DI_TF       V2DI_FTYPE_V2DI_V2DI_TF
25048 #define MULTI_ARG_2_SI_TF       V4SI_FTYPE_V4SI_V4SI_TF
25049 #define MULTI_ARG_2_HI_TF       V8HI_FTYPE_V8HI_V8HI_TF
25050 #define MULTI_ARG_2_QI_TF       V16QI_FTYPE_V16QI_V16QI_TF
25051 #define MULTI_ARG_1_SF          V4SF_FTYPE_V4SF
25052 #define MULTI_ARG_1_DF          V2DF_FTYPE_V2DF
25053 #define MULTI_ARG_1_SF2         V8SF_FTYPE_V8SF
25054 #define MULTI_ARG_1_DF2         V4DF_FTYPE_V4DF
25055 #define MULTI_ARG_1_DI          V2DI_FTYPE_V2DI
25056 #define MULTI_ARG_1_SI          V4SI_FTYPE_V4SI
25057 #define MULTI_ARG_1_HI          V8HI_FTYPE_V8HI
25058 #define MULTI_ARG_1_QI          V16QI_FTYPE_V16QI
25059 #define MULTI_ARG_1_SI_DI       V2DI_FTYPE_V4SI
25060 #define MULTI_ARG_1_HI_DI       V2DI_FTYPE_V8HI
25061 #define MULTI_ARG_1_HI_SI       V4SI_FTYPE_V8HI
25062 #define MULTI_ARG_1_QI_DI       V2DI_FTYPE_V16QI
25063 #define MULTI_ARG_1_QI_SI       V4SI_FTYPE_V16QI
25064 #define MULTI_ARG_1_QI_HI       V8HI_FTYPE_V16QI
25065
25066 static const struct builtin_description bdesc_multi_arg[] =
25067 {
25068   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v4sf,
25069     "__builtin_ia32_vfmaddss", IX86_BUILTIN_VFMADDSS,
25070     UNKNOWN, (int)MULTI_ARG_3_SF },
25071   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v2df,
25072     "__builtin_ia32_vfmaddsd", IX86_BUILTIN_VFMADDSD,
25073     UNKNOWN, (int)MULTI_ARG_3_DF },
25074
25075   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4sf,
25076     "__builtin_ia32_vfmaddps", IX86_BUILTIN_VFMADDPS,
25077     UNKNOWN, (int)MULTI_ARG_3_SF },
25078   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v2df,
25079     "__builtin_ia32_vfmaddpd", IX86_BUILTIN_VFMADDPD,
25080     UNKNOWN, (int)MULTI_ARG_3_DF },
25081   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v8sf,
25082     "__builtin_ia32_vfmaddps256", IX86_BUILTIN_VFMADDPS256,
25083     UNKNOWN, (int)MULTI_ARG_3_SF2 },
25084   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4df,
25085     "__builtin_ia32_vfmaddpd256", IX86_BUILTIN_VFMADDPD256,
25086     UNKNOWN, (int)MULTI_ARG_3_DF2 },
25087
25088   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4sf,
25089     "__builtin_ia32_vfmaddsubps", IX86_BUILTIN_VFMADDSUBPS,
25090     UNKNOWN, (int)MULTI_ARG_3_SF },
25091   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v2df,
25092     "__builtin_ia32_vfmaddsubpd", IX86_BUILTIN_VFMADDSUBPD,
25093     UNKNOWN, (int)MULTI_ARG_3_DF },
25094   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v8sf,
25095     "__builtin_ia32_vfmaddsubps256", IX86_BUILTIN_VFMADDSUBPS256,
25096     UNKNOWN, (int)MULTI_ARG_3_SF2 },
25097   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4df,
25098     "__builtin_ia32_vfmaddsubpd256", IX86_BUILTIN_VFMADDSUBPD256,
25099     UNKNOWN, (int)MULTI_ARG_3_DF2 },
25100
25101   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov",      IX86_BUILTIN_VPCMOV,      UNKNOWN,      (int)MULTI_ARG_3_DI },
25102   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov_v2di", IX86_BUILTIN_VPCMOV_V2DI, UNKNOWN,      (int)MULTI_ARG_3_DI },
25103   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4si,        "__builtin_ia32_vpcmov_v4si", IX86_BUILTIN_VPCMOV_V4SI, UNKNOWN,      (int)MULTI_ARG_3_SI },
25104   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8hi,        "__builtin_ia32_vpcmov_v8hi", IX86_BUILTIN_VPCMOV_V8HI, UNKNOWN,      (int)MULTI_ARG_3_HI },
25105   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16qi,       "__builtin_ia32_vpcmov_v16qi",IX86_BUILTIN_VPCMOV_V16QI,UNKNOWN,      (int)MULTI_ARG_3_QI },
25106   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2df,        "__builtin_ia32_vpcmov_v2df", IX86_BUILTIN_VPCMOV_V2DF, UNKNOWN,      (int)MULTI_ARG_3_DF },
25107   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4sf,        "__builtin_ia32_vpcmov_v4sf", IX86_BUILTIN_VPCMOV_V4SF, UNKNOWN,      (int)MULTI_ARG_3_SF },
25108
25109   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov256",       IX86_BUILTIN_VPCMOV256,       UNKNOWN,      (int)MULTI_ARG_3_DI2 },
25110   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov_v4di256",  IX86_BUILTIN_VPCMOV_V4DI256,  UNKNOWN,      (int)MULTI_ARG_3_DI2 },
25111   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8si256,        "__builtin_ia32_vpcmov_v8si256",  IX86_BUILTIN_VPCMOV_V8SI256,  UNKNOWN,      (int)MULTI_ARG_3_SI2 },
25112   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16hi256,       "__builtin_ia32_vpcmov_v16hi256", IX86_BUILTIN_VPCMOV_V16HI256, UNKNOWN,      (int)MULTI_ARG_3_HI2 },
25113   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v32qi256,       "__builtin_ia32_vpcmov_v32qi256", IX86_BUILTIN_VPCMOV_V32QI256, UNKNOWN,      (int)MULTI_ARG_3_QI2 },
25114   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4df256,        "__builtin_ia32_vpcmov_v4df256",  IX86_BUILTIN_VPCMOV_V4DF256,  UNKNOWN,      (int)MULTI_ARG_3_DF2 },
25115   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8sf256,        "__builtin_ia32_vpcmov_v8sf256",  IX86_BUILTIN_VPCMOV_V8SF256,  UNKNOWN,      (int)MULTI_ARG_3_SF2 },
25116
25117   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pperm,             "__builtin_ia32_vpperm",      IX86_BUILTIN_VPPERM,      UNKNOWN,      (int)MULTI_ARG_3_QI },
25118
25119   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssww,          "__builtin_ia32_vpmacssww",   IX86_BUILTIN_VPMACSSWW,   UNKNOWN,      (int)MULTI_ARG_3_HI },
25120   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsww,           "__builtin_ia32_vpmacsww",    IX86_BUILTIN_VPMACSWW,    UNKNOWN,      (int)MULTI_ARG_3_HI },
25121   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsswd,          "__builtin_ia32_vpmacsswd",   IX86_BUILTIN_VPMACSSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25122   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacswd,           "__builtin_ia32_vpmacswd",    IX86_BUILTIN_VPMACSWD,    UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25123   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdd,          "__builtin_ia32_vpmacssdd",   IX86_BUILTIN_VPMACSSDD,   UNKNOWN,      (int)MULTI_ARG_3_SI },
25124   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdd,           "__builtin_ia32_vpmacsdd",    IX86_BUILTIN_VPMACSDD,    UNKNOWN,      (int)MULTI_ARG_3_SI },
25125   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdql,         "__builtin_ia32_vpmacssdql",  IX86_BUILTIN_VPMACSSDQL,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25126   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdqh,         "__builtin_ia32_vpmacssdqh",  IX86_BUILTIN_VPMACSSDQH,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25127   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdql,          "__builtin_ia32_vpmacsdql",   IX86_BUILTIN_VPMACSDQL,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25128   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdqh,          "__builtin_ia32_vpmacsdqh",   IX86_BUILTIN_VPMACSDQH,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
25129   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcsswd,         "__builtin_ia32_vpmadcsswd",  IX86_BUILTIN_VPMADCSSWD,  UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25130   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcswd,          "__builtin_ia32_vpmadcswd",   IX86_BUILTIN_VPMADCSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
25131
25132   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv2di3,        "__builtin_ia32_vprotq",      IX86_BUILTIN_VPROTQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25133   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv4si3,        "__builtin_ia32_vprotd",      IX86_BUILTIN_VPROTD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25134   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv8hi3,        "__builtin_ia32_vprotw",      IX86_BUILTIN_VPROTW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25135   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv16qi3,       "__builtin_ia32_vprotb",      IX86_BUILTIN_VPROTB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25136   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv2di3,         "__builtin_ia32_vprotqi",     IX86_BUILTIN_VPROTQ_IMM,  UNKNOWN,      (int)MULTI_ARG_2_DI_IMM },
25137   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv4si3,         "__builtin_ia32_vprotdi",     IX86_BUILTIN_VPROTD_IMM,  UNKNOWN,      (int)MULTI_ARG_2_SI_IMM },
25138   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv8hi3,         "__builtin_ia32_vprotwi",     IX86_BUILTIN_VPROTW_IMM,  UNKNOWN,      (int)MULTI_ARG_2_HI_IMM },
25139   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv16qi3,        "__builtin_ia32_vprotbi",     IX86_BUILTIN_VPROTB_IMM,  UNKNOWN,      (int)MULTI_ARG_2_QI_IMM },
25140   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv2di3,         "__builtin_ia32_vpshaq",      IX86_BUILTIN_VPSHAQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25141   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv4si3,         "__builtin_ia32_vpshad",      IX86_BUILTIN_VPSHAD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25142   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv8hi3,         "__builtin_ia32_vpshaw",      IX86_BUILTIN_VPSHAW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25143   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_ashlv16qi3,        "__builtin_ia32_vpshab",      IX86_BUILTIN_VPSHAB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25144   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv2di3,         "__builtin_ia32_vpshlq",      IX86_BUILTIN_VPSHLQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
25145   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv4si3,         "__builtin_ia32_vpshld",      IX86_BUILTIN_VPSHLD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
25146   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv8hi3,         "__builtin_ia32_vpshlw",      IX86_BUILTIN_VPSHLW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
25147   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_lshlv16qi3,        "__builtin_ia32_vpshlb",      IX86_BUILTIN_VPSHLB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
25148
25149   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv4sf2,       "__builtin_ia32_vfrczss",     IX86_BUILTIN_VFRCZSS,     UNKNOWN,      (int)MULTI_ARG_2_SF },
25150   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv2df2,       "__builtin_ia32_vfrczsd",     IX86_BUILTIN_VFRCZSD,     UNKNOWN,      (int)MULTI_ARG_2_DF },
25151   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4sf2,         "__builtin_ia32_vfrczps",     IX86_BUILTIN_VFRCZPS,     UNKNOWN,      (int)MULTI_ARG_1_SF },
25152   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv2df2,         "__builtin_ia32_vfrczpd",     IX86_BUILTIN_VFRCZPD,     UNKNOWN,      (int)MULTI_ARG_1_DF },
25153   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv8sf2,         "__builtin_ia32_vfrczps256",  IX86_BUILTIN_VFRCZPS256,  UNKNOWN,      (int)MULTI_ARG_1_SF2 },
25154   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4df2,         "__builtin_ia32_vfrczpd256",  IX86_BUILTIN_VFRCZPD256,  UNKNOWN,      (int)MULTI_ARG_1_DF2 },
25155
25156   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbw,           "__builtin_ia32_vphaddbw",    IX86_BUILTIN_VPHADDBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25157   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbd,           "__builtin_ia32_vphaddbd",    IX86_BUILTIN_VPHADDBD,    UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
25158   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbq,           "__builtin_ia32_vphaddbq",    IX86_BUILTIN_VPHADDBQ,    UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
25159   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwd,           "__builtin_ia32_vphaddwd",    IX86_BUILTIN_VPHADDWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25160   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwq,           "__builtin_ia32_vphaddwq",    IX86_BUILTIN_VPHADDWQ,    UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
25161   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadddq,           "__builtin_ia32_vphadddq",    IX86_BUILTIN_VPHADDDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25162   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubw,          "__builtin_ia32_vphaddubw",   IX86_BUILTIN_VPHADDUBW,   UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25163   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubd,          "__builtin_ia32_vphaddubd",   IX86_BUILTIN_VPHADDUBD,   UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
25164   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubq,          "__builtin_ia32_vphaddubq",   IX86_BUILTIN_VPHADDUBQ,   UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
25165   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwd,          "__builtin_ia32_vphadduwd",   IX86_BUILTIN_VPHADDUWD,   UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25166   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwq,          "__builtin_ia32_vphadduwq",   IX86_BUILTIN_VPHADDUWQ,   UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
25167   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddudq,          "__builtin_ia32_vphaddudq",   IX86_BUILTIN_VPHADDUDQ,   UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25168   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubbw,           "__builtin_ia32_vphsubbw",    IX86_BUILTIN_VPHSUBBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
25169   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubwd,           "__builtin_ia32_vphsubwd",    IX86_BUILTIN_VPHSUBWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
25170   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubdq,           "__builtin_ia32_vphsubdq",    IX86_BUILTIN_VPHSUBDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
25171
25172   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomeqb",    IX86_BUILTIN_VPCOMEQB,    EQ,           (int)MULTI_ARG_2_QI_CMP },
25173   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneb",    IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
25174   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneqb",   IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
25175   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomltb",    IX86_BUILTIN_VPCOMLTB,    LT,           (int)MULTI_ARG_2_QI_CMP },
25176   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomleb",    IX86_BUILTIN_VPCOMLEB,    LE,           (int)MULTI_ARG_2_QI_CMP },
25177   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgtb",    IX86_BUILTIN_VPCOMGTB,    GT,           (int)MULTI_ARG_2_QI_CMP },
25178   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgeb",    IX86_BUILTIN_VPCOMGEB,    GE,           (int)MULTI_ARG_2_QI_CMP },
25179
25180   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomeqw",    IX86_BUILTIN_VPCOMEQW,    EQ,           (int)MULTI_ARG_2_HI_CMP },
25181   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomnew",    IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
25182   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomneqw",   IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
25183   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomltw",    IX86_BUILTIN_VPCOMLTW,    LT,           (int)MULTI_ARG_2_HI_CMP },
25184   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomlew",    IX86_BUILTIN_VPCOMLEW,    LE,           (int)MULTI_ARG_2_HI_CMP },
25185   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgtw",    IX86_BUILTIN_VPCOMGTW,    GT,           (int)MULTI_ARG_2_HI_CMP },
25186   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgew",    IX86_BUILTIN_VPCOMGEW,    GE,           (int)MULTI_ARG_2_HI_CMP },
25187
25188   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomeqd",    IX86_BUILTIN_VPCOMEQD,    EQ,           (int)MULTI_ARG_2_SI_CMP },
25189   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomned",    IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
25190   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomneqd",   IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
25191   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomltd",    IX86_BUILTIN_VPCOMLTD,    LT,           (int)MULTI_ARG_2_SI_CMP },
25192   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomled",    IX86_BUILTIN_VPCOMLED,    LE,           (int)MULTI_ARG_2_SI_CMP },
25193   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomgtd",    IX86_BUILTIN_VPCOMGTD,    GT,           (int)MULTI_ARG_2_SI_CMP },
25194   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomged",    IX86_BUILTIN_VPCOMGED,    GE,           (int)MULTI_ARG_2_SI_CMP },
25195
25196   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomeqq",    IX86_BUILTIN_VPCOMEQQ,    EQ,           (int)MULTI_ARG_2_DI_CMP },
25197   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneq",    IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
25198   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneqq",   IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
25199   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomltq",    IX86_BUILTIN_VPCOMLTQ,    LT,           (int)MULTI_ARG_2_DI_CMP },
25200   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomleq",    IX86_BUILTIN_VPCOMLEQ,    LE,           (int)MULTI_ARG_2_DI_CMP },
25201   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgtq",    IX86_BUILTIN_VPCOMGTQ,    GT,           (int)MULTI_ARG_2_DI_CMP },
25202   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgeq",    IX86_BUILTIN_VPCOMGEQ,    GE,           (int)MULTI_ARG_2_DI_CMP },
25203
25204   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomequb",   IX86_BUILTIN_VPCOMEQUB,   EQ,           (int)MULTI_ARG_2_QI_CMP },
25205   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomneub",   IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
25206   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomnequb",  IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
25207   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomltub",   IX86_BUILTIN_VPCOMLTUB,   LTU,          (int)MULTI_ARG_2_QI_CMP },
25208   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomleub",   IX86_BUILTIN_VPCOMLEUB,   LEU,          (int)MULTI_ARG_2_QI_CMP },
25209   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgtub",   IX86_BUILTIN_VPCOMGTUB,   GTU,          (int)MULTI_ARG_2_QI_CMP },
25210   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgeub",   IX86_BUILTIN_VPCOMGEUB,   GEU,          (int)MULTI_ARG_2_QI_CMP },
25211
25212   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomequw",   IX86_BUILTIN_VPCOMEQUW,   EQ,           (int)MULTI_ARG_2_HI_CMP },
25213   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomneuw",   IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
25214   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomnequw",  IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
25215   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomltuw",   IX86_BUILTIN_VPCOMLTUW,   LTU,          (int)MULTI_ARG_2_HI_CMP },
25216   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomleuw",   IX86_BUILTIN_VPCOMLEUW,   LEU,          (int)MULTI_ARG_2_HI_CMP },
25217   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgtuw",   IX86_BUILTIN_VPCOMGTUW,   GTU,          (int)MULTI_ARG_2_HI_CMP },
25218   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgeuw",   IX86_BUILTIN_VPCOMGEUW,   GEU,          (int)MULTI_ARG_2_HI_CMP },
25219
25220   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomequd",   IX86_BUILTIN_VPCOMEQUD,   EQ,           (int)MULTI_ARG_2_SI_CMP },
25221   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomneud",   IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
25222   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomnequd",  IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
25223   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomltud",   IX86_BUILTIN_VPCOMLTUD,   LTU,          (int)MULTI_ARG_2_SI_CMP },
25224   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomleud",   IX86_BUILTIN_VPCOMLEUD,   LEU,          (int)MULTI_ARG_2_SI_CMP },
25225   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgtud",   IX86_BUILTIN_VPCOMGTUD,   GTU,          (int)MULTI_ARG_2_SI_CMP },
25226   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgeud",   IX86_BUILTIN_VPCOMGEUD,   GEU,          (int)MULTI_ARG_2_SI_CMP },
25227
25228   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomequq",   IX86_BUILTIN_VPCOMEQUQ,   EQ,           (int)MULTI_ARG_2_DI_CMP },
25229   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomneuq",   IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
25230   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomnequq",  IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
25231   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomltuq",   IX86_BUILTIN_VPCOMLTUQ,   LTU,          (int)MULTI_ARG_2_DI_CMP },
25232   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomleuq",   IX86_BUILTIN_VPCOMLEUQ,   LEU,          (int)MULTI_ARG_2_DI_CMP },
25233   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgtuq",   IX86_BUILTIN_VPCOMGTUQ,   GTU,          (int)MULTI_ARG_2_DI_CMP },
25234   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgeuq",   IX86_BUILTIN_VPCOMGEUQ,   GEU,          (int)MULTI_ARG_2_DI_CMP },
25235
25236   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv16qi3,     "__builtin_ia32_vpcomfalseb", IX86_BUILTIN_VPCOMFALSEB, (enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_QI_TF },
25237   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv8hi3,      "__builtin_ia32_vpcomfalsew", IX86_BUILTIN_VPCOMFALSEW, (enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_HI_TF },
25238   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv4si3,      "__builtin_ia32_vpcomfalsed", IX86_BUILTIN_VPCOMFALSED, (enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_SI_TF },
25239   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv2di3,      "__builtin_ia32_vpcomfalseq", IX86_BUILTIN_VPCOMFALSEQ, (enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_DI_TF },
25240   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv16qi3,     "__builtin_ia32_vpcomfalseub",IX86_BUILTIN_VPCOMFALSEUB,(enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_QI_TF },
25241   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv8hi3,      "__builtin_ia32_vpcomfalseuw",IX86_BUILTIN_VPCOMFALSEUW,(enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_HI_TF },
25242   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv4si3,      "__builtin_ia32_vpcomfalseud",IX86_BUILTIN_VPCOMFALSEUD,(enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_SI_TF },
25243   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv2di3,      "__builtin_ia32_vpcomfalseuq",IX86_BUILTIN_VPCOMFALSEUQ,(enum rtx_code) PCOM_FALSE,   (int)MULTI_ARG_2_DI_TF },
25244
25245   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv16qi3,     "__builtin_ia32_vpcomtrueb",  IX86_BUILTIN_VPCOMTRUEB,  (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_QI_TF },
25246   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv8hi3,      "__builtin_ia32_vpcomtruew",  IX86_BUILTIN_VPCOMTRUEW,  (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_HI_TF },
25247   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv4si3,      "__builtin_ia32_vpcomtrued",  IX86_BUILTIN_VPCOMTRUED,  (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_SI_TF },
25248   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv2di3,      "__builtin_ia32_vpcomtrueq",  IX86_BUILTIN_VPCOMTRUEQ,  (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_DI_TF },
25249   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv16qi3,     "__builtin_ia32_vpcomtrueub", IX86_BUILTIN_VPCOMTRUEUB, (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_QI_TF },
25250   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv8hi3,      "__builtin_ia32_vpcomtrueuw", IX86_BUILTIN_VPCOMTRUEUW, (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_HI_TF },
25251   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv4si3,      "__builtin_ia32_vpcomtrueud", IX86_BUILTIN_VPCOMTRUEUD, (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_SI_TF },
25252   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcom_tfv2di3,      "__builtin_ia32_vpcomtrueuq", IX86_BUILTIN_VPCOMTRUEUQ, (enum rtx_code) PCOM_TRUE,    (int)MULTI_ARG_2_DI_TF },
25253
25254   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v2df3,     "__builtin_ia32_vpermil2pd",  IX86_BUILTIN_VPERMIL2PD, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I },
25255   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4sf3,     "__builtin_ia32_vpermil2ps",  IX86_BUILTIN_VPERMIL2PS, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I },
25256   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4df3,     "__builtin_ia32_vpermil2pd256", IX86_BUILTIN_VPERMIL2PD256, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I1 },
25257   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v8sf3,     "__builtin_ia32_vpermil2ps256", IX86_BUILTIN_VPERMIL2PS256, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I1 },
25258
25259 };
25260
25261 /* Set up all the MMX/SSE builtins, even builtins for instructions that are not
25262    in the current target ISA to allow the user to compile particular modules
25263    with different target specific options that differ from the command line
25264    options.  */
25265 static void
25266 ix86_init_mmx_sse_builtins (void)
25267 {
25268   const struct builtin_description * d;
25269   enum ix86_builtin_func_type ftype;
25270   size_t i;
25271
25272   /* Add all special builtins with variable number of operands.  */
25273   for (i = 0, d = bdesc_special_args;
25274        i < ARRAY_SIZE (bdesc_special_args);
25275        i++, d++)
25276     {
25277       if (d->name == 0)
25278         continue;
25279
25280       ftype = (enum ix86_builtin_func_type) d->flag;
25281       def_builtin (d->mask, d->name, ftype, d->code);
25282     }
25283
25284   /* Add all builtins with variable number of operands.  */
25285   for (i = 0, d = bdesc_args;
25286        i < ARRAY_SIZE (bdesc_args);
25287        i++, d++)
25288     {
25289       if (d->name == 0)
25290         continue;
25291
25292       ftype = (enum ix86_builtin_func_type) d->flag;
25293       def_builtin_const (d->mask, d->name, ftype, d->code);
25294     }
25295
25296   /* pcmpestr[im] insns.  */
25297   for (i = 0, d = bdesc_pcmpestr;
25298        i < ARRAY_SIZE (bdesc_pcmpestr);
25299        i++, d++)
25300     {
25301       if (d->code == IX86_BUILTIN_PCMPESTRM128)
25302         ftype = V16QI_FTYPE_V16QI_INT_V16QI_INT_INT;
25303       else
25304         ftype = INT_FTYPE_V16QI_INT_V16QI_INT_INT;
25305       def_builtin_const (d->mask, d->name, ftype, d->code);
25306     }
25307
25308   /* pcmpistr[im] insns.  */
25309   for (i = 0, d = bdesc_pcmpistr;
25310        i < ARRAY_SIZE (bdesc_pcmpistr);
25311        i++, d++)
25312     {
25313       if (d->code == IX86_BUILTIN_PCMPISTRM128)
25314         ftype = V16QI_FTYPE_V16QI_V16QI_INT;
25315       else
25316         ftype = INT_FTYPE_V16QI_V16QI_INT;
25317       def_builtin_const (d->mask, d->name, ftype, d->code);
25318     }
25319
25320   /* comi/ucomi insns.  */
25321   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
25322     {
25323       if (d->mask == OPTION_MASK_ISA_SSE2)
25324         ftype = INT_FTYPE_V2DF_V2DF;
25325       else
25326         ftype = INT_FTYPE_V4SF_V4SF;
25327       def_builtin_const (d->mask, d->name, ftype, d->code);
25328     }
25329
25330   /* SSE */
25331   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr",
25332                VOID_FTYPE_UNSIGNED, IX86_BUILTIN_LDMXCSR);
25333   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr",
25334                UNSIGNED_FTYPE_VOID, IX86_BUILTIN_STMXCSR);
25335
25336   /* SSE or 3DNow!A */
25337   def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25338                "__builtin_ia32_maskmovq", VOID_FTYPE_V8QI_V8QI_PCHAR,
25339                IX86_BUILTIN_MASKMOVQ);
25340
25341   /* SSE2 */
25342   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu",
25343                VOID_FTYPE_V16QI_V16QI_PCHAR, IX86_BUILTIN_MASKMOVDQU);
25344
25345   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush",
25346                VOID_FTYPE_PCVOID, IX86_BUILTIN_CLFLUSH);
25347   x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence",
25348                             VOID_FTYPE_VOID, IX86_BUILTIN_MFENCE);
25349
25350   /* SSE3.  */
25351   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor",
25352                VOID_FTYPE_PCVOID_UNSIGNED_UNSIGNED, IX86_BUILTIN_MONITOR);
25353   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait",
25354                VOID_FTYPE_UNSIGNED_UNSIGNED, IX86_BUILTIN_MWAIT);
25355
25356   /* AES */
25357   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128",
25358                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENC128);
25359   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128",
25360                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENCLAST128);
25361   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128",
25362                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDEC128);
25363   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128",
25364                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDECLAST128);
25365   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128",
25366                      V2DI_FTYPE_V2DI, IX86_BUILTIN_AESIMC128);
25367   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128",
25368                      V2DI_FTYPE_V2DI_INT, IX86_BUILTIN_AESKEYGENASSIST128);
25369
25370   /* PCLMUL */
25371   def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128",
25372                      V2DI_FTYPE_V2DI_V2DI_INT, IX86_BUILTIN_PCLMULQDQ128);
25373
25374   /* RDRND */
25375   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand16_step",
25376                INT_FTYPE_PUSHORT, IX86_BUILTIN_RDRAND16_STEP);
25377   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand32_step",
25378                INT_FTYPE_PUNSIGNED, IX86_BUILTIN_RDRAND32_STEP);
25379   def_builtin (OPTION_MASK_ISA_RDRND | OPTION_MASK_ISA_64BIT,
25380                "__builtin_ia32_rdrand64_step", INT_FTYPE_PULONGLONG,
25381                IX86_BUILTIN_RDRAND64_STEP);
25382
25383   /* MMX access to the vec_init patterns.  */
25384   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si",
25385                      V2SI_FTYPE_INT_INT, IX86_BUILTIN_VEC_INIT_V2SI);
25386
25387   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi",
25388                      V4HI_FTYPE_HI_HI_HI_HI,
25389                      IX86_BUILTIN_VEC_INIT_V4HI);
25390
25391   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi",
25392                      V8QI_FTYPE_QI_QI_QI_QI_QI_QI_QI_QI,
25393                      IX86_BUILTIN_VEC_INIT_V8QI);
25394
25395   /* Access to the vec_extract patterns.  */
25396   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df",
25397                      DOUBLE_FTYPE_V2DF_INT, IX86_BUILTIN_VEC_EXT_V2DF);
25398   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di",
25399                      DI_FTYPE_V2DI_INT, IX86_BUILTIN_VEC_EXT_V2DI);
25400   def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf",
25401                      FLOAT_FTYPE_V4SF_INT, IX86_BUILTIN_VEC_EXT_V4SF);
25402   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si",
25403                      SI_FTYPE_V4SI_INT, IX86_BUILTIN_VEC_EXT_V4SI);
25404   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi",
25405                      HI_FTYPE_V8HI_INT, IX86_BUILTIN_VEC_EXT_V8HI);
25406
25407   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25408                      "__builtin_ia32_vec_ext_v4hi",
25409                      HI_FTYPE_V4HI_INT, IX86_BUILTIN_VEC_EXT_V4HI);
25410
25411   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si",
25412                      SI_FTYPE_V2SI_INT, IX86_BUILTIN_VEC_EXT_V2SI);
25413
25414   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi",
25415                      QI_FTYPE_V16QI_INT, IX86_BUILTIN_VEC_EXT_V16QI);
25416
25417   /* Access to the vec_set patterns.  */
25418   def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT,
25419                      "__builtin_ia32_vec_set_v2di",
25420                      V2DI_FTYPE_V2DI_DI_INT, IX86_BUILTIN_VEC_SET_V2DI);
25421
25422   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf",
25423                      V4SF_FTYPE_V4SF_FLOAT_INT, IX86_BUILTIN_VEC_SET_V4SF);
25424
25425   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si",
25426                      V4SI_FTYPE_V4SI_SI_INT, IX86_BUILTIN_VEC_SET_V4SI);
25427
25428   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi",
25429                      V8HI_FTYPE_V8HI_HI_INT, IX86_BUILTIN_VEC_SET_V8HI);
25430
25431   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
25432                      "__builtin_ia32_vec_set_v4hi",
25433                      V4HI_FTYPE_V4HI_HI_INT, IX86_BUILTIN_VEC_SET_V4HI);
25434
25435   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi",
25436                      V16QI_FTYPE_V16QI_QI_INT, IX86_BUILTIN_VEC_SET_V16QI);
25437
25438   /* Add FMA4 multi-arg argument instructions */
25439   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
25440     {
25441       if (d->name == 0)
25442         continue;
25443
25444       ftype = (enum ix86_builtin_func_type) d->flag;
25445       def_builtin_const (d->mask, d->name, ftype, d->code);
25446     }
25447 }
25448
25449 /* Internal method for ix86_init_builtins.  */
25450
25451 static void
25452 ix86_init_builtins_va_builtins_abi (void)
25453 {
25454   tree ms_va_ref, sysv_va_ref;
25455   tree fnvoid_va_end_ms, fnvoid_va_end_sysv;
25456   tree fnvoid_va_start_ms, fnvoid_va_start_sysv;
25457   tree fnvoid_va_copy_ms, fnvoid_va_copy_sysv;
25458   tree fnattr_ms = NULL_TREE, fnattr_sysv = NULL_TREE;
25459
25460   if (!TARGET_64BIT)
25461     return;
25462   fnattr_ms = build_tree_list (get_identifier ("ms_abi"), NULL_TREE);
25463   fnattr_sysv = build_tree_list (get_identifier ("sysv_abi"), NULL_TREE);
25464   ms_va_ref = build_reference_type (ms_va_list_type_node);
25465   sysv_va_ref =
25466     build_pointer_type (TREE_TYPE (sysv_va_list_type_node));
25467
25468   fnvoid_va_end_ms =
25469     build_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
25470   fnvoid_va_start_ms =
25471     build_varargs_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
25472   fnvoid_va_end_sysv =
25473     build_function_type_list (void_type_node, sysv_va_ref, NULL_TREE);
25474   fnvoid_va_start_sysv =
25475     build_varargs_function_type_list (void_type_node, sysv_va_ref,
25476                                        NULL_TREE);
25477   fnvoid_va_copy_ms =
25478     build_function_type_list (void_type_node, ms_va_ref, ms_va_list_type_node,
25479                               NULL_TREE);
25480   fnvoid_va_copy_sysv =
25481     build_function_type_list (void_type_node, sysv_va_ref,
25482                               sysv_va_ref, NULL_TREE);
25483
25484   add_builtin_function ("__builtin_ms_va_start", fnvoid_va_start_ms,
25485                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_ms);
25486   add_builtin_function ("__builtin_ms_va_end", fnvoid_va_end_ms,
25487                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_ms);
25488   add_builtin_function ("__builtin_ms_va_copy", fnvoid_va_copy_ms,
25489                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_ms);
25490   add_builtin_function ("__builtin_sysv_va_start", fnvoid_va_start_sysv,
25491                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25492   add_builtin_function ("__builtin_sysv_va_end", fnvoid_va_end_sysv,
25493                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25494   add_builtin_function ("__builtin_sysv_va_copy", fnvoid_va_copy_sysv,
25495                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_sysv);
25496 }
25497
25498 static void
25499 ix86_init_builtin_types (void)
25500 {
25501   tree float128_type_node, float80_type_node;
25502
25503   /* The __float80 type.  */
25504   float80_type_node = long_double_type_node;
25505   if (TYPE_MODE (float80_type_node) != XFmode)
25506     {
25507       /* The __float80 type.  */
25508       float80_type_node = make_node (REAL_TYPE);
25509
25510       TYPE_PRECISION (float80_type_node) = 80;
25511       layout_type (float80_type_node);
25512     }
25513   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
25514
25515   /* The __float128 type.  */
25516   float128_type_node = make_node (REAL_TYPE);
25517   TYPE_PRECISION (float128_type_node) = 128;
25518   layout_type (float128_type_node);
25519   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
25520
25521   /* This macro is built by i386-builtin-types.awk.  */
25522   DEFINE_BUILTIN_PRIMITIVE_TYPES;
25523 }
25524
25525 static void
25526 ix86_init_builtins (void)
25527 {
25528   tree t;
25529
25530   ix86_init_builtin_types ();
25531
25532   /* TFmode support builtins.  */
25533   def_builtin_const (0, "__builtin_infq",
25534                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_INFQ);
25535   def_builtin_const (0, "__builtin_huge_valq",
25536                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_HUGE_VALQ);
25537
25538   /* We will expand them to normal call if SSE2 isn't available since
25539      they are used by libgcc. */
25540   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128);
25541   t = add_builtin_function ("__builtin_fabsq", t, IX86_BUILTIN_FABSQ,
25542                             BUILT_IN_MD, "__fabstf2", NULL_TREE);
25543   TREE_READONLY (t) = 1;
25544   ix86_builtins[(int) IX86_BUILTIN_FABSQ] = t;
25545
25546   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128_FLOAT128);
25547   t = add_builtin_function ("__builtin_copysignq", t, IX86_BUILTIN_COPYSIGNQ,
25548                             BUILT_IN_MD, "__copysigntf3", NULL_TREE);
25549   TREE_READONLY (t) = 1;
25550   ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = t;
25551
25552   ix86_init_mmx_sse_builtins ();
25553
25554   if (TARGET_LP64)
25555     ix86_init_builtins_va_builtins_abi ();
25556
25557 #ifdef SUBTARGET_INIT_BUILTINS
25558   SUBTARGET_INIT_BUILTINS;
25559 #endif
25560 }
25561
25562 /* Return the ix86 builtin for CODE.  */
25563
25564 static tree
25565 ix86_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
25566 {
25567   if (code >= IX86_BUILTIN_MAX)
25568     return error_mark_node;
25569
25570   return ix86_builtins[code];
25571 }
25572
25573 /* Errors in the source file can cause expand_expr to return const0_rtx
25574    where we expect a vector.  To avoid crashing, use one of the vector
25575    clear instructions.  */
25576 static rtx
25577 safe_vector_operand (rtx x, enum machine_mode mode)
25578 {
25579   if (x == const0_rtx)
25580     x = CONST0_RTX (mode);
25581   return x;
25582 }
25583
25584 /* Subroutine of ix86_expand_builtin to take care of binop insns.  */
25585
25586 static rtx
25587 ix86_expand_binop_builtin (enum insn_code icode, tree exp, rtx target)
25588 {
25589   rtx pat;
25590   tree arg0 = CALL_EXPR_ARG (exp, 0);
25591   tree arg1 = CALL_EXPR_ARG (exp, 1);
25592   rtx op0 = expand_normal (arg0);
25593   rtx op1 = expand_normal (arg1);
25594   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25595   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
25596   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
25597
25598   if (VECTOR_MODE_P (mode0))
25599     op0 = safe_vector_operand (op0, mode0);
25600   if (VECTOR_MODE_P (mode1))
25601     op1 = safe_vector_operand (op1, mode1);
25602
25603   if (optimize || !target
25604       || GET_MODE (target) != tmode
25605       || !insn_data[icode].operand[0].predicate (target, tmode))
25606     target = gen_reg_rtx (tmode);
25607
25608   if (GET_MODE (op1) == SImode && mode1 == TImode)
25609     {
25610       rtx x = gen_reg_rtx (V4SImode);
25611       emit_insn (gen_sse2_loadd (x, op1));
25612       op1 = gen_lowpart (TImode, x);
25613     }
25614
25615   if (!insn_data[icode].operand[1].predicate (op0, mode0))
25616     op0 = copy_to_mode_reg (mode0, op0);
25617   if (!insn_data[icode].operand[2].predicate (op1, mode1))
25618     op1 = copy_to_mode_reg (mode1, op1);
25619
25620   pat = GEN_FCN (icode) (target, op0, op1);
25621   if (! pat)
25622     return 0;
25623
25624   emit_insn (pat);
25625
25626   return target;
25627 }
25628
25629 /* Subroutine of ix86_expand_builtin to take care of 2-4 argument insns.  */
25630
25631 static rtx
25632 ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target,
25633                                enum ix86_builtin_func_type m_type,
25634                                enum rtx_code sub_code)
25635 {
25636   rtx pat;
25637   int i;
25638   int nargs;
25639   bool comparison_p = false;
25640   bool tf_p = false;
25641   bool last_arg_constant = false;
25642   int num_memory = 0;
25643   struct {
25644     rtx op;
25645     enum machine_mode mode;
25646   } args[4];
25647
25648   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25649
25650   switch (m_type)
25651     {
25652     case MULTI_ARG_4_DF2_DI_I:
25653     case MULTI_ARG_4_DF2_DI_I1:
25654     case MULTI_ARG_4_SF2_SI_I:
25655     case MULTI_ARG_4_SF2_SI_I1:
25656       nargs = 4;
25657       last_arg_constant = true;
25658       break;
25659
25660     case MULTI_ARG_3_SF:
25661     case MULTI_ARG_3_DF:
25662     case MULTI_ARG_3_SF2:
25663     case MULTI_ARG_3_DF2:
25664     case MULTI_ARG_3_DI:
25665     case MULTI_ARG_3_SI:
25666     case MULTI_ARG_3_SI_DI:
25667     case MULTI_ARG_3_HI:
25668     case MULTI_ARG_3_HI_SI:
25669     case MULTI_ARG_3_QI:
25670     case MULTI_ARG_3_DI2:
25671     case MULTI_ARG_3_SI2:
25672     case MULTI_ARG_3_HI2:
25673     case MULTI_ARG_3_QI2:
25674       nargs = 3;
25675       break;
25676
25677     case MULTI_ARG_2_SF:
25678     case MULTI_ARG_2_DF:
25679     case MULTI_ARG_2_DI:
25680     case MULTI_ARG_2_SI:
25681     case MULTI_ARG_2_HI:
25682     case MULTI_ARG_2_QI:
25683       nargs = 2;
25684       break;
25685
25686     case MULTI_ARG_2_DI_IMM:
25687     case MULTI_ARG_2_SI_IMM:
25688     case MULTI_ARG_2_HI_IMM:
25689     case MULTI_ARG_2_QI_IMM:
25690       nargs = 2;
25691       last_arg_constant = true;
25692       break;
25693
25694     case MULTI_ARG_1_SF:
25695     case MULTI_ARG_1_DF:
25696     case MULTI_ARG_1_SF2:
25697     case MULTI_ARG_1_DF2:
25698     case MULTI_ARG_1_DI:
25699     case MULTI_ARG_1_SI:
25700     case MULTI_ARG_1_HI:
25701     case MULTI_ARG_1_QI:
25702     case MULTI_ARG_1_SI_DI:
25703     case MULTI_ARG_1_HI_DI:
25704     case MULTI_ARG_1_HI_SI:
25705     case MULTI_ARG_1_QI_DI:
25706     case MULTI_ARG_1_QI_SI:
25707     case MULTI_ARG_1_QI_HI:
25708       nargs = 1;
25709       break;
25710
25711     case MULTI_ARG_2_DI_CMP:
25712     case MULTI_ARG_2_SI_CMP:
25713     case MULTI_ARG_2_HI_CMP:
25714     case MULTI_ARG_2_QI_CMP:
25715       nargs = 2;
25716       comparison_p = true;
25717       break;
25718
25719     case MULTI_ARG_2_SF_TF:
25720     case MULTI_ARG_2_DF_TF:
25721     case MULTI_ARG_2_DI_TF:
25722     case MULTI_ARG_2_SI_TF:
25723     case MULTI_ARG_2_HI_TF:
25724     case MULTI_ARG_2_QI_TF:
25725       nargs = 2;
25726       tf_p = true;
25727       break;
25728
25729     default:
25730       gcc_unreachable ();
25731     }
25732
25733   if (optimize || !target
25734       || GET_MODE (target) != tmode
25735       || !insn_data[icode].operand[0].predicate (target, tmode))
25736     target = gen_reg_rtx (tmode);
25737
25738   gcc_assert (nargs <= 4);
25739
25740   for (i = 0; i < nargs; i++)
25741     {
25742       tree arg = CALL_EXPR_ARG (exp, i);
25743       rtx op = expand_normal (arg);
25744       int adjust = (comparison_p) ? 1 : 0;
25745       enum machine_mode mode = insn_data[icode].operand[i+adjust+1].mode;
25746
25747       if (last_arg_constant && i == nargs - 1)
25748         {
25749           if (!insn_data[icode].operand[i + 1].predicate (op, mode))
25750             {
25751               enum insn_code new_icode = icode;
25752               switch (icode)
25753                 {
25754                 case CODE_FOR_xop_vpermil2v2df3:
25755                 case CODE_FOR_xop_vpermil2v4sf3:
25756                 case CODE_FOR_xop_vpermil2v4df3:
25757                 case CODE_FOR_xop_vpermil2v8sf3:
25758                   error ("the last argument must be a 2-bit immediate");
25759                   return gen_reg_rtx (tmode);
25760                 case CODE_FOR_xop_rotlv2di3:
25761                   new_icode = CODE_FOR_rotlv2di3;
25762                   goto xop_rotl;
25763                 case CODE_FOR_xop_rotlv4si3:
25764                   new_icode = CODE_FOR_rotlv4si3;
25765                   goto xop_rotl;
25766                 case CODE_FOR_xop_rotlv8hi3:
25767                   new_icode = CODE_FOR_rotlv8hi3;
25768                   goto xop_rotl;
25769                 case CODE_FOR_xop_rotlv16qi3:
25770                   new_icode = CODE_FOR_rotlv16qi3;
25771                 xop_rotl:
25772                   if (CONST_INT_P (op))
25773                     {
25774                       int mask = GET_MODE_BITSIZE (GET_MODE_INNER (tmode)) - 1;
25775                       op = GEN_INT (INTVAL (op) & mask);
25776                       gcc_checking_assert
25777                         (insn_data[icode].operand[i + 1].predicate (op, mode));
25778                     }
25779                   else
25780                     {
25781                       gcc_checking_assert
25782                         (nargs == 2
25783                          && insn_data[new_icode].operand[0].mode == tmode
25784                          && insn_data[new_icode].operand[1].mode == tmode
25785                          && insn_data[new_icode].operand[2].mode == mode
25786                          && insn_data[new_icode].operand[0].predicate
25787                             == insn_data[icode].operand[0].predicate
25788                          && insn_data[new_icode].operand[1].predicate
25789                             == insn_data[icode].operand[1].predicate);
25790                       icode = new_icode;
25791                       goto non_constant;
25792                     }
25793                   break;
25794                 default:
25795                   gcc_unreachable ();
25796                 }
25797             }
25798         }
25799       else
25800         {
25801         non_constant:
25802           if (VECTOR_MODE_P (mode))
25803             op = safe_vector_operand (op, mode);
25804
25805           /* If we aren't optimizing, only allow one memory operand to be
25806              generated.  */
25807           if (memory_operand (op, mode))
25808             num_memory++;
25809
25810           gcc_assert (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode);
25811
25812           if (optimize
25813               || !insn_data[icode].operand[i+adjust+1].predicate (op, mode)
25814               || num_memory > 1)
25815             op = force_reg (mode, op);
25816         }
25817
25818       args[i].op = op;
25819       args[i].mode = mode;
25820     }
25821
25822   switch (nargs)
25823     {
25824     case 1:
25825       pat = GEN_FCN (icode) (target, args[0].op);
25826       break;
25827
25828     case 2:
25829       if (tf_p)
25830         pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
25831                                GEN_INT ((int)sub_code));
25832       else if (! comparison_p)
25833         pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
25834       else
25835         {
25836           rtx cmp_op = gen_rtx_fmt_ee (sub_code, GET_MODE (target),
25837                                        args[0].op,
25838                                        args[1].op);
25839
25840           pat = GEN_FCN (icode) (target, cmp_op, args[0].op, args[1].op);
25841         }
25842       break;
25843
25844     case 3:
25845       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
25846       break;
25847
25848     case 4:
25849       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op, args[3].op);
25850       break;
25851
25852     default:
25853       gcc_unreachable ();
25854     }
25855
25856   if (! pat)
25857     return 0;
25858
25859   emit_insn (pat);
25860   return target;
25861 }
25862
25863 /* Subroutine of ix86_expand_args_builtin to take care of scalar unop
25864    insns with vec_merge.  */
25865
25866 static rtx
25867 ix86_expand_unop_vec_merge_builtin (enum insn_code icode, tree exp,
25868                                     rtx target)
25869 {
25870   rtx pat;
25871   tree arg0 = CALL_EXPR_ARG (exp, 0);
25872   rtx op1, op0 = expand_normal (arg0);
25873   enum machine_mode tmode = insn_data[icode].operand[0].mode;
25874   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
25875
25876   if (optimize || !target
25877       || GET_MODE (target) != tmode
25878       || !insn_data[icode].operand[0].predicate (target, tmode))
25879     target = gen_reg_rtx (tmode);
25880
25881   if (VECTOR_MODE_P (mode0))
25882     op0 = safe_vector_operand (op0, mode0);
25883
25884   if ((optimize && !register_operand (op0, mode0))
25885       || !insn_data[icode].operand[1].predicate (op0, mode0))
25886     op0 = copy_to_mode_reg (mode0, op0);
25887
25888   op1 = op0;
25889   if (!insn_data[icode].operand[2].predicate (op1, mode0))
25890     op1 = copy_to_mode_reg (mode0, op1);
25891
25892   pat = GEN_FCN (icode) (target, op0, op1);
25893   if (! pat)
25894     return 0;
25895   emit_insn (pat);
25896   return target;
25897 }
25898
25899 /* Subroutine of ix86_expand_builtin to take care of comparison insns.  */
25900
25901 static rtx
25902 ix86_expand_sse_compare (const struct builtin_description *d,
25903                          tree exp, rtx target, bool swap)
25904 {
25905   rtx pat;
25906   tree arg0 = CALL_EXPR_ARG (exp, 0);
25907   tree arg1 = CALL_EXPR_ARG (exp, 1);
25908   rtx op0 = expand_normal (arg0);
25909   rtx op1 = expand_normal (arg1);
25910   rtx op2;
25911   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
25912   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
25913   enum machine_mode mode1 = insn_data[d->icode].operand[2].mode;
25914   enum rtx_code comparison = d->comparison;
25915
25916   if (VECTOR_MODE_P (mode0))
25917     op0 = safe_vector_operand (op0, mode0);
25918   if (VECTOR_MODE_P (mode1))
25919     op1 = safe_vector_operand (op1, mode1);
25920
25921   /* Swap operands if we have a comparison that isn't available in
25922      hardware.  */
25923   if (swap)
25924     {
25925       rtx tmp = gen_reg_rtx (mode1);
25926       emit_move_insn (tmp, op1);
25927       op1 = op0;
25928       op0 = tmp;
25929     }
25930
25931   if (optimize || !target
25932       || GET_MODE (target) != tmode
25933       || !insn_data[d->icode].operand[0].predicate (target, tmode))
25934     target = gen_reg_rtx (tmode);
25935
25936   if ((optimize && !register_operand (op0, mode0))
25937       || !insn_data[d->icode].operand[1].predicate (op0, mode0))
25938     op0 = copy_to_mode_reg (mode0, op0);
25939   if ((optimize && !register_operand (op1, mode1))
25940       || !insn_data[d->icode].operand[2].predicate (op1, mode1))
25941     op1 = copy_to_mode_reg (mode1, op1);
25942
25943   op2 = gen_rtx_fmt_ee (comparison, mode0, op0, op1);
25944   pat = GEN_FCN (d->icode) (target, op0, op1, op2);
25945   if (! pat)
25946     return 0;
25947   emit_insn (pat);
25948   return target;
25949 }
25950
25951 /* Subroutine of ix86_expand_builtin to take care of comi insns.  */
25952
25953 static rtx
25954 ix86_expand_sse_comi (const struct builtin_description *d, tree exp,
25955                       rtx target)
25956 {
25957   rtx pat;
25958   tree arg0 = CALL_EXPR_ARG (exp, 0);
25959   tree arg1 = CALL_EXPR_ARG (exp, 1);
25960   rtx op0 = expand_normal (arg0);
25961   rtx op1 = expand_normal (arg1);
25962   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
25963   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
25964   enum rtx_code comparison = d->comparison;
25965
25966   if (VECTOR_MODE_P (mode0))
25967     op0 = safe_vector_operand (op0, mode0);
25968   if (VECTOR_MODE_P (mode1))
25969     op1 = safe_vector_operand (op1, mode1);
25970
25971   /* Swap operands if we have a comparison that isn't available in
25972      hardware.  */
25973   if (d->flag & BUILTIN_DESC_SWAP_OPERANDS)
25974     {
25975       rtx tmp = op1;
25976       op1 = op0;
25977       op0 = tmp;
25978     }
25979
25980   target = gen_reg_rtx (SImode);
25981   emit_move_insn (target, const0_rtx);
25982   target = gen_rtx_SUBREG (QImode, target, 0);
25983
25984   if ((optimize && !register_operand (op0, mode0))
25985       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
25986     op0 = copy_to_mode_reg (mode0, op0);
25987   if ((optimize && !register_operand (op1, mode1))
25988       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
25989     op1 = copy_to_mode_reg (mode1, op1);
25990
25991   pat = GEN_FCN (d->icode) (op0, op1);
25992   if (! pat)
25993     return 0;
25994   emit_insn (pat);
25995   emit_insn (gen_rtx_SET (VOIDmode,
25996                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
25997                           gen_rtx_fmt_ee (comparison, QImode,
25998                                           SET_DEST (pat),
25999                                           const0_rtx)));
26000
26001   return SUBREG_REG (target);
26002 }
26003
26004 /* Subroutine of ix86_expand_args_builtin to take care of round insns.  */
26005
26006 static rtx
26007 ix86_expand_sse_round (const struct builtin_description *d, tree exp,
26008                        rtx target)
26009 {
26010   rtx pat;
26011   tree arg0 = CALL_EXPR_ARG (exp, 0);
26012   rtx op1, op0 = expand_normal (arg0);
26013   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
26014   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
26015
26016   if (optimize || target == 0
26017       || GET_MODE (target) != tmode
26018       || !insn_data[d->icode].operand[0].predicate (target, tmode))
26019     target = gen_reg_rtx (tmode);
26020
26021   if (VECTOR_MODE_P (mode0))
26022     op0 = safe_vector_operand (op0, mode0);
26023
26024   if ((optimize && !register_operand (op0, mode0))
26025       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
26026     op0 = copy_to_mode_reg (mode0, op0);
26027
26028   op1 = GEN_INT (d->comparison);
26029
26030   pat = GEN_FCN (d->icode) (target, op0, op1);
26031   if (! pat)
26032     return 0;
26033   emit_insn (pat);
26034   return target;
26035 }
26036
26037 /* Subroutine of ix86_expand_builtin to take care of ptest insns.  */
26038
26039 static rtx
26040 ix86_expand_sse_ptest (const struct builtin_description *d, tree exp,
26041                        rtx target)
26042 {
26043   rtx pat;
26044   tree arg0 = CALL_EXPR_ARG (exp, 0);
26045   tree arg1 = CALL_EXPR_ARG (exp, 1);
26046   rtx op0 = expand_normal (arg0);
26047   rtx op1 = expand_normal (arg1);
26048   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
26049   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
26050   enum rtx_code comparison = d->comparison;
26051
26052   if (VECTOR_MODE_P (mode0))
26053     op0 = safe_vector_operand (op0, mode0);
26054   if (VECTOR_MODE_P (mode1))
26055     op1 = safe_vector_operand (op1, mode1);
26056
26057   target = gen_reg_rtx (SImode);
26058   emit_move_insn (target, const0_rtx);
26059   target = gen_rtx_SUBREG (QImode, target, 0);
26060
26061   if ((optimize && !register_operand (op0, mode0))
26062       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
26063     op0 = copy_to_mode_reg (mode0, op0);
26064   if ((optimize && !register_operand (op1, mode1))
26065       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
26066     op1 = copy_to_mode_reg (mode1, op1);
26067
26068   pat = GEN_FCN (d->icode) (op0, op1);
26069   if (! pat)
26070     return 0;
26071   emit_insn (pat);
26072   emit_insn (gen_rtx_SET (VOIDmode,
26073                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
26074                           gen_rtx_fmt_ee (comparison, QImode,
26075                                           SET_DEST (pat),
26076                                           const0_rtx)));
26077
26078   return SUBREG_REG (target);
26079 }
26080
26081 /* Subroutine of ix86_expand_builtin to take care of pcmpestr[im] insns.  */
26082
26083 static rtx
26084 ix86_expand_sse_pcmpestr (const struct builtin_description *d,
26085                           tree exp, rtx target)
26086 {
26087   rtx pat;
26088   tree arg0 = CALL_EXPR_ARG (exp, 0);
26089   tree arg1 = CALL_EXPR_ARG (exp, 1);
26090   tree arg2 = CALL_EXPR_ARG (exp, 2);
26091   tree arg3 = CALL_EXPR_ARG (exp, 3);
26092   tree arg4 = CALL_EXPR_ARG (exp, 4);
26093   rtx scratch0, scratch1;
26094   rtx op0 = expand_normal (arg0);
26095   rtx op1 = expand_normal (arg1);
26096   rtx op2 = expand_normal (arg2);
26097   rtx op3 = expand_normal (arg3);
26098   rtx op4 = expand_normal (arg4);
26099   enum machine_mode tmode0, tmode1, modev2, modei3, modev4, modei5, modeimm;
26100
26101   tmode0 = insn_data[d->icode].operand[0].mode;
26102   tmode1 = insn_data[d->icode].operand[1].mode;
26103   modev2 = insn_data[d->icode].operand[2].mode;
26104   modei3 = insn_data[d->icode].operand[3].mode;
26105   modev4 = insn_data[d->icode].operand[4].mode;
26106   modei5 = insn_data[d->icode].operand[5].mode;
26107   modeimm = insn_data[d->icode].operand[6].mode;
26108
26109   if (VECTOR_MODE_P (modev2))
26110     op0 = safe_vector_operand (op0, modev2);
26111   if (VECTOR_MODE_P (modev4))
26112     op2 = safe_vector_operand (op2, modev4);
26113
26114   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
26115     op0 = copy_to_mode_reg (modev2, op0);
26116   if (!insn_data[d->icode].operand[3].predicate (op1, modei3))
26117     op1 = copy_to_mode_reg (modei3, op1);
26118   if ((optimize && !register_operand (op2, modev4))
26119       || !insn_data[d->icode].operand[4].predicate (op2, modev4))
26120     op2 = copy_to_mode_reg (modev4, op2);
26121   if (!insn_data[d->icode].operand[5].predicate (op3, modei5))
26122     op3 = copy_to_mode_reg (modei5, op3);
26123
26124   if (!insn_data[d->icode].operand[6].predicate (op4, modeimm))
26125     {
26126       error ("the fifth argument must be an 8-bit immediate");
26127       return const0_rtx;
26128     }
26129
26130   if (d->code == IX86_BUILTIN_PCMPESTRI128)
26131     {
26132       if (optimize || !target
26133           || GET_MODE (target) != tmode0
26134           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
26135         target = gen_reg_rtx (tmode0);
26136
26137       scratch1 = gen_reg_rtx (tmode1);
26138
26139       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2, op3, op4);
26140     }
26141   else if (d->code == IX86_BUILTIN_PCMPESTRM128)
26142     {
26143       if (optimize || !target
26144           || GET_MODE (target) != tmode1
26145           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
26146         target = gen_reg_rtx (tmode1);
26147
26148       scratch0 = gen_reg_rtx (tmode0);
26149
26150       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2, op3, op4);
26151     }
26152   else
26153     {
26154       gcc_assert (d->flag);
26155
26156       scratch0 = gen_reg_rtx (tmode0);
26157       scratch1 = gen_reg_rtx (tmode1);
26158
26159       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2, op3, op4);
26160     }
26161
26162   if (! pat)
26163     return 0;
26164
26165   emit_insn (pat);
26166
26167   if (d->flag)
26168     {
26169       target = gen_reg_rtx (SImode);
26170       emit_move_insn (target, const0_rtx);
26171       target = gen_rtx_SUBREG (QImode, target, 0);
26172
26173       emit_insn
26174         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
26175                       gen_rtx_fmt_ee (EQ, QImode,
26176                                       gen_rtx_REG ((enum machine_mode) d->flag,
26177                                                    FLAGS_REG),
26178                                       const0_rtx)));
26179       return SUBREG_REG (target);
26180     }
26181   else
26182     return target;
26183 }
26184
26185
26186 /* Subroutine of ix86_expand_builtin to take care of pcmpistr[im] insns.  */
26187
26188 static rtx
26189 ix86_expand_sse_pcmpistr (const struct builtin_description *d,
26190                           tree exp, rtx target)
26191 {
26192   rtx pat;
26193   tree arg0 = CALL_EXPR_ARG (exp, 0);
26194   tree arg1 = CALL_EXPR_ARG (exp, 1);
26195   tree arg2 = CALL_EXPR_ARG (exp, 2);
26196   rtx scratch0, scratch1;
26197   rtx op0 = expand_normal (arg0);
26198   rtx op1 = expand_normal (arg1);
26199   rtx op2 = expand_normal (arg2);
26200   enum machine_mode tmode0, tmode1, modev2, modev3, modeimm;
26201
26202   tmode0 = insn_data[d->icode].operand[0].mode;
26203   tmode1 = insn_data[d->icode].operand[1].mode;
26204   modev2 = insn_data[d->icode].operand[2].mode;
26205   modev3 = insn_data[d->icode].operand[3].mode;
26206   modeimm = insn_data[d->icode].operand[4].mode;
26207
26208   if (VECTOR_MODE_P (modev2))
26209     op0 = safe_vector_operand (op0, modev2);
26210   if (VECTOR_MODE_P (modev3))
26211     op1 = safe_vector_operand (op1, modev3);
26212
26213   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
26214     op0 = copy_to_mode_reg (modev2, op0);
26215   if ((optimize && !register_operand (op1, modev3))
26216       || !insn_data[d->icode].operand[3].predicate (op1, modev3))
26217     op1 = copy_to_mode_reg (modev3, op1);
26218
26219   if (!insn_data[d->icode].operand[4].predicate (op2, modeimm))
26220     {
26221       error ("the third argument must be an 8-bit immediate");
26222       return const0_rtx;
26223     }
26224
26225   if (d->code == IX86_BUILTIN_PCMPISTRI128)
26226     {
26227       if (optimize || !target
26228           || GET_MODE (target) != tmode0
26229           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
26230         target = gen_reg_rtx (tmode0);
26231
26232       scratch1 = gen_reg_rtx (tmode1);
26233
26234       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2);
26235     }
26236   else if (d->code == IX86_BUILTIN_PCMPISTRM128)
26237     {
26238       if (optimize || !target
26239           || GET_MODE (target) != tmode1
26240           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
26241         target = gen_reg_rtx (tmode1);
26242
26243       scratch0 = gen_reg_rtx (tmode0);
26244
26245       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2);
26246     }
26247   else
26248     {
26249       gcc_assert (d->flag);
26250
26251       scratch0 = gen_reg_rtx (tmode0);
26252       scratch1 = gen_reg_rtx (tmode1);
26253
26254       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2);
26255     }
26256
26257   if (! pat)
26258     return 0;
26259
26260   emit_insn (pat);
26261
26262   if (d->flag)
26263     {
26264       target = gen_reg_rtx (SImode);
26265       emit_move_insn (target, const0_rtx);
26266       target = gen_rtx_SUBREG (QImode, target, 0);
26267
26268       emit_insn
26269         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
26270                       gen_rtx_fmt_ee (EQ, QImode,
26271                                       gen_rtx_REG ((enum machine_mode) d->flag,
26272                                                    FLAGS_REG),
26273                                       const0_rtx)));
26274       return SUBREG_REG (target);
26275     }
26276   else
26277     return target;
26278 }
26279
26280 /* Subroutine of ix86_expand_builtin to take care of insns with
26281    variable number of operands.  */
26282
26283 static rtx
26284 ix86_expand_args_builtin (const struct builtin_description *d,
26285                           tree exp, rtx target)
26286 {
26287   rtx pat, real_target;
26288   unsigned int i, nargs;
26289   unsigned int nargs_constant = 0;
26290   int num_memory = 0;
26291   struct
26292     {
26293       rtx op;
26294       enum machine_mode mode;
26295     } args[4];
26296   bool last_arg_count = false;
26297   enum insn_code icode = d->icode;
26298   const struct insn_data_d *insn_p = &insn_data[icode];
26299   enum machine_mode tmode = insn_p->operand[0].mode;
26300   enum machine_mode rmode = VOIDmode;
26301   bool swap = false;
26302   enum rtx_code comparison = d->comparison;
26303
26304   switch ((enum ix86_builtin_func_type) d->flag)
26305     {
26306     case V2DF_FTYPE_V2DF_ROUND:
26307     case V4DF_FTYPE_V4DF_ROUND:
26308     case V4SF_FTYPE_V4SF_ROUND:
26309     case V8SF_FTYPE_V8SF_ROUND:
26310       return ix86_expand_sse_round (d, exp, target);
26311     case INT_FTYPE_V8SF_V8SF_PTEST:
26312     case INT_FTYPE_V4DI_V4DI_PTEST:
26313     case INT_FTYPE_V4DF_V4DF_PTEST:
26314     case INT_FTYPE_V4SF_V4SF_PTEST:
26315     case INT_FTYPE_V2DI_V2DI_PTEST:
26316     case INT_FTYPE_V2DF_V2DF_PTEST:
26317       return ix86_expand_sse_ptest (d, exp, target);
26318     case FLOAT128_FTYPE_FLOAT128:
26319     case FLOAT_FTYPE_FLOAT:
26320     case INT_FTYPE_INT:
26321     case UINT64_FTYPE_INT:
26322     case UINT16_FTYPE_UINT16:
26323     case INT64_FTYPE_INT64:
26324     case INT64_FTYPE_V4SF:
26325     case INT64_FTYPE_V2DF:
26326     case INT_FTYPE_V16QI:
26327     case INT_FTYPE_V8QI:
26328     case INT_FTYPE_V8SF:
26329     case INT_FTYPE_V4DF:
26330     case INT_FTYPE_V4SF:
26331     case INT_FTYPE_V2DF:
26332     case V16QI_FTYPE_V16QI:
26333     case V8SI_FTYPE_V8SF:
26334     case V8SI_FTYPE_V4SI:
26335     case V8HI_FTYPE_V8HI:
26336     case V8HI_FTYPE_V16QI:
26337     case V8QI_FTYPE_V8QI:
26338     case V8SF_FTYPE_V8SF:
26339     case V8SF_FTYPE_V8SI:
26340     case V8SF_FTYPE_V4SF:
26341     case V8SF_FTYPE_V8HI:
26342     case V4SI_FTYPE_V4SI:
26343     case V4SI_FTYPE_V16QI:
26344     case V4SI_FTYPE_V4SF:
26345     case V4SI_FTYPE_V8SI:
26346     case V4SI_FTYPE_V8HI:
26347     case V4SI_FTYPE_V4DF:
26348     case V4SI_FTYPE_V2DF:
26349     case V4HI_FTYPE_V4HI:
26350     case V4DF_FTYPE_V4DF:
26351     case V4DF_FTYPE_V4SI:
26352     case V4DF_FTYPE_V4SF:
26353     case V4DF_FTYPE_V2DF:
26354     case V4SF_FTYPE_V4SF:
26355     case V4SF_FTYPE_V4SI:
26356     case V4SF_FTYPE_V8SF:
26357     case V4SF_FTYPE_V4DF:
26358     case V4SF_FTYPE_V8HI:
26359     case V4SF_FTYPE_V2DF:
26360     case V2DI_FTYPE_V2DI:
26361     case V2DI_FTYPE_V16QI:
26362     case V2DI_FTYPE_V8HI:
26363     case V2DI_FTYPE_V4SI:
26364     case V2DF_FTYPE_V2DF:
26365     case V2DF_FTYPE_V4SI:
26366     case V2DF_FTYPE_V4DF:
26367     case V2DF_FTYPE_V4SF:
26368     case V2DF_FTYPE_V2SI:
26369     case V2SI_FTYPE_V2SI:
26370     case V2SI_FTYPE_V4SF:
26371     case V2SI_FTYPE_V2SF:
26372     case V2SI_FTYPE_V2DF:
26373     case V2SF_FTYPE_V2SF:
26374     case V2SF_FTYPE_V2SI:
26375       nargs = 1;
26376       break;
26377     case V4SF_FTYPE_V4SF_VEC_MERGE:
26378     case V2DF_FTYPE_V2DF_VEC_MERGE:
26379       return ix86_expand_unop_vec_merge_builtin (icode, exp, target);
26380     case FLOAT128_FTYPE_FLOAT128_FLOAT128:
26381     case V16QI_FTYPE_V16QI_V16QI:
26382     case V16QI_FTYPE_V8HI_V8HI:
26383     case V8QI_FTYPE_V8QI_V8QI:
26384     case V8QI_FTYPE_V4HI_V4HI:
26385     case V8HI_FTYPE_V8HI_V8HI:
26386     case V8HI_FTYPE_V16QI_V16QI:
26387     case V8HI_FTYPE_V4SI_V4SI:
26388     case V8SF_FTYPE_V8SF_V8SF:
26389     case V8SF_FTYPE_V8SF_V8SI:
26390     case V4SI_FTYPE_V4SI_V4SI:
26391     case V4SI_FTYPE_V8HI_V8HI:
26392     case V4SI_FTYPE_V4SF_V4SF:
26393     case V4SI_FTYPE_V2DF_V2DF:
26394     case V4HI_FTYPE_V4HI_V4HI:
26395     case V4HI_FTYPE_V8QI_V8QI:
26396     case V4HI_FTYPE_V2SI_V2SI:
26397     case V4DF_FTYPE_V4DF_V4DF:
26398     case V4DF_FTYPE_V4DF_V4DI:
26399     case V4SF_FTYPE_V4SF_V4SF:
26400     case V4SF_FTYPE_V4SF_V4SI:
26401     case V4SF_FTYPE_V4SF_V2SI:
26402     case V4SF_FTYPE_V4SF_V2DF:
26403     case V4SF_FTYPE_V4SF_DI:
26404     case V4SF_FTYPE_V4SF_SI:
26405     case V2DI_FTYPE_V2DI_V2DI:
26406     case V2DI_FTYPE_V16QI_V16QI:
26407     case V2DI_FTYPE_V4SI_V4SI:
26408     case V2DI_FTYPE_V2DI_V16QI:
26409     case V2DI_FTYPE_V2DF_V2DF:
26410     case V2SI_FTYPE_V2SI_V2SI:
26411     case V2SI_FTYPE_V4HI_V4HI:
26412     case V2SI_FTYPE_V2SF_V2SF:
26413     case V2DF_FTYPE_V2DF_V2DF:
26414     case V2DF_FTYPE_V2DF_V4SF:
26415     case V2DF_FTYPE_V2DF_V2DI:
26416     case V2DF_FTYPE_V2DF_DI:
26417     case V2DF_FTYPE_V2DF_SI:
26418     case V2SF_FTYPE_V2SF_V2SF:
26419     case V1DI_FTYPE_V1DI_V1DI:
26420     case V1DI_FTYPE_V8QI_V8QI:
26421     case V1DI_FTYPE_V2SI_V2SI:
26422       if (comparison == UNKNOWN)
26423         return ix86_expand_binop_builtin (icode, exp, target);
26424       nargs = 2;
26425       break;
26426     case V4SF_FTYPE_V4SF_V4SF_SWAP:
26427     case V2DF_FTYPE_V2DF_V2DF_SWAP:
26428       gcc_assert (comparison != UNKNOWN);
26429       nargs = 2;
26430       swap = true;
26431       break;
26432     case V8HI_FTYPE_V8HI_V8HI_COUNT:
26433     case V8HI_FTYPE_V8HI_SI_COUNT:
26434     case V4SI_FTYPE_V4SI_V4SI_COUNT:
26435     case V4SI_FTYPE_V4SI_SI_COUNT:
26436     case V4HI_FTYPE_V4HI_V4HI_COUNT:
26437     case V4HI_FTYPE_V4HI_SI_COUNT:
26438     case V2DI_FTYPE_V2DI_V2DI_COUNT:
26439     case V2DI_FTYPE_V2DI_SI_COUNT:
26440     case V2SI_FTYPE_V2SI_V2SI_COUNT:
26441     case V2SI_FTYPE_V2SI_SI_COUNT:
26442     case V1DI_FTYPE_V1DI_V1DI_COUNT:
26443     case V1DI_FTYPE_V1DI_SI_COUNT:
26444       nargs = 2;
26445       last_arg_count = true;
26446       break;
26447     case UINT64_FTYPE_UINT64_UINT64:
26448     case UINT_FTYPE_UINT_UINT:
26449     case UINT_FTYPE_UINT_USHORT:
26450     case UINT_FTYPE_UINT_UCHAR:
26451     case UINT16_FTYPE_UINT16_INT:
26452     case UINT8_FTYPE_UINT8_INT:
26453       nargs = 2;
26454       break;
26455     case V2DI_FTYPE_V2DI_INT_CONVERT:
26456       nargs = 2;
26457       rmode = V1TImode;
26458       nargs_constant = 1;
26459       break;
26460     case V8HI_FTYPE_V8HI_INT:
26461     case V8HI_FTYPE_V8SF_INT:
26462     case V8HI_FTYPE_V4SF_INT:
26463     case V8SF_FTYPE_V8SF_INT:
26464     case V4SI_FTYPE_V4SI_INT:
26465     case V4SI_FTYPE_V8SI_INT:
26466     case V4HI_FTYPE_V4HI_INT:
26467     case V4DF_FTYPE_V4DF_INT:
26468     case V4SF_FTYPE_V4SF_INT:
26469     case V4SF_FTYPE_V8SF_INT:
26470     case V2DI_FTYPE_V2DI_INT:
26471     case V2DF_FTYPE_V2DF_INT:
26472     case V2DF_FTYPE_V4DF_INT:
26473       nargs = 2;
26474       nargs_constant = 1;
26475       break;
26476     case V16QI_FTYPE_V16QI_V16QI_V16QI:
26477     case V8SF_FTYPE_V8SF_V8SF_V8SF:
26478     case V4DF_FTYPE_V4DF_V4DF_V4DF:
26479     case V4SF_FTYPE_V4SF_V4SF_V4SF:
26480     case V2DF_FTYPE_V2DF_V2DF_V2DF:
26481       nargs = 3;
26482       break;
26483     case V16QI_FTYPE_V16QI_V16QI_INT:
26484     case V8HI_FTYPE_V8HI_V8HI_INT:
26485     case V8SI_FTYPE_V8SI_V8SI_INT:
26486     case V8SI_FTYPE_V8SI_V4SI_INT:
26487     case V8SF_FTYPE_V8SF_V8SF_INT:
26488     case V8SF_FTYPE_V8SF_V4SF_INT:
26489     case V4SI_FTYPE_V4SI_V4SI_INT:
26490     case V4DF_FTYPE_V4DF_V4DF_INT:
26491     case V4DF_FTYPE_V4DF_V2DF_INT:
26492     case V4SF_FTYPE_V4SF_V4SF_INT:
26493     case V2DI_FTYPE_V2DI_V2DI_INT:
26494     case V2DF_FTYPE_V2DF_V2DF_INT:
26495       nargs = 3;
26496       nargs_constant = 1;
26497       break;
26498     case V2DI_FTYPE_V2DI_V2DI_INT_CONVERT:
26499       nargs = 3;
26500       rmode = V2DImode;
26501       nargs_constant = 1;
26502       break;
26503     case V1DI_FTYPE_V1DI_V1DI_INT_CONVERT:
26504       nargs = 3;
26505       rmode = DImode;
26506       nargs_constant = 1;
26507       break;
26508     case V2DI_FTYPE_V2DI_UINT_UINT:
26509       nargs = 3;
26510       nargs_constant = 2;
26511       break;
26512     case V2DF_FTYPE_V2DF_V2DF_V2DI_INT:
26513     case V4DF_FTYPE_V4DF_V4DF_V4DI_INT:
26514     case V4SF_FTYPE_V4SF_V4SF_V4SI_INT:
26515     case V8SF_FTYPE_V8SF_V8SF_V8SI_INT:
26516       nargs = 4;
26517       nargs_constant = 1;
26518       break;
26519     case V2DI_FTYPE_V2DI_V2DI_UINT_UINT:
26520       nargs = 4;
26521       nargs_constant = 2;
26522       break;
26523     default:
26524       gcc_unreachable ();
26525     }
26526
26527   gcc_assert (nargs <= ARRAY_SIZE (args));
26528
26529   if (comparison != UNKNOWN)
26530     {
26531       gcc_assert (nargs == 2);
26532       return ix86_expand_sse_compare (d, exp, target, swap);
26533     }
26534
26535   if (rmode == VOIDmode || rmode == tmode)
26536     {
26537       if (optimize
26538           || target == 0
26539           || GET_MODE (target) != tmode
26540           || !insn_p->operand[0].predicate (target, tmode))
26541         target = gen_reg_rtx (tmode);
26542       real_target = target;
26543     }
26544   else
26545     {
26546       target = gen_reg_rtx (rmode);
26547       real_target = simplify_gen_subreg (tmode, target, rmode, 0);
26548     }
26549
26550   for (i = 0; i < nargs; i++)
26551     {
26552       tree arg = CALL_EXPR_ARG (exp, i);
26553       rtx op = expand_normal (arg);
26554       enum machine_mode mode = insn_p->operand[i + 1].mode;
26555       bool match = insn_p->operand[i + 1].predicate (op, mode);
26556
26557       if (last_arg_count && (i + 1) == nargs)
26558         {
26559           /* SIMD shift insns take either an 8-bit immediate or
26560              register as count.  But builtin functions take int as
26561              count.  If count doesn't match, we put it in register.  */
26562           if (!match)
26563             {
26564               op = simplify_gen_subreg (SImode, op, GET_MODE (op), 0);
26565               if (!insn_p->operand[i + 1].predicate (op, mode))
26566                 op = copy_to_reg (op);
26567             }
26568         }
26569       else if ((nargs - i) <= nargs_constant)
26570         {
26571           if (!match)
26572             switch (icode)
26573               {
26574               case CODE_FOR_sse4_1_roundpd:
26575               case CODE_FOR_sse4_1_roundps:
26576               case CODE_FOR_sse4_1_roundsd:
26577               case CODE_FOR_sse4_1_roundss:
26578               case CODE_FOR_sse4_1_blendps:
26579               case CODE_FOR_avx_blendpd256:
26580               case CODE_FOR_avx_vpermilv4df:
26581               case CODE_FOR_avx_roundpd256:
26582               case CODE_FOR_avx_roundps256:
26583                 error ("the last argument must be a 4-bit immediate");
26584                 return const0_rtx;
26585
26586               case CODE_FOR_sse4_1_blendpd:
26587               case CODE_FOR_avx_vpermilv2df:
26588               case CODE_FOR_xop_vpermil2v2df3:
26589               case CODE_FOR_xop_vpermil2v4sf3:
26590               case CODE_FOR_xop_vpermil2v4df3:
26591               case CODE_FOR_xop_vpermil2v8sf3:
26592                 error ("the last argument must be a 2-bit immediate");
26593                 return const0_rtx;
26594
26595               case CODE_FOR_avx_vextractf128v4df:
26596               case CODE_FOR_avx_vextractf128v8sf:
26597               case CODE_FOR_avx_vextractf128v8si:
26598               case CODE_FOR_avx_vinsertf128v4df:
26599               case CODE_FOR_avx_vinsertf128v8sf:
26600               case CODE_FOR_avx_vinsertf128v8si:
26601                 error ("the last argument must be a 1-bit immediate");
26602                 return const0_rtx;
26603
26604               case CODE_FOR_avx_vmcmpv2df3:
26605               case CODE_FOR_avx_vmcmpv4sf3:
26606               case CODE_FOR_avx_cmpv2df3:
26607               case CODE_FOR_avx_cmpv4sf3:
26608               case CODE_FOR_avx_cmpv4df3:
26609               case CODE_FOR_avx_cmpv8sf3:
26610                 error ("the last argument must be a 5-bit immediate");
26611                 return const0_rtx;
26612
26613              default:
26614                 switch (nargs_constant)
26615                   {
26616                   case 2:
26617                     if ((nargs - i) == nargs_constant)
26618                       {
26619                         error ("the next to last argument must be an 8-bit immediate");
26620                         break;
26621                       }
26622                   case 1:
26623                     error ("the last argument must be an 8-bit immediate");
26624                     break;
26625                   default:
26626                     gcc_unreachable ();
26627                   }
26628                 return const0_rtx;
26629               }
26630         }
26631       else
26632         {
26633           if (VECTOR_MODE_P (mode))
26634             op = safe_vector_operand (op, mode);
26635
26636           /* If we aren't optimizing, only allow one memory operand to
26637              be generated.  */
26638           if (memory_operand (op, mode))
26639             num_memory++;
26640
26641           if (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
26642             {
26643               if (optimize || !match || num_memory > 1)
26644                 op = copy_to_mode_reg (mode, op);
26645             }
26646           else
26647             {
26648               op = copy_to_reg (op);
26649               op = simplify_gen_subreg (mode, op, GET_MODE (op), 0);
26650             }
26651         }
26652
26653       args[i].op = op;
26654       args[i].mode = mode;
26655     }
26656
26657   switch (nargs)
26658     {
26659     case 1:
26660       pat = GEN_FCN (icode) (real_target, args[0].op);
26661       break;
26662     case 2:
26663       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op);
26664       break;
26665     case 3:
26666       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
26667                              args[2].op);
26668       break;
26669     case 4:
26670       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
26671                              args[2].op, args[3].op);
26672       break;
26673     default:
26674       gcc_unreachable ();
26675     }
26676
26677   if (! pat)
26678     return 0;
26679
26680   emit_insn (pat);
26681   return target;
26682 }
26683
26684 /* Subroutine of ix86_expand_builtin to take care of special insns
26685    with variable number of operands.  */
26686
26687 static rtx
26688 ix86_expand_special_args_builtin (const struct builtin_description *d,
26689                                     tree exp, rtx target)
26690 {
26691   tree arg;
26692   rtx pat, op;
26693   unsigned int i, nargs, arg_adjust, memory;
26694   struct
26695     {
26696       rtx op;
26697       enum machine_mode mode;
26698     } args[3];
26699   enum insn_code icode = d->icode;
26700   bool last_arg_constant = false;
26701   const struct insn_data_d *insn_p = &insn_data[icode];
26702   enum machine_mode tmode = insn_p->operand[0].mode;
26703   enum { load, store } klass;
26704
26705   switch ((enum ix86_builtin_func_type) d->flag)
26706     {
26707     case VOID_FTYPE_VOID:
26708       if (icode == CODE_FOR_avx_vzeroupper)
26709         target = GEN_INT (vzeroupper_intrinsic);
26710       emit_insn (GEN_FCN (icode) (target));
26711       return 0;
26712     case VOID_FTYPE_UINT64:
26713     case VOID_FTYPE_UNSIGNED:
26714       nargs = 0;
26715       klass = store;
26716       memory = 0;
26717       break;
26718       break;
26719     case UINT64_FTYPE_VOID:
26720     case UNSIGNED_FTYPE_VOID:
26721       nargs = 0;
26722       klass = load;
26723       memory = 0;
26724       break;
26725     case UINT64_FTYPE_PUNSIGNED:
26726     case V2DI_FTYPE_PV2DI:
26727     case V32QI_FTYPE_PCCHAR:
26728     case V16QI_FTYPE_PCCHAR:
26729     case V8SF_FTYPE_PCV4SF:
26730     case V8SF_FTYPE_PCFLOAT:
26731     case V4SF_FTYPE_PCFLOAT:
26732     case V4DF_FTYPE_PCV2DF:
26733     case V4DF_FTYPE_PCDOUBLE:
26734     case V2DF_FTYPE_PCDOUBLE:
26735     case VOID_FTYPE_PVOID:
26736       nargs = 1;
26737       klass = load;
26738       memory = 0;
26739       break;
26740     case VOID_FTYPE_PV2SF_V4SF:
26741     case VOID_FTYPE_PV4DI_V4DI:
26742     case VOID_FTYPE_PV2DI_V2DI:
26743     case VOID_FTYPE_PCHAR_V32QI:
26744     case VOID_FTYPE_PCHAR_V16QI:
26745     case VOID_FTYPE_PFLOAT_V8SF:
26746     case VOID_FTYPE_PFLOAT_V4SF:
26747     case VOID_FTYPE_PDOUBLE_V4DF:
26748     case VOID_FTYPE_PDOUBLE_V2DF:
26749     case VOID_FTYPE_PULONGLONG_ULONGLONG:
26750     case VOID_FTYPE_PINT_INT:
26751       nargs = 1;
26752       klass = store;
26753       /* Reserve memory operand for target.  */
26754       memory = ARRAY_SIZE (args);
26755       break;
26756     case V4SF_FTYPE_V4SF_PCV2SF:
26757     case V2DF_FTYPE_V2DF_PCDOUBLE:
26758       nargs = 2;
26759       klass = load;
26760       memory = 1;
26761       break;
26762     case V8SF_FTYPE_PCV8SF_V8SI:
26763     case V4DF_FTYPE_PCV4DF_V4DI:
26764     case V4SF_FTYPE_PCV4SF_V4SI:
26765     case V2DF_FTYPE_PCV2DF_V2DI:
26766       nargs = 2;
26767       klass = load;
26768       memory = 0;
26769       break;
26770     case VOID_FTYPE_PV8SF_V8SI_V8SF:
26771     case VOID_FTYPE_PV4DF_V4DI_V4DF:
26772     case VOID_FTYPE_PV4SF_V4SI_V4SF:
26773     case VOID_FTYPE_PV2DF_V2DI_V2DF:
26774       nargs = 2;
26775       klass = store;
26776       /* Reserve memory operand for target.  */
26777       memory = ARRAY_SIZE (args);
26778       break;
26779     case VOID_FTYPE_UINT_UINT_UINT:
26780     case VOID_FTYPE_UINT64_UINT_UINT:
26781     case UCHAR_FTYPE_UINT_UINT_UINT:
26782     case UCHAR_FTYPE_UINT64_UINT_UINT:
26783       nargs = 3;
26784       klass = load;
26785       memory = ARRAY_SIZE (args);
26786       last_arg_constant = true;
26787       break;
26788     default:
26789       gcc_unreachable ();
26790     }
26791
26792   gcc_assert (nargs <= ARRAY_SIZE (args));
26793
26794   if (klass == store)
26795     {
26796       arg = CALL_EXPR_ARG (exp, 0);
26797       op = expand_normal (arg);
26798       gcc_assert (target == 0);
26799       if (memory)
26800         {
26801           if (GET_MODE (op) != Pmode)
26802             op = convert_to_mode (Pmode, op, 1);
26803           target = gen_rtx_MEM (tmode, force_reg (Pmode, op));
26804         }
26805       else
26806         target = force_reg (tmode, op);
26807       arg_adjust = 1;
26808     }
26809   else
26810     {
26811       arg_adjust = 0;
26812       if (optimize
26813           || target == 0
26814           || GET_MODE (target) != tmode
26815           || !insn_p->operand[0].predicate (target, tmode))
26816         target = gen_reg_rtx (tmode);
26817     }
26818
26819   for (i = 0; i < nargs; i++)
26820     {
26821       enum machine_mode mode = insn_p->operand[i + 1].mode;
26822       bool match;
26823
26824       arg = CALL_EXPR_ARG (exp, i + arg_adjust);
26825       op = expand_normal (arg);
26826       match = insn_p->operand[i + 1].predicate (op, mode);
26827
26828       if (last_arg_constant && (i + 1) == nargs)
26829         {
26830           if (!match)
26831             {
26832               if (icode == CODE_FOR_lwp_lwpvalsi3
26833                   || icode == CODE_FOR_lwp_lwpinssi3
26834                   || icode == CODE_FOR_lwp_lwpvaldi3
26835                   || icode == CODE_FOR_lwp_lwpinsdi3)
26836                 error ("the last argument must be a 32-bit immediate");
26837               else
26838                 error ("the last argument must be an 8-bit immediate");
26839               return const0_rtx;
26840             }
26841         }
26842       else
26843         {
26844           if (i == memory)
26845             {
26846               /* This must be the memory operand.  */
26847               if (GET_MODE (op) != Pmode)
26848                 op = convert_to_mode (Pmode, op, 1);
26849               op = gen_rtx_MEM (mode, force_reg (Pmode, op));
26850               gcc_assert (GET_MODE (op) == mode
26851                           || GET_MODE (op) == VOIDmode);
26852             }
26853           else
26854             {
26855               /* This must be register.  */
26856               if (VECTOR_MODE_P (mode))
26857                 op = safe_vector_operand (op, mode);
26858
26859               gcc_assert (GET_MODE (op) == mode
26860                           || GET_MODE (op) == VOIDmode);
26861               op = copy_to_mode_reg (mode, op);
26862             }
26863         }
26864
26865       args[i].op = op;
26866       args[i].mode = mode;
26867     }
26868
26869   switch (nargs)
26870     {
26871     case 0:
26872       pat = GEN_FCN (icode) (target);
26873       break;
26874     case 1:
26875       pat = GEN_FCN (icode) (target, args[0].op);
26876       break;
26877     case 2:
26878       pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
26879       break;
26880     case 3:
26881       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
26882       break;
26883     default:
26884       gcc_unreachable ();
26885     }
26886
26887   if (! pat)
26888     return 0;
26889   emit_insn (pat);
26890   return klass == store ? 0 : target;
26891 }
26892
26893 /* Return the integer constant in ARG.  Constrain it to be in the range
26894    of the subparts of VEC_TYPE; issue an error if not.  */
26895
26896 static int
26897 get_element_number (tree vec_type, tree arg)
26898 {
26899   unsigned HOST_WIDE_INT elt, max = TYPE_VECTOR_SUBPARTS (vec_type) - 1;
26900
26901   if (!host_integerp (arg, 1)
26902       || (elt = tree_low_cst (arg, 1), elt > max))
26903     {
26904       error ("selector must be an integer constant in the range 0..%wi", max);
26905       return 0;
26906     }
26907
26908   return elt;
26909 }
26910
26911 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26912    ix86_expand_vector_init.  We DO have language-level syntax for this, in
26913    the form of  (type){ init-list }.  Except that since we can't place emms
26914    instructions from inside the compiler, we can't allow the use of MMX
26915    registers unless the user explicitly asks for it.  So we do *not* define
26916    vec_set/vec_extract/vec_init patterns for MMX modes in mmx.md.  Instead
26917    we have builtins invoked by mmintrin.h that gives us license to emit
26918    these sorts of instructions.  */
26919
26920 static rtx
26921 ix86_expand_vec_init_builtin (tree type, tree exp, rtx target)
26922 {
26923   enum machine_mode tmode = TYPE_MODE (type);
26924   enum machine_mode inner_mode = GET_MODE_INNER (tmode);
26925   int i, n_elt = GET_MODE_NUNITS (tmode);
26926   rtvec v = rtvec_alloc (n_elt);
26927
26928   gcc_assert (VECTOR_MODE_P (tmode));
26929   gcc_assert (call_expr_nargs (exp) == n_elt);
26930
26931   for (i = 0; i < n_elt; ++i)
26932     {
26933       rtx x = expand_normal (CALL_EXPR_ARG (exp, i));
26934       RTVEC_ELT (v, i) = gen_lowpart (inner_mode, x);
26935     }
26936
26937   if (!target || !register_operand (target, tmode))
26938     target = gen_reg_rtx (tmode);
26939
26940   ix86_expand_vector_init (true, target, gen_rtx_PARALLEL (tmode, v));
26941   return target;
26942 }
26943
26944 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26945    ix86_expand_vector_extract.  They would be redundant (for non-MMX) if we
26946    had a language-level syntax for referencing vector elements.  */
26947
26948 static rtx
26949 ix86_expand_vec_ext_builtin (tree exp, rtx target)
26950 {
26951   enum machine_mode tmode, mode0;
26952   tree arg0, arg1;
26953   int elt;
26954   rtx op0;
26955
26956   arg0 = CALL_EXPR_ARG (exp, 0);
26957   arg1 = CALL_EXPR_ARG (exp, 1);
26958
26959   op0 = expand_normal (arg0);
26960   elt = get_element_number (TREE_TYPE (arg0), arg1);
26961
26962   tmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
26963   mode0 = TYPE_MODE (TREE_TYPE (arg0));
26964   gcc_assert (VECTOR_MODE_P (mode0));
26965
26966   op0 = force_reg (mode0, op0);
26967
26968   if (optimize || !target || !register_operand (target, tmode))
26969     target = gen_reg_rtx (tmode);
26970
26971   ix86_expand_vector_extract (true, target, op0, elt);
26972
26973   return target;
26974 }
26975
26976 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
26977    ix86_expand_vector_set.  They would be redundant (for non-MMX) if we had
26978    a language-level syntax for referencing vector elements.  */
26979
26980 static rtx
26981 ix86_expand_vec_set_builtin (tree exp)
26982 {
26983   enum machine_mode tmode, mode1;
26984   tree arg0, arg1, arg2;
26985   int elt;
26986   rtx op0, op1, target;
26987
26988   arg0 = CALL_EXPR_ARG (exp, 0);
26989   arg1 = CALL_EXPR_ARG (exp, 1);
26990   arg2 = CALL_EXPR_ARG (exp, 2);
26991
26992   tmode = TYPE_MODE (TREE_TYPE (arg0));
26993   mode1 = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
26994   gcc_assert (VECTOR_MODE_P (tmode));
26995
26996   op0 = expand_expr (arg0, NULL_RTX, tmode, EXPAND_NORMAL);
26997   op1 = expand_expr (arg1, NULL_RTX, mode1, EXPAND_NORMAL);
26998   elt = get_element_number (TREE_TYPE (arg0), arg2);
26999
27000   if (GET_MODE (op1) != mode1 && GET_MODE (op1) != VOIDmode)
27001     op1 = convert_modes (mode1, GET_MODE (op1), op1, true);
27002
27003   op0 = force_reg (tmode, op0);
27004   op1 = force_reg (mode1, op1);
27005
27006   /* OP0 is the source of these builtin functions and shouldn't be
27007      modified.  Create a copy, use it and return it as target.  */
27008   target = gen_reg_rtx (tmode);
27009   emit_move_insn (target, op0);
27010   ix86_expand_vector_set (true, target, op1, elt);
27011
27012   return target;
27013 }
27014
27015 /* Expand an expression EXP that calls a built-in function,
27016    with result going to TARGET if that's convenient
27017    (and in mode MODE if that's convenient).
27018    SUBTARGET may be used as the target for computing one of EXP's operands.
27019    IGNORE is nonzero if the value is to be ignored.  */
27020
27021 static rtx
27022 ix86_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
27023                      enum machine_mode mode ATTRIBUTE_UNUSED,
27024                      int ignore ATTRIBUTE_UNUSED)
27025 {
27026   const struct builtin_description *d;
27027   size_t i;
27028   enum insn_code icode;
27029   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
27030   tree arg0, arg1, arg2;
27031   rtx op0, op1, op2, pat;
27032   enum machine_mode mode0, mode1, mode2;
27033   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
27034
27035   /* Determine whether the builtin function is available under the current ISA.
27036      Originally the builtin was not created if it wasn't applicable to the
27037      current ISA based on the command line switches.  With function specific
27038      options, we need to check in the context of the function making the call
27039      whether it is supported.  */
27040   if (ix86_builtins_isa[fcode].isa
27041       && !(ix86_builtins_isa[fcode].isa & ix86_isa_flags))
27042     {
27043       char *opts = ix86_target_string (ix86_builtins_isa[fcode].isa, 0, NULL,
27044                                        NULL, (enum fpmath_unit) 0, false);
27045
27046       if (!opts)
27047         error ("%qE needs unknown isa option", fndecl);
27048       else
27049         {
27050           gcc_assert (opts != NULL);
27051           error ("%qE needs isa option %s", fndecl, opts);
27052           free (opts);
27053         }
27054       return const0_rtx;
27055     }
27056
27057   switch (fcode)
27058     {
27059     case IX86_BUILTIN_MASKMOVQ:
27060     case IX86_BUILTIN_MASKMOVDQU:
27061       icode = (fcode == IX86_BUILTIN_MASKMOVQ
27062                ? CODE_FOR_mmx_maskmovq
27063                : CODE_FOR_sse2_maskmovdqu);
27064       /* Note the arg order is different from the operand order.  */
27065       arg1 = CALL_EXPR_ARG (exp, 0);
27066       arg2 = CALL_EXPR_ARG (exp, 1);
27067       arg0 = CALL_EXPR_ARG (exp, 2);
27068       op0 = expand_normal (arg0);
27069       op1 = expand_normal (arg1);
27070       op2 = expand_normal (arg2);
27071       mode0 = insn_data[icode].operand[0].mode;
27072       mode1 = insn_data[icode].operand[1].mode;
27073       mode2 = insn_data[icode].operand[2].mode;
27074
27075       if (GET_MODE (op0) != Pmode)
27076         op0 = convert_to_mode (Pmode, op0, 1);
27077       op0 = gen_rtx_MEM (mode1, force_reg (Pmode, op0));
27078
27079       if (!insn_data[icode].operand[0].predicate (op0, mode0))
27080         op0 = copy_to_mode_reg (mode0, op0);
27081       if (!insn_data[icode].operand[1].predicate (op1, mode1))
27082         op1 = copy_to_mode_reg (mode1, op1);
27083       if (!insn_data[icode].operand[2].predicate (op2, mode2))
27084         op2 = copy_to_mode_reg (mode2, op2);
27085       pat = GEN_FCN (icode) (op0, op1, op2);
27086       if (! pat)
27087         return 0;
27088       emit_insn (pat);
27089       return 0;
27090
27091     case IX86_BUILTIN_LDMXCSR:
27092       op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
27093       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
27094       emit_move_insn (target, op0);
27095       emit_insn (gen_sse_ldmxcsr (target));
27096       return 0;
27097
27098     case IX86_BUILTIN_STMXCSR:
27099       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
27100       emit_insn (gen_sse_stmxcsr (target));
27101       return copy_to_mode_reg (SImode, target);
27102
27103     case IX86_BUILTIN_CLFLUSH:
27104         arg0 = CALL_EXPR_ARG (exp, 0);
27105         op0 = expand_normal (arg0);
27106         icode = CODE_FOR_sse2_clflush;
27107         if (!insn_data[icode].operand[0].predicate (op0, Pmode))
27108           {
27109             if (GET_MODE (op0) != Pmode)
27110               op0 = convert_to_mode (Pmode, op0, 1);
27111             op0 = force_reg (Pmode, op0);
27112           }
27113
27114         emit_insn (gen_sse2_clflush (op0));
27115         return 0;
27116
27117     case IX86_BUILTIN_MONITOR:
27118       arg0 = CALL_EXPR_ARG (exp, 0);
27119       arg1 = CALL_EXPR_ARG (exp, 1);
27120       arg2 = CALL_EXPR_ARG (exp, 2);
27121       op0 = expand_normal (arg0);
27122       op1 = expand_normal (arg1);
27123       op2 = expand_normal (arg2);
27124       if (!REG_P (op0))
27125         {
27126           if (GET_MODE (op0) != Pmode)
27127             op0 = convert_to_mode (Pmode, op0, 1);
27128           op0 = force_reg (Pmode, op0);
27129         }
27130       if (!REG_P (op1))
27131         op1 = copy_to_mode_reg (SImode, op1);
27132       if (!REG_P (op2))
27133         op2 = copy_to_mode_reg (SImode, op2);
27134       emit_insn (ix86_gen_monitor (op0, op1, op2));
27135       return 0;
27136
27137     case IX86_BUILTIN_MWAIT:
27138       arg0 = CALL_EXPR_ARG (exp, 0);
27139       arg1 = CALL_EXPR_ARG (exp, 1);
27140       op0 = expand_normal (arg0);
27141       op1 = expand_normal (arg1);
27142       if (!REG_P (op0))
27143         op0 = copy_to_mode_reg (SImode, op0);
27144       if (!REG_P (op1))
27145         op1 = copy_to_mode_reg (SImode, op1);
27146       emit_insn (gen_sse3_mwait (op0, op1));
27147       return 0;
27148
27149     case IX86_BUILTIN_VEC_INIT_V2SI:
27150     case IX86_BUILTIN_VEC_INIT_V4HI:
27151     case IX86_BUILTIN_VEC_INIT_V8QI:
27152       return ix86_expand_vec_init_builtin (TREE_TYPE (exp), exp, target);
27153
27154     case IX86_BUILTIN_VEC_EXT_V2DF:
27155     case IX86_BUILTIN_VEC_EXT_V2DI:
27156     case IX86_BUILTIN_VEC_EXT_V4SF:
27157     case IX86_BUILTIN_VEC_EXT_V4SI:
27158     case IX86_BUILTIN_VEC_EXT_V8HI:
27159     case IX86_BUILTIN_VEC_EXT_V2SI:
27160     case IX86_BUILTIN_VEC_EXT_V4HI:
27161     case IX86_BUILTIN_VEC_EXT_V16QI:
27162       return ix86_expand_vec_ext_builtin (exp, target);
27163
27164     case IX86_BUILTIN_VEC_SET_V2DI:
27165     case IX86_BUILTIN_VEC_SET_V4SF:
27166     case IX86_BUILTIN_VEC_SET_V4SI:
27167     case IX86_BUILTIN_VEC_SET_V8HI:
27168     case IX86_BUILTIN_VEC_SET_V4HI:
27169     case IX86_BUILTIN_VEC_SET_V16QI:
27170       return ix86_expand_vec_set_builtin (exp);
27171
27172     case IX86_BUILTIN_VEC_PERM_V2DF:
27173     case IX86_BUILTIN_VEC_PERM_V4SF:
27174     case IX86_BUILTIN_VEC_PERM_V2DI:
27175     case IX86_BUILTIN_VEC_PERM_V4SI:
27176     case IX86_BUILTIN_VEC_PERM_V8HI:
27177     case IX86_BUILTIN_VEC_PERM_V16QI:
27178     case IX86_BUILTIN_VEC_PERM_V2DI_U:
27179     case IX86_BUILTIN_VEC_PERM_V4SI_U:
27180     case IX86_BUILTIN_VEC_PERM_V8HI_U:
27181     case IX86_BUILTIN_VEC_PERM_V16QI_U:
27182     case IX86_BUILTIN_VEC_PERM_V4DF:
27183     case IX86_BUILTIN_VEC_PERM_V8SF:
27184       return ix86_expand_vec_perm_builtin (exp);
27185
27186     case IX86_BUILTIN_INFQ:
27187     case IX86_BUILTIN_HUGE_VALQ:
27188       {
27189         REAL_VALUE_TYPE inf;
27190         rtx tmp;
27191
27192         real_inf (&inf);
27193         tmp = CONST_DOUBLE_FROM_REAL_VALUE (inf, mode);
27194
27195         tmp = validize_mem (force_const_mem (mode, tmp));
27196
27197         if (target == 0)
27198           target = gen_reg_rtx (mode);
27199
27200         emit_move_insn (target, tmp);
27201         return target;
27202       }
27203
27204     case IX86_BUILTIN_LLWPCB:
27205       arg0 = CALL_EXPR_ARG (exp, 0);
27206       op0 = expand_normal (arg0);
27207       icode = CODE_FOR_lwp_llwpcb;
27208       if (!insn_data[icode].operand[0].predicate (op0, Pmode))
27209         {
27210           if (GET_MODE (op0) != Pmode)
27211             op0 = convert_to_mode (Pmode, op0, 1);
27212           op0 = force_reg (Pmode, op0);
27213         }
27214       emit_insn (gen_lwp_llwpcb (op0));
27215       return 0;
27216
27217     case IX86_BUILTIN_SLWPCB:
27218       icode = CODE_FOR_lwp_slwpcb;
27219       if (!target
27220           || !insn_data[icode].operand[0].predicate (target, Pmode))
27221         target = gen_reg_rtx (Pmode);
27222       emit_insn (gen_lwp_slwpcb (target));
27223       return target;
27224
27225     case IX86_BUILTIN_BEXTRI32:
27226     case IX86_BUILTIN_BEXTRI64:
27227       arg0 = CALL_EXPR_ARG (exp, 0);
27228       arg1 = CALL_EXPR_ARG (exp, 1);
27229       op0 = expand_normal (arg0);
27230       op1 = expand_normal (arg1);
27231       icode = (fcode == IX86_BUILTIN_BEXTRI32
27232           ? CODE_FOR_tbm_bextri_si
27233           : CODE_FOR_tbm_bextri_di);
27234       if (!CONST_INT_P (op1))
27235         {
27236           error ("last argument must be an immediate");
27237           return const0_rtx;
27238         }
27239       else
27240         {
27241           unsigned char length = (INTVAL (op1) >> 8) & 0xFF;
27242           unsigned char lsb_index = INTVAL (op1) & 0xFF;
27243           op1 = GEN_INT (length);
27244           op2 = GEN_INT (lsb_index);
27245           pat = GEN_FCN (icode) (target, op0, op1, op2);
27246           if (pat)
27247             emit_insn (pat);
27248           return target;
27249         }
27250
27251     case IX86_BUILTIN_RDRAND16_STEP:
27252       icode = CODE_FOR_rdrandhi_1;
27253       mode0 = HImode;
27254       goto rdrand_step;
27255
27256     case IX86_BUILTIN_RDRAND32_STEP:
27257       icode = CODE_FOR_rdrandsi_1;
27258       mode0 = SImode;
27259       goto rdrand_step;
27260
27261     case IX86_BUILTIN_RDRAND64_STEP:
27262       icode = CODE_FOR_rdranddi_1;
27263       mode0 = DImode;
27264
27265 rdrand_step:
27266       op0 = gen_reg_rtx (mode0);
27267       emit_insn (GEN_FCN (icode) (op0));
27268
27269       arg0 = CALL_EXPR_ARG (exp, 0);
27270       op1 = expand_normal (arg0);
27271       if (!address_operand (op1, VOIDmode))
27272         {
27273           op1 = convert_memory_address (Pmode, op1);
27274           op1 = copy_addr_to_reg (op1);
27275         }
27276       emit_move_insn (gen_rtx_MEM (mode0, op1), op0);
27277
27278       op1 = gen_reg_rtx (SImode);
27279       emit_move_insn (op1, CONST1_RTX (SImode));
27280
27281       /* Emit SImode conditional move.  */
27282       if (mode0 == HImode)
27283         {
27284           op2 = gen_reg_rtx (SImode);
27285           emit_insn (gen_zero_extendhisi2 (op2, op0));
27286         }
27287       else if (mode0 == SImode)
27288         op2 = op0;
27289       else
27290         op2 = gen_rtx_SUBREG (SImode, op0, 0);
27291
27292       if (target == 0)
27293         target = gen_reg_rtx (SImode);
27294
27295       pat = gen_rtx_GEU (VOIDmode, gen_rtx_REG (CCCmode, FLAGS_REG),
27296                          const0_rtx);
27297       emit_insn (gen_rtx_SET (VOIDmode, target,
27298                               gen_rtx_IF_THEN_ELSE (SImode, pat, op2, op1)));
27299       return target;
27300
27301     default:
27302       break;
27303     }
27304
27305   for (i = 0, d = bdesc_special_args;
27306        i < ARRAY_SIZE (bdesc_special_args);
27307        i++, d++)
27308     if (d->code == fcode)
27309       return ix86_expand_special_args_builtin (d, exp, target);
27310
27311   for (i = 0, d = bdesc_args;
27312        i < ARRAY_SIZE (bdesc_args);
27313        i++, d++)
27314     if (d->code == fcode)
27315       switch (fcode)
27316         {
27317         case IX86_BUILTIN_FABSQ:
27318         case IX86_BUILTIN_COPYSIGNQ:
27319           if (!TARGET_SSE2)
27320             /* Emit a normal call if SSE2 isn't available.  */
27321             return expand_call (exp, target, ignore);
27322         default:
27323           return ix86_expand_args_builtin (d, exp, target);
27324         }
27325
27326   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
27327     if (d->code == fcode)
27328       return ix86_expand_sse_comi (d, exp, target);
27329
27330   for (i = 0, d = bdesc_pcmpestr;
27331        i < ARRAY_SIZE (bdesc_pcmpestr);
27332        i++, d++)
27333     if (d->code == fcode)
27334       return ix86_expand_sse_pcmpestr (d, exp, target);
27335
27336   for (i = 0, d = bdesc_pcmpistr;
27337        i < ARRAY_SIZE (bdesc_pcmpistr);
27338        i++, d++)
27339     if (d->code == fcode)
27340       return ix86_expand_sse_pcmpistr (d, exp, target);
27341
27342   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
27343     if (d->code == fcode)
27344       return ix86_expand_multi_arg_builtin (d->icode, exp, target,
27345                                             (enum ix86_builtin_func_type)
27346                                             d->flag, d->comparison);
27347
27348   gcc_unreachable ();
27349 }
27350
27351 /* Returns a function decl for a vectorized version of the builtin function
27352    with builtin function code FN and the result vector type TYPE, or NULL_TREE
27353    if it is not available.  */
27354
27355 static tree
27356 ix86_builtin_vectorized_function (tree fndecl, tree type_out,
27357                                   tree type_in)
27358 {
27359   enum machine_mode in_mode, out_mode;
27360   int in_n, out_n;
27361   enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
27362
27363   if (TREE_CODE (type_out) != VECTOR_TYPE
27364       || TREE_CODE (type_in) != VECTOR_TYPE
27365       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
27366     return NULL_TREE;
27367
27368   out_mode = TYPE_MODE (TREE_TYPE (type_out));
27369   out_n = TYPE_VECTOR_SUBPARTS (type_out);
27370   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27371   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27372
27373   switch (fn)
27374     {
27375     case BUILT_IN_SQRT:
27376       if (out_mode == DFmode && in_mode == DFmode)
27377         {
27378           if (out_n == 2 && in_n == 2)
27379             return ix86_builtins[IX86_BUILTIN_SQRTPD];
27380           else if (out_n == 4 && in_n == 4)
27381             return ix86_builtins[IX86_BUILTIN_SQRTPD256];
27382         }
27383       break;
27384
27385     case BUILT_IN_SQRTF:
27386       if (out_mode == SFmode && in_mode == SFmode)
27387         {
27388           if (out_n == 4 && in_n == 4)
27389             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR];
27390           else if (out_n == 8 && in_n == 8)
27391             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR256];
27392         }
27393       break;
27394
27395     case BUILT_IN_LRINT:
27396       if (out_mode == SImode && out_n == 4
27397           && in_mode == DFmode && in_n == 2)
27398         return ix86_builtins[IX86_BUILTIN_VEC_PACK_SFIX];
27399       break;
27400
27401     case BUILT_IN_LRINTF:
27402       if (out_mode == SImode && in_mode == SFmode)
27403         {
27404           if (out_n == 4 && in_n == 4)
27405             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ];
27406           else if (out_n == 8 && in_n == 8)
27407             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ256];
27408         }
27409       break;
27410
27411     case BUILT_IN_COPYSIGN:
27412       if (out_mode == DFmode && in_mode == DFmode)
27413         {
27414           if (out_n == 2 && in_n == 2)
27415             return ix86_builtins[IX86_BUILTIN_CPYSGNPD];
27416           else if (out_n == 4 && in_n == 4)
27417             return ix86_builtins[IX86_BUILTIN_CPYSGNPD256];
27418         }
27419       break;
27420
27421     case BUILT_IN_COPYSIGNF:
27422       if (out_mode == SFmode && in_mode == SFmode)
27423         {
27424           if (out_n == 4 && in_n == 4)
27425             return ix86_builtins[IX86_BUILTIN_CPYSGNPS];
27426           else if (out_n == 8 && in_n == 8)
27427             return ix86_builtins[IX86_BUILTIN_CPYSGNPS256];
27428         }
27429       break;
27430
27431     case BUILT_IN_FLOOR:
27432       /* The round insn does not trap on denormals.  */
27433       if (flag_trapping_math || !TARGET_ROUND)
27434         break;
27435
27436       if (out_mode == DFmode && in_mode == DFmode)
27437         {
27438           if (out_n == 2 && in_n == 2)
27439             return ix86_builtins[IX86_BUILTIN_FLOORPD];
27440           else if (out_n == 4 && in_n == 4)
27441             return ix86_builtins[IX86_BUILTIN_FLOORPD256];
27442         }
27443       break;
27444
27445     case BUILT_IN_FLOORF:
27446       /* The round insn does not trap on denormals.  */
27447       if (flag_trapping_math || !TARGET_ROUND)
27448         break;
27449
27450       if (out_mode == SFmode && in_mode == SFmode)
27451         {
27452           if (out_n == 4 && in_n == 4)
27453             return ix86_builtins[IX86_BUILTIN_FLOORPS];
27454           else if (out_n == 8 && in_n == 8)
27455             return ix86_builtins[IX86_BUILTIN_FLOORPS256];
27456         }
27457       break;
27458
27459     case BUILT_IN_CEIL:
27460       /* The round insn does not trap on denormals.  */
27461       if (flag_trapping_math || !TARGET_ROUND)
27462         break;
27463
27464       if (out_mode == DFmode && in_mode == DFmode)
27465         {
27466           if (out_n == 2 && in_n == 2)
27467             return ix86_builtins[IX86_BUILTIN_CEILPD];
27468           else if (out_n == 4 && in_n == 4)
27469             return ix86_builtins[IX86_BUILTIN_CEILPD256];
27470         }
27471       break;
27472
27473     case BUILT_IN_CEILF:
27474       /* The round insn does not trap on denormals.  */
27475       if (flag_trapping_math || !TARGET_ROUND)
27476         break;
27477
27478       if (out_mode == SFmode && in_mode == SFmode)
27479         {
27480           if (out_n == 4 && in_n == 4)
27481             return ix86_builtins[IX86_BUILTIN_CEILPS];
27482           else if (out_n == 8 && in_n == 8)
27483             return ix86_builtins[IX86_BUILTIN_CEILPS256];
27484         }
27485       break;
27486
27487     case BUILT_IN_TRUNC:
27488       /* The round insn does not trap on denormals.  */
27489       if (flag_trapping_math || !TARGET_ROUND)
27490         break;
27491
27492       if (out_mode == DFmode && in_mode == DFmode)
27493         {
27494           if (out_n == 2 && in_n == 2)
27495             return ix86_builtins[IX86_BUILTIN_TRUNCPD];
27496           else if (out_n == 4 && in_n == 4)
27497             return ix86_builtins[IX86_BUILTIN_TRUNCPD256];
27498         }
27499       break;
27500
27501     case BUILT_IN_TRUNCF:
27502       /* The round insn does not trap on denormals.  */
27503       if (flag_trapping_math || !TARGET_ROUND)
27504         break;
27505
27506       if (out_mode == SFmode && in_mode == SFmode)
27507         {
27508           if (out_n == 4 && in_n == 4)
27509             return ix86_builtins[IX86_BUILTIN_TRUNCPS];
27510           else if (out_n == 8 && in_n == 8)
27511             return ix86_builtins[IX86_BUILTIN_TRUNCPS256];
27512         }
27513       break;
27514
27515     case BUILT_IN_RINT:
27516       /* The round insn does not trap on denormals.  */
27517       if (flag_trapping_math || !TARGET_ROUND)
27518         break;
27519
27520       if (out_mode == DFmode && in_mode == DFmode)
27521         {
27522           if (out_n == 2 && in_n == 2)
27523             return ix86_builtins[IX86_BUILTIN_RINTPD];
27524           else if (out_n == 4 && in_n == 4)
27525             return ix86_builtins[IX86_BUILTIN_RINTPD256];
27526         }
27527       break;
27528
27529     case BUILT_IN_RINTF:
27530       /* The round insn does not trap on denormals.  */
27531       if (flag_trapping_math || !TARGET_ROUND)
27532         break;
27533
27534       if (out_mode == SFmode && in_mode == SFmode)
27535         {
27536           if (out_n == 4 && in_n == 4)
27537             return ix86_builtins[IX86_BUILTIN_RINTPS];
27538           else if (out_n == 8 && in_n == 8)
27539             return ix86_builtins[IX86_BUILTIN_RINTPS256];
27540         }
27541       break;
27542
27543     case BUILT_IN_FMA:
27544       if (out_mode == DFmode && in_mode == DFmode)
27545         {
27546           if (out_n == 2 && in_n == 2)
27547             return ix86_builtins[IX86_BUILTIN_VFMADDPD];
27548           if (out_n == 4 && in_n == 4)
27549             return ix86_builtins[IX86_BUILTIN_VFMADDPD256];
27550         }
27551       break;
27552
27553     case BUILT_IN_FMAF:
27554       if (out_mode == SFmode && in_mode == SFmode)
27555         {
27556           if (out_n == 4 && in_n == 4)
27557             return ix86_builtins[IX86_BUILTIN_VFMADDPS];
27558           if (out_n == 8 && in_n == 8)
27559             return ix86_builtins[IX86_BUILTIN_VFMADDPS256];
27560         }
27561       break;
27562
27563     default:
27564       break;
27565     }
27566
27567   /* Dispatch to a handler for a vectorization library.  */
27568   if (ix86_veclib_handler)
27569     return ix86_veclib_handler ((enum built_in_function) fn, type_out,
27570                                 type_in);
27571
27572   return NULL_TREE;
27573 }
27574
27575 /* Handler for an SVML-style interface to
27576    a library with vectorized intrinsics.  */
27577
27578 static tree
27579 ix86_veclibabi_svml (enum built_in_function fn, tree type_out, tree type_in)
27580 {
27581   char name[20];
27582   tree fntype, new_fndecl, args;
27583   unsigned arity;
27584   const char *bname;
27585   enum machine_mode el_mode, in_mode;
27586   int n, in_n;
27587
27588   /* The SVML is suitable for unsafe math only.  */
27589   if (!flag_unsafe_math_optimizations)
27590     return NULL_TREE;
27591
27592   el_mode = TYPE_MODE (TREE_TYPE (type_out));
27593   n = TYPE_VECTOR_SUBPARTS (type_out);
27594   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27595   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27596   if (el_mode != in_mode
27597       || n != in_n)
27598     return NULL_TREE;
27599
27600   switch (fn)
27601     {
27602     case BUILT_IN_EXP:
27603     case BUILT_IN_LOG:
27604     case BUILT_IN_LOG10:
27605     case BUILT_IN_POW:
27606     case BUILT_IN_TANH:
27607     case BUILT_IN_TAN:
27608     case BUILT_IN_ATAN:
27609     case BUILT_IN_ATAN2:
27610     case BUILT_IN_ATANH:
27611     case BUILT_IN_CBRT:
27612     case BUILT_IN_SINH:
27613     case BUILT_IN_SIN:
27614     case BUILT_IN_ASINH:
27615     case BUILT_IN_ASIN:
27616     case BUILT_IN_COSH:
27617     case BUILT_IN_COS:
27618     case BUILT_IN_ACOSH:
27619     case BUILT_IN_ACOS:
27620       if (el_mode != DFmode || n != 2)
27621         return NULL_TREE;
27622       break;
27623
27624     case BUILT_IN_EXPF:
27625     case BUILT_IN_LOGF:
27626     case BUILT_IN_LOG10F:
27627     case BUILT_IN_POWF:
27628     case BUILT_IN_TANHF:
27629     case BUILT_IN_TANF:
27630     case BUILT_IN_ATANF:
27631     case BUILT_IN_ATAN2F:
27632     case BUILT_IN_ATANHF:
27633     case BUILT_IN_CBRTF:
27634     case BUILT_IN_SINHF:
27635     case BUILT_IN_SINF:
27636     case BUILT_IN_ASINHF:
27637     case BUILT_IN_ASINF:
27638     case BUILT_IN_COSHF:
27639     case BUILT_IN_COSF:
27640     case BUILT_IN_ACOSHF:
27641     case BUILT_IN_ACOSF:
27642       if (el_mode != SFmode || n != 4)
27643         return NULL_TREE;
27644       break;
27645
27646     default:
27647       return NULL_TREE;
27648     }
27649
27650   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
27651
27652   if (fn == BUILT_IN_LOGF)
27653     strcpy (name, "vmlsLn4");
27654   else if (fn == BUILT_IN_LOG)
27655     strcpy (name, "vmldLn2");
27656   else if (n == 4)
27657     {
27658       sprintf (name, "vmls%s", bname+10);
27659       name[strlen (name)-1] = '4';
27660     }
27661   else
27662     sprintf (name, "vmld%s2", bname+10);
27663
27664   /* Convert to uppercase. */
27665   name[4] &= ~0x20;
27666
27667   arity = 0;
27668   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
27669        args = TREE_CHAIN (args))
27670     arity++;
27671
27672   if (arity == 1)
27673     fntype = build_function_type_list (type_out, type_in, NULL);
27674   else
27675     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
27676
27677   /* Build a function declaration for the vectorized function.  */
27678   new_fndecl = build_decl (BUILTINS_LOCATION,
27679                            FUNCTION_DECL, get_identifier (name), fntype);
27680   TREE_PUBLIC (new_fndecl) = 1;
27681   DECL_EXTERNAL (new_fndecl) = 1;
27682   DECL_IS_NOVOPS (new_fndecl) = 1;
27683   TREE_READONLY (new_fndecl) = 1;
27684
27685   return new_fndecl;
27686 }
27687
27688 /* Handler for an ACML-style interface to
27689    a library with vectorized intrinsics.  */
27690
27691 static tree
27692 ix86_veclibabi_acml (enum built_in_function fn, tree type_out, tree type_in)
27693 {
27694   char name[20] = "__vr.._";
27695   tree fntype, new_fndecl, args;
27696   unsigned arity;
27697   const char *bname;
27698   enum machine_mode el_mode, in_mode;
27699   int n, in_n;
27700
27701   /* The ACML is 64bits only and suitable for unsafe math only as
27702      it does not correctly support parts of IEEE with the required
27703      precision such as denormals.  */
27704   if (!TARGET_64BIT
27705       || !flag_unsafe_math_optimizations)
27706     return NULL_TREE;
27707
27708   el_mode = TYPE_MODE (TREE_TYPE (type_out));
27709   n = TYPE_VECTOR_SUBPARTS (type_out);
27710   in_mode = TYPE_MODE (TREE_TYPE (type_in));
27711   in_n = TYPE_VECTOR_SUBPARTS (type_in);
27712   if (el_mode != in_mode
27713       || n != in_n)
27714     return NULL_TREE;
27715
27716   switch (fn)
27717     {
27718     case BUILT_IN_SIN:
27719     case BUILT_IN_COS:
27720     case BUILT_IN_EXP:
27721     case BUILT_IN_LOG:
27722     case BUILT_IN_LOG2:
27723     case BUILT_IN_LOG10:
27724       name[4] = 'd';
27725       name[5] = '2';
27726       if (el_mode != DFmode
27727           || n != 2)
27728         return NULL_TREE;
27729       break;
27730
27731     case BUILT_IN_SINF:
27732     case BUILT_IN_COSF:
27733     case BUILT_IN_EXPF:
27734     case BUILT_IN_POWF:
27735     case BUILT_IN_LOGF:
27736     case BUILT_IN_LOG2F:
27737     case BUILT_IN_LOG10F:
27738       name[4] = 's';
27739       name[5] = '4';
27740       if (el_mode != SFmode
27741           || n != 4)
27742         return NULL_TREE;
27743       break;
27744
27745     default:
27746       return NULL_TREE;
27747     }
27748
27749   bname = IDENTIFIER_POINTER (DECL_NAME (implicit_built_in_decls[fn]));
27750   sprintf (name + 7, "%s", bname+10);
27751
27752   arity = 0;
27753   for (args = DECL_ARGUMENTS (implicit_built_in_decls[fn]); args;
27754        args = TREE_CHAIN (args))
27755     arity++;
27756
27757   if (arity == 1)
27758     fntype = build_function_type_list (type_out, type_in, NULL);
27759   else
27760     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
27761
27762   /* Build a function declaration for the vectorized function.  */
27763   new_fndecl = build_decl (BUILTINS_LOCATION,
27764                            FUNCTION_DECL, get_identifier (name), fntype);
27765   TREE_PUBLIC (new_fndecl) = 1;
27766   DECL_EXTERNAL (new_fndecl) = 1;
27767   DECL_IS_NOVOPS (new_fndecl) = 1;
27768   TREE_READONLY (new_fndecl) = 1;
27769
27770   return new_fndecl;
27771 }
27772
27773
27774 /* Returns a decl of a function that implements conversion of an integer vector
27775    into a floating-point vector, or vice-versa.  DEST_TYPE and SRC_TYPE
27776    are the types involved when converting according to CODE.
27777    Return NULL_TREE if it is not available.  */
27778
27779 static tree
27780 ix86_vectorize_builtin_conversion (unsigned int code,
27781                                    tree dest_type, tree src_type)
27782 {
27783   if (! TARGET_SSE2)
27784     return NULL_TREE;
27785
27786   switch (code)
27787     {
27788     case FLOAT_EXPR:
27789       switch (TYPE_MODE (src_type))
27790         {
27791         case V4SImode:
27792           switch (TYPE_MODE (dest_type))
27793             {
27794             case V4SFmode:
27795               return (TYPE_UNSIGNED (src_type)
27796                       ? ix86_builtins[IX86_BUILTIN_CVTUDQ2PS]
27797                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS]);
27798             case V4DFmode:
27799               return (TYPE_UNSIGNED (src_type)
27800                       ? NULL_TREE
27801                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PD256]);
27802             default:
27803               return NULL_TREE;
27804             }
27805           break;
27806         case V8SImode:
27807           switch (TYPE_MODE (dest_type))
27808             {
27809             case V8SFmode:
27810               return (TYPE_UNSIGNED (src_type)
27811                       ? NULL_TREE
27812                       : ix86_builtins[IX86_BUILTIN_CVTDQ2PS256]);
27813             default:
27814               return NULL_TREE;
27815             }
27816           break;
27817         default:
27818           return NULL_TREE;
27819         }
27820
27821     case FIX_TRUNC_EXPR:
27822       switch (TYPE_MODE (dest_type))
27823         {
27824         case V4SImode:
27825           switch (TYPE_MODE (src_type))
27826             {
27827             case V4SFmode:
27828               return (TYPE_UNSIGNED (dest_type)
27829                       ? NULL_TREE
27830                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ]);
27831             case V4DFmode:
27832               return (TYPE_UNSIGNED (dest_type)
27833                       ? NULL_TREE
27834                       : ix86_builtins[IX86_BUILTIN_CVTTPD2DQ256]);
27835             default:
27836               return NULL_TREE;
27837             }
27838           break;
27839
27840         case V8SImode:
27841           switch (TYPE_MODE (src_type))
27842             {
27843             case V8SFmode:
27844               return (TYPE_UNSIGNED (dest_type)
27845                       ? NULL_TREE
27846                       : ix86_builtins[IX86_BUILTIN_CVTTPS2DQ256]);
27847             default:
27848               return NULL_TREE;
27849             }
27850           break;
27851
27852         default:
27853           return NULL_TREE;
27854         }
27855
27856     default:
27857       return NULL_TREE;
27858     }
27859
27860   return NULL_TREE;
27861 }
27862
27863 /* Returns a code for a target-specific builtin that implements
27864    reciprocal of the function, or NULL_TREE if not available.  */
27865
27866 static tree
27867 ix86_builtin_reciprocal (unsigned int fn, bool md_fn,
27868                          bool sqrt ATTRIBUTE_UNUSED)
27869 {
27870   if (! (TARGET_SSE_MATH && !optimize_insn_for_size_p ()
27871          && flag_finite_math_only && !flag_trapping_math
27872          && flag_unsafe_math_optimizations))
27873     return NULL_TREE;
27874
27875   if (md_fn)
27876     /* Machine dependent builtins.  */
27877     switch (fn)
27878       {
27879         /* Vectorized version of sqrt to rsqrt conversion.  */
27880       case IX86_BUILTIN_SQRTPS_NR:
27881         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR];
27882
27883       case IX86_BUILTIN_SQRTPS_NR256:
27884         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR256];
27885
27886       default:
27887         return NULL_TREE;
27888       }
27889   else
27890     /* Normal builtins.  */
27891     switch (fn)
27892       {
27893         /* Sqrt to rsqrt conversion.  */
27894       case BUILT_IN_SQRTF:
27895         return ix86_builtins[IX86_BUILTIN_RSQRTF];
27896
27897       default:
27898         return NULL_TREE;
27899       }
27900 }
27901 \f
27902 /* Helper for avx_vpermilps256_operand et al.  This is also used by
27903    the expansion functions to turn the parallel back into a mask.
27904    The return value is 0 for no match and the imm8+1 for a match.  */
27905
27906 int
27907 avx_vpermilp_parallel (rtx par, enum machine_mode mode)
27908 {
27909   unsigned i, nelt = GET_MODE_NUNITS (mode);
27910   unsigned mask = 0;
27911   unsigned char ipar[8];
27912
27913   if (XVECLEN (par, 0) != (int) nelt)
27914     return 0;
27915
27916   /* Validate that all of the elements are constants, and not totally
27917      out of range.  Copy the data into an integral array to make the
27918      subsequent checks easier.  */
27919   for (i = 0; i < nelt; ++i)
27920     {
27921       rtx er = XVECEXP (par, 0, i);
27922       unsigned HOST_WIDE_INT ei;
27923
27924       if (!CONST_INT_P (er))
27925         return 0;
27926       ei = INTVAL (er);
27927       if (ei >= nelt)
27928         return 0;
27929       ipar[i] = ei;
27930     }
27931
27932   switch (mode)
27933     {
27934     case V4DFmode:
27935       /* In the 256-bit DFmode case, we can only move elements within
27936          a 128-bit lane.  */
27937       for (i = 0; i < 2; ++i)
27938         {
27939           if (ipar[i] >= 2)
27940             return 0;
27941           mask |= ipar[i] << i;
27942         }
27943       for (i = 2; i < 4; ++i)
27944         {
27945           if (ipar[i] < 2)
27946             return 0;
27947           mask |= (ipar[i] - 2) << i;
27948         }
27949       break;
27950
27951     case V8SFmode:
27952       /* In the 256-bit SFmode case, we have full freedom of movement
27953          within the low 128-bit lane, but the high 128-bit lane must
27954          mirror the exact same pattern.  */
27955       for (i = 0; i < 4; ++i)
27956         if (ipar[i] + 4 != ipar[i + 4])
27957           return 0;
27958       nelt = 4;
27959       /* FALLTHRU */
27960
27961     case V2DFmode:
27962     case V4SFmode:
27963       /* In the 128-bit case, we've full freedom in the placement of
27964          the elements from the source operand.  */
27965       for (i = 0; i < nelt; ++i)
27966         mask |= ipar[i] << (i * (nelt / 2));
27967       break;
27968
27969     default:
27970       gcc_unreachable ();
27971     }
27972
27973   /* Make sure success has a non-zero value by adding one.  */
27974   return mask + 1;
27975 }
27976
27977 /* Helper for avx_vperm2f128_v4df_operand et al.  This is also used by
27978    the expansion functions to turn the parallel back into a mask.
27979    The return value is 0 for no match and the imm8+1 for a match.  */
27980
27981 int
27982 avx_vperm2f128_parallel (rtx par, enum machine_mode mode)
27983 {
27984   unsigned i, nelt = GET_MODE_NUNITS (mode), nelt2 = nelt / 2;
27985   unsigned mask = 0;
27986   unsigned char ipar[8];
27987
27988   if (XVECLEN (par, 0) != (int) nelt)
27989     return 0;
27990
27991   /* Validate that all of the elements are constants, and not totally
27992      out of range.  Copy the data into an integral array to make the
27993      subsequent checks easier.  */
27994   for (i = 0; i < nelt; ++i)
27995     {
27996       rtx er = XVECEXP (par, 0, i);
27997       unsigned HOST_WIDE_INT ei;
27998
27999       if (!CONST_INT_P (er))
28000         return 0;
28001       ei = INTVAL (er);
28002       if (ei >= 2 * nelt)
28003         return 0;
28004       ipar[i] = ei;
28005     }
28006
28007   /* Validate that the halves of the permute are halves.  */
28008   for (i = 0; i < nelt2 - 1; ++i)
28009     if (ipar[i] + 1 != ipar[i + 1])
28010       return 0;
28011   for (i = nelt2; i < nelt - 1; ++i)
28012     if (ipar[i] + 1 != ipar[i + 1])
28013       return 0;
28014
28015   /* Reconstruct the mask.  */
28016   for (i = 0; i < 2; ++i)
28017     {
28018       unsigned e = ipar[i * nelt2];
28019       if (e % nelt2)
28020         return 0;
28021       e /= nelt2;
28022       mask |= e << (i * 4);
28023     }
28024
28025   /* Make sure success has a non-zero value by adding one.  */
28026   return mask + 1;
28027 }
28028 \f
28029
28030 /* Store OPERAND to the memory after reload is completed.  This means
28031    that we can't easily use assign_stack_local.  */
28032 rtx
28033 ix86_force_to_memory (enum machine_mode mode, rtx operand)
28034 {
28035   rtx result;
28036
28037   gcc_assert (reload_completed);
28038   if (ix86_using_red_zone ())
28039     {
28040       result = gen_rtx_MEM (mode,
28041                             gen_rtx_PLUS (Pmode,
28042                                           stack_pointer_rtx,
28043                                           GEN_INT (-RED_ZONE_SIZE)));
28044       emit_move_insn (result, operand);
28045     }
28046   else if (TARGET_64BIT)
28047     {
28048       switch (mode)
28049         {
28050         case HImode:
28051         case SImode:
28052           operand = gen_lowpart (DImode, operand);
28053           /* FALLTHRU */
28054         case DImode:
28055           emit_insn (
28056                       gen_rtx_SET (VOIDmode,
28057                                    gen_rtx_MEM (DImode,
28058                                                 gen_rtx_PRE_DEC (DImode,
28059                                                         stack_pointer_rtx)),
28060                                    operand));
28061           break;
28062         default:
28063           gcc_unreachable ();
28064         }
28065       result = gen_rtx_MEM (mode, stack_pointer_rtx);
28066     }
28067   else
28068     {
28069       switch (mode)
28070         {
28071         case DImode:
28072           {
28073             rtx operands[2];
28074             split_double_mode (mode, &operand, 1, operands, operands + 1);
28075             emit_insn (
28076                         gen_rtx_SET (VOIDmode,
28077                                      gen_rtx_MEM (SImode,
28078                                                   gen_rtx_PRE_DEC (Pmode,
28079                                                         stack_pointer_rtx)),
28080                                      operands[1]));
28081             emit_insn (
28082                         gen_rtx_SET (VOIDmode,
28083                                      gen_rtx_MEM (SImode,
28084                                                   gen_rtx_PRE_DEC (Pmode,
28085                                                         stack_pointer_rtx)),
28086                                      operands[0]));
28087           }
28088           break;
28089         case HImode:
28090           /* Store HImodes as SImodes.  */
28091           operand = gen_lowpart (SImode, operand);
28092           /* FALLTHRU */
28093         case SImode:
28094           emit_insn (
28095                       gen_rtx_SET (VOIDmode,
28096                                    gen_rtx_MEM (GET_MODE (operand),
28097                                                 gen_rtx_PRE_DEC (SImode,
28098                                                         stack_pointer_rtx)),
28099                                    operand));
28100           break;
28101         default:
28102           gcc_unreachable ();
28103         }
28104       result = gen_rtx_MEM (mode, stack_pointer_rtx);
28105     }
28106   return result;
28107 }
28108
28109 /* Free operand from the memory.  */
28110 void
28111 ix86_free_from_memory (enum machine_mode mode)
28112 {
28113   if (!ix86_using_red_zone ())
28114     {
28115       int size;
28116
28117       if (mode == DImode || TARGET_64BIT)
28118         size = 8;
28119       else
28120         size = 4;
28121       /* Use LEA to deallocate stack space.  In peephole2 it will be converted
28122          to pop or add instruction if registers are available.  */
28123       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
28124                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
28125                                             GEN_INT (size))));
28126     }
28127 }
28128
28129 /* Implement TARGET_PREFERRED_RELOAD_CLASS.
28130
28131    Put float CONST_DOUBLE in the constant pool instead of fp regs.
28132    QImode must go into class Q_REGS.
28133    Narrow ALL_REGS to GENERAL_REGS.  This supports allowing movsf and
28134    movdf to do mem-to-mem moves through integer regs.  */
28135
28136 static reg_class_t
28137 ix86_preferred_reload_class (rtx x, reg_class_t regclass)
28138 {
28139   enum machine_mode mode = GET_MODE (x);
28140
28141   /* We're only allowed to return a subclass of CLASS.  Many of the
28142      following checks fail for NO_REGS, so eliminate that early.  */
28143   if (regclass == NO_REGS)
28144     return NO_REGS;
28145
28146   /* All classes can load zeros.  */
28147   if (x == CONST0_RTX (mode))
28148     return regclass;
28149
28150   /* Force constants into memory if we are loading a (nonzero) constant into
28151      an MMX or SSE register.  This is because there are no MMX/SSE instructions
28152      to load from a constant.  */
28153   if (CONSTANT_P (x)
28154       && (MAYBE_MMX_CLASS_P (regclass) || MAYBE_SSE_CLASS_P (regclass)))
28155     return NO_REGS;
28156
28157   /* Prefer SSE regs only, if we can use them for math.  */
28158   if (TARGET_SSE_MATH && !TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P (mode))
28159     return SSE_CLASS_P (regclass) ? regclass : NO_REGS;
28160
28161   /* Floating-point constants need more complex checks.  */
28162   if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode)
28163     {
28164       /* General regs can load everything.  */
28165       if (reg_class_subset_p (regclass, GENERAL_REGS))
28166         return regclass;
28167
28168       /* Floats can load 0 and 1 plus some others.  Note that we eliminated
28169          zero above.  We only want to wind up preferring 80387 registers if
28170          we plan on doing computation with them.  */
28171       if (TARGET_80387
28172           && standard_80387_constant_p (x) > 0)
28173         {
28174           /* Limit class to non-sse.  */
28175           if (regclass == FLOAT_SSE_REGS)
28176             return FLOAT_REGS;
28177           if (regclass == FP_TOP_SSE_REGS)
28178             return FP_TOP_REG;
28179           if (regclass == FP_SECOND_SSE_REGS)
28180             return FP_SECOND_REG;
28181           if (regclass == FLOAT_INT_REGS || regclass == FLOAT_REGS)
28182             return regclass;
28183         }
28184
28185       return NO_REGS;
28186     }
28187
28188   /* Generally when we see PLUS here, it's the function invariant
28189      (plus soft-fp const_int).  Which can only be computed into general
28190      regs.  */
28191   if (GET_CODE (x) == PLUS)
28192     return reg_class_subset_p (regclass, GENERAL_REGS) ? regclass : NO_REGS;
28193
28194   /* QImode constants are easy to load, but non-constant QImode data
28195      must go into Q_REGS.  */
28196   if (GET_MODE (x) == QImode && !CONSTANT_P (x))
28197     {
28198       if (reg_class_subset_p (regclass, Q_REGS))
28199         return regclass;
28200       if (reg_class_subset_p (Q_REGS, regclass))
28201         return Q_REGS;
28202       return NO_REGS;
28203     }
28204
28205   return regclass;
28206 }
28207
28208 /* Discourage putting floating-point values in SSE registers unless
28209    SSE math is being used, and likewise for the 387 registers.  */
28210 static reg_class_t
28211 ix86_preferred_output_reload_class (rtx x, reg_class_t regclass)
28212 {
28213   enum machine_mode mode = GET_MODE (x);
28214
28215   /* Restrict the output reload class to the register bank that we are doing
28216      math on.  If we would like not to return a subset of CLASS, reject this
28217      alternative: if reload cannot do this, it will still use its choice.  */
28218   mode = GET_MODE (x);
28219   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
28220     return MAYBE_SSE_CLASS_P (regclass) ? SSE_REGS : NO_REGS;
28221
28222   if (X87_FLOAT_MODE_P (mode))
28223     {
28224       if (regclass == FP_TOP_SSE_REGS)
28225         return FP_TOP_REG;
28226       else if (regclass == FP_SECOND_SSE_REGS)
28227         return FP_SECOND_REG;
28228       else
28229         return FLOAT_CLASS_P (regclass) ? regclass : NO_REGS;
28230     }
28231
28232   return regclass;
28233 }
28234
28235 static reg_class_t
28236 ix86_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
28237                        enum machine_mode mode,
28238                        secondary_reload_info *sri ATTRIBUTE_UNUSED)
28239 {
28240   /* QImode spills from non-QI registers require
28241      intermediate register on 32bit targets.  */
28242   if (!TARGET_64BIT
28243       && !in_p && mode == QImode
28244       && (rclass == GENERAL_REGS
28245           || rclass == LEGACY_REGS
28246           || rclass == INDEX_REGS))
28247     {
28248       int regno;
28249
28250       if (REG_P (x))
28251         regno = REGNO (x);
28252       else
28253         regno = -1;
28254
28255       if (regno >= FIRST_PSEUDO_REGISTER || GET_CODE (x) == SUBREG)
28256         regno = true_regnum (x);
28257
28258       /* Return Q_REGS if the operand is in memory.  */
28259       if (regno == -1)
28260         return Q_REGS;
28261     }
28262
28263   /* This condition handles corner case where an expression involving
28264      pointers gets vectorized.  We're trying to use the address of a
28265      stack slot as a vector initializer.
28266
28267      (set (reg:V2DI 74 [ vect_cst_.2 ])
28268           (vec_duplicate:V2DI (reg/f:DI 20 frame)))
28269
28270      Eventually frame gets turned into sp+offset like this:
28271
28272      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28273           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
28274                                        (const_int 392 [0x188]))))
28275
28276      That later gets turned into:
28277
28278      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28279           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
28280             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))))
28281
28282      We'll have the following reload recorded:
28283
28284      Reload 0: reload_in (DI) =
28285            (plus:DI (reg/f:DI 7 sp)
28286             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))
28287      reload_out (V2DI) = (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28288      SSE_REGS, RELOAD_OTHER (opnum = 0), can't combine
28289      reload_in_reg: (plus:DI (reg/f:DI 7 sp) (const_int 392 [0x188]))
28290      reload_out_reg: (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
28291      reload_reg_rtx: (reg:V2DI 22 xmm1)
28292
28293      Which isn't going to work since SSE instructions can't handle scalar
28294      additions.  Returning GENERAL_REGS forces the addition into integer
28295      register and reload can handle subsequent reloads without problems.  */
28296
28297   if (in_p && GET_CODE (x) == PLUS
28298       && SSE_CLASS_P (rclass)
28299       && SCALAR_INT_MODE_P (mode))
28300     return GENERAL_REGS;
28301
28302   return NO_REGS;
28303 }
28304
28305 /* Implement TARGET_CLASS_LIKELY_SPILLED_P.  */
28306
28307 static bool
28308 ix86_class_likely_spilled_p (reg_class_t rclass)
28309 {
28310   switch (rclass)
28311     {
28312       case AREG:
28313       case DREG:
28314       case CREG:
28315       case BREG:
28316       case AD_REGS:
28317       case SIREG:
28318       case DIREG:
28319       case SSE_FIRST_REG:
28320       case FP_TOP_REG:
28321       case FP_SECOND_REG:
28322         return true;
28323
28324       default:
28325         break;
28326     }
28327
28328   return false;
28329 }
28330
28331 /* If we are copying between general and FP registers, we need a memory
28332    location. The same is true for SSE and MMX registers.
28333
28334    To optimize register_move_cost performance, allow inline variant.
28335
28336    The macro can't work reliably when one of the CLASSES is class containing
28337    registers from multiple units (SSE, MMX, integer).  We avoid this by never
28338    combining those units in single alternative in the machine description.
28339    Ensure that this constraint holds to avoid unexpected surprises.
28340
28341    When STRICT is false, we are being called from REGISTER_MOVE_COST, so do not
28342    enforce these sanity checks.  */
28343
28344 static inline bool
28345 inline_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
28346                                 enum machine_mode mode, int strict)
28347 {
28348   if (MAYBE_FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class1)
28349       || MAYBE_FLOAT_CLASS_P (class2) != FLOAT_CLASS_P (class2)
28350       || MAYBE_SSE_CLASS_P (class1) != SSE_CLASS_P (class1)
28351       || MAYBE_SSE_CLASS_P (class2) != SSE_CLASS_P (class2)
28352       || MAYBE_MMX_CLASS_P (class1) != MMX_CLASS_P (class1)
28353       || MAYBE_MMX_CLASS_P (class2) != MMX_CLASS_P (class2))
28354     {
28355       gcc_assert (!strict);
28356       return true;
28357     }
28358
28359   if (FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class2))
28360     return true;
28361
28362   /* ??? This is a lie.  We do have moves between mmx/general, and for
28363      mmx/sse2.  But by saying we need secondary memory we discourage the
28364      register allocator from using the mmx registers unless needed.  */
28365   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2))
28366     return true;
28367
28368   if (SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
28369     {
28370       /* SSE1 doesn't have any direct moves from other classes.  */
28371       if (!TARGET_SSE2)
28372         return true;
28373
28374       /* If the target says that inter-unit moves are more expensive
28375          than moving through memory, then don't generate them.  */
28376       if (!TARGET_INTER_UNIT_MOVES)
28377         return true;
28378
28379       /* Between SSE and general, we have moves no larger than word size.  */
28380       if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
28381         return true;
28382     }
28383
28384   return false;
28385 }
28386
28387 bool
28388 ix86_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
28389                               enum machine_mode mode, int strict)
28390 {
28391   return inline_secondary_memory_needed (class1, class2, mode, strict);
28392 }
28393
28394 /* Implement the TARGET_CLASS_MAX_NREGS hook.
28395
28396    On the 80386, this is the size of MODE in words,
28397    except in the FP regs, where a single reg is always enough.  */
28398
28399 static unsigned char
28400 ix86_class_max_nregs (reg_class_t rclass, enum machine_mode mode)
28401 {
28402   if (MAYBE_INTEGER_CLASS_P (rclass))
28403     {
28404       if (mode == XFmode)
28405         return (TARGET_64BIT ? 2 : 3);
28406       else if (mode == XCmode)
28407         return (TARGET_64BIT ? 4 : 6);
28408       else
28409         return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
28410     }
28411   else
28412     {
28413       if (COMPLEX_MODE_P (mode))
28414         return 2;
28415       else
28416         return 1;
28417     }
28418 }
28419
28420 /* Return true if the registers in CLASS cannot represent the change from
28421    modes FROM to TO.  */
28422
28423 bool
28424 ix86_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
28425                                enum reg_class regclass)
28426 {
28427   if (from == to)
28428     return false;
28429
28430   /* x87 registers can't do subreg at all, as all values are reformatted
28431      to extended precision.  */
28432   if (MAYBE_FLOAT_CLASS_P (regclass))
28433     return true;
28434
28435   if (MAYBE_SSE_CLASS_P (regclass) || MAYBE_MMX_CLASS_P (regclass))
28436     {
28437       /* Vector registers do not support QI or HImode loads.  If we don't
28438          disallow a change to these modes, reload will assume it's ok to
28439          drop the subreg from (subreg:SI (reg:HI 100) 0).  This affects
28440          the vec_dupv4hi pattern.  */
28441       if (GET_MODE_SIZE (from) < 4)
28442         return true;
28443
28444       /* Vector registers do not support subreg with nonzero offsets, which
28445          are otherwise valid for integer registers.  Since we can't see
28446          whether we have a nonzero offset from here, prohibit all
28447          nonparadoxical subregs changing size.  */
28448       if (GET_MODE_SIZE (to) < GET_MODE_SIZE (from))
28449         return true;
28450     }
28451
28452   return false;
28453 }
28454
28455 /* Return the cost of moving data of mode M between a
28456    register and memory.  A value of 2 is the default; this cost is
28457    relative to those in `REGISTER_MOVE_COST'.
28458
28459    This function is used extensively by register_move_cost that is used to
28460    build tables at startup.  Make it inline in this case.
28461    When IN is 2, return maximum of in and out move cost.
28462
28463    If moving between registers and memory is more expensive than
28464    between two registers, you should define this macro to express the
28465    relative cost.
28466
28467    Model also increased moving costs of QImode registers in non
28468    Q_REGS classes.
28469  */
28470 static inline int
28471 inline_memory_move_cost (enum machine_mode mode, enum reg_class regclass,
28472                          int in)
28473 {
28474   int cost;
28475   if (FLOAT_CLASS_P (regclass))
28476     {
28477       int index;
28478       switch (mode)
28479         {
28480           case SFmode:
28481             index = 0;
28482             break;
28483           case DFmode:
28484             index = 1;
28485             break;
28486           case XFmode:
28487             index = 2;
28488             break;
28489           default:
28490             return 100;
28491         }
28492       if (in == 2)
28493         return MAX (ix86_cost->fp_load [index], ix86_cost->fp_store [index]);
28494       return in ? ix86_cost->fp_load [index] : ix86_cost->fp_store [index];
28495     }
28496   if (SSE_CLASS_P (regclass))
28497     {
28498       int index;
28499       switch (GET_MODE_SIZE (mode))
28500         {
28501           case 4:
28502             index = 0;
28503             break;
28504           case 8:
28505             index = 1;
28506             break;
28507           case 16:
28508             index = 2;
28509             break;
28510           default:
28511             return 100;
28512         }
28513       if (in == 2)
28514         return MAX (ix86_cost->sse_load [index], ix86_cost->sse_store [index]);
28515       return in ? ix86_cost->sse_load [index] : ix86_cost->sse_store [index];
28516     }
28517   if (MMX_CLASS_P (regclass))
28518     {
28519       int index;
28520       switch (GET_MODE_SIZE (mode))
28521         {
28522           case 4:
28523             index = 0;
28524             break;
28525           case 8:
28526             index = 1;
28527             break;
28528           default:
28529             return 100;
28530         }
28531       if (in)
28532         return MAX (ix86_cost->mmx_load [index], ix86_cost->mmx_store [index]);
28533       return in ? ix86_cost->mmx_load [index] : ix86_cost->mmx_store [index];
28534     }
28535   switch (GET_MODE_SIZE (mode))
28536     {
28537       case 1:
28538         if (Q_CLASS_P (regclass) || TARGET_64BIT)
28539           {
28540             if (!in)
28541               return ix86_cost->int_store[0];
28542             if (TARGET_PARTIAL_REG_DEPENDENCY
28543                 && optimize_function_for_speed_p (cfun))
28544               cost = ix86_cost->movzbl_load;
28545             else
28546               cost = ix86_cost->int_load[0];
28547             if (in == 2)
28548               return MAX (cost, ix86_cost->int_store[0]);
28549             return cost;
28550           }
28551         else
28552           {
28553            if (in == 2)
28554              return MAX (ix86_cost->movzbl_load, ix86_cost->int_store[0] + 4);
28555            if (in)
28556              return ix86_cost->movzbl_load;
28557            else
28558              return ix86_cost->int_store[0] + 4;
28559           }
28560         break;
28561       case 2:
28562         if (in == 2)
28563           return MAX (ix86_cost->int_load[1], ix86_cost->int_store[1]);
28564         return in ? ix86_cost->int_load[1] : ix86_cost->int_store[1];
28565       default:
28566         /* Compute number of 32bit moves needed.  TFmode is moved as XFmode.  */
28567         if (mode == TFmode)
28568           mode = XFmode;
28569         if (in == 2)
28570           cost = MAX (ix86_cost->int_load[2] , ix86_cost->int_store[2]);
28571         else if (in)
28572           cost = ix86_cost->int_load[2];
28573         else
28574           cost = ix86_cost->int_store[2];
28575         return (cost * (((int) GET_MODE_SIZE (mode)
28576                         + UNITS_PER_WORD - 1) / UNITS_PER_WORD));
28577     }
28578 }
28579
28580 static int
28581 ix86_memory_move_cost (enum machine_mode mode, reg_class_t regclass,
28582                        bool in)
28583 {
28584   return inline_memory_move_cost (mode, (enum reg_class) regclass, in ? 1 : 0);
28585 }
28586
28587
28588 /* Return the cost of moving data from a register in class CLASS1 to
28589    one in class CLASS2.
28590
28591    It is not required that the cost always equal 2 when FROM is the same as TO;
28592    on some machines it is expensive to move between registers if they are not
28593    general registers.  */
28594
28595 static int
28596 ix86_register_move_cost (enum machine_mode mode, reg_class_t class1_i,
28597                          reg_class_t class2_i)
28598 {
28599   enum reg_class class1 = (enum reg_class) class1_i;
28600   enum reg_class class2 = (enum reg_class) class2_i;
28601
28602   /* In case we require secondary memory, compute cost of the store followed
28603      by load.  In order to avoid bad register allocation choices, we need
28604      for this to be *at least* as high as the symmetric MEMORY_MOVE_COST.  */
28605
28606   if (inline_secondary_memory_needed (class1, class2, mode, 0))
28607     {
28608       int cost = 1;
28609
28610       cost += inline_memory_move_cost (mode, class1, 2);
28611       cost += inline_memory_move_cost (mode, class2, 2);
28612
28613       /* In case of copying from general_purpose_register we may emit multiple
28614          stores followed by single load causing memory size mismatch stall.
28615          Count this as arbitrarily high cost of 20.  */
28616       if (targetm.class_max_nregs (class1, mode)
28617           > targetm.class_max_nregs (class2, mode))
28618         cost += 20;
28619
28620       /* In the case of FP/MMX moves, the registers actually overlap, and we
28621          have to switch modes in order to treat them differently.  */
28622       if ((MMX_CLASS_P (class1) && MAYBE_FLOAT_CLASS_P (class2))
28623           || (MMX_CLASS_P (class2) && MAYBE_FLOAT_CLASS_P (class1)))
28624         cost += 20;
28625
28626       return cost;
28627     }
28628
28629   /* Moves between SSE/MMX and integer unit are expensive.  */
28630   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2)
28631       || SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
28632
28633     /* ??? By keeping returned value relatively high, we limit the number
28634        of moves between integer and MMX/SSE registers for all targets.
28635        Additionally, high value prevents problem with x86_modes_tieable_p(),
28636        where integer modes in MMX/SSE registers are not tieable
28637        because of missing QImode and HImode moves to, from or between
28638        MMX/SSE registers.  */
28639     return MAX (8, ix86_cost->mmxsse_to_integer);
28640
28641   if (MAYBE_FLOAT_CLASS_P (class1))
28642     return ix86_cost->fp_move;
28643   if (MAYBE_SSE_CLASS_P (class1))
28644     return ix86_cost->sse_move;
28645   if (MAYBE_MMX_CLASS_P (class1))
28646     return ix86_cost->mmx_move;
28647   return 2;
28648 }
28649
28650 /* Return TRUE if hard register REGNO can hold a value of machine-mode
28651    MODE.  */
28652
28653 bool
28654 ix86_hard_regno_mode_ok (int regno, enum machine_mode mode)
28655 {
28656   /* Flags and only flags can only hold CCmode values.  */
28657   if (CC_REGNO_P (regno))
28658     return GET_MODE_CLASS (mode) == MODE_CC;
28659   if (GET_MODE_CLASS (mode) == MODE_CC
28660       || GET_MODE_CLASS (mode) == MODE_RANDOM
28661       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
28662     return false;
28663   if (FP_REGNO_P (regno))
28664     return VALID_FP_MODE_P (mode);
28665   if (SSE_REGNO_P (regno))
28666     {
28667       /* We implement the move patterns for all vector modes into and
28668          out of SSE registers, even when no operation instructions
28669          are available.  OImode move is available only when AVX is
28670          enabled.  */
28671       return ((TARGET_AVX && mode == OImode)
28672               || VALID_AVX256_REG_MODE (mode)
28673               || VALID_SSE_REG_MODE (mode)
28674               || VALID_SSE2_REG_MODE (mode)
28675               || VALID_MMX_REG_MODE (mode)
28676               || VALID_MMX_REG_MODE_3DNOW (mode));
28677     }
28678   if (MMX_REGNO_P (regno))
28679     {
28680       /* We implement the move patterns for 3DNOW modes even in MMX mode,
28681          so if the register is available at all, then we can move data of
28682          the given mode into or out of it.  */
28683       return (VALID_MMX_REG_MODE (mode)
28684               || VALID_MMX_REG_MODE_3DNOW (mode));
28685     }
28686
28687   if (mode == QImode)
28688     {
28689       /* Take care for QImode values - they can be in non-QI regs,
28690          but then they do cause partial register stalls.  */
28691       if (regno <= BX_REG || TARGET_64BIT)
28692         return true;
28693       if (!TARGET_PARTIAL_REG_STALL)
28694         return true;
28695       return !can_create_pseudo_p ();
28696     }
28697   /* We handle both integer and floats in the general purpose registers.  */
28698   else if (VALID_INT_MODE_P (mode))
28699     return true;
28700   else if (VALID_FP_MODE_P (mode))
28701     return true;
28702   else if (VALID_DFP_MODE_P (mode))
28703     return true;
28704   /* Lots of MMX code casts 8 byte vector modes to DImode.  If we then go
28705      on to use that value in smaller contexts, this can easily force a
28706      pseudo to be allocated to GENERAL_REGS.  Since this is no worse than
28707      supporting DImode, allow it.  */
28708   else if (VALID_MMX_REG_MODE_3DNOW (mode) || VALID_MMX_REG_MODE (mode))
28709     return true;
28710
28711   return false;
28712 }
28713
28714 /* A subroutine of ix86_modes_tieable_p.  Return true if MODE is a
28715    tieable integer mode.  */
28716
28717 static bool
28718 ix86_tieable_integer_mode_p (enum machine_mode mode)
28719 {
28720   switch (mode)
28721     {
28722     case HImode:
28723     case SImode:
28724       return true;
28725
28726     case QImode:
28727       return TARGET_64BIT || !TARGET_PARTIAL_REG_STALL;
28728
28729     case DImode:
28730       return TARGET_64BIT;
28731
28732     default:
28733       return false;
28734     }
28735 }
28736
28737 /* Return true if MODE1 is accessible in a register that can hold MODE2
28738    without copying.  That is, all register classes that can hold MODE2
28739    can also hold MODE1.  */
28740
28741 bool
28742 ix86_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
28743 {
28744   if (mode1 == mode2)
28745     return true;
28746
28747   if (ix86_tieable_integer_mode_p (mode1)
28748       && ix86_tieable_integer_mode_p (mode2))
28749     return true;
28750
28751   /* MODE2 being XFmode implies fp stack or general regs, which means we
28752      can tie any smaller floating point modes to it.  Note that we do not
28753      tie this with TFmode.  */
28754   if (mode2 == XFmode)
28755     return mode1 == SFmode || mode1 == DFmode;
28756
28757   /* MODE2 being DFmode implies fp stack, general or sse regs, which means
28758      that we can tie it with SFmode.  */
28759   if (mode2 == DFmode)
28760     return mode1 == SFmode;
28761
28762   /* If MODE2 is only appropriate for an SSE register, then tie with
28763      any other mode acceptable to SSE registers.  */
28764   if (GET_MODE_SIZE (mode2) == 16
28765       && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode2))
28766     return (GET_MODE_SIZE (mode1) == 16
28767             && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode1));
28768
28769   /* If MODE2 is appropriate for an MMX register, then tie
28770      with any other mode acceptable to MMX registers.  */
28771   if (GET_MODE_SIZE (mode2) == 8
28772       && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode2))
28773     return (GET_MODE_SIZE (mode1) == 8
28774             && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode1));
28775
28776   return false;
28777 }
28778
28779 /* Compute a (partial) cost for rtx X.  Return true if the complete
28780    cost has been computed, and false if subexpressions should be
28781    scanned.  In either case, *TOTAL contains the cost result.  */
28782
28783 static bool
28784 ix86_rtx_costs (rtx x, int code, int outer_code_i, int *total, bool speed)
28785 {
28786   enum rtx_code outer_code = (enum rtx_code) outer_code_i;
28787   enum machine_mode mode = GET_MODE (x);
28788   const struct processor_costs *cost = speed ? ix86_cost : &ix86_size_cost;
28789
28790   switch (code)
28791     {
28792     case CONST_INT:
28793     case CONST:
28794     case LABEL_REF:
28795     case SYMBOL_REF:
28796       if (TARGET_64BIT && !x86_64_immediate_operand (x, VOIDmode))
28797         *total = 3;
28798       else if (TARGET_64BIT && !x86_64_zext_immediate_operand (x, VOIDmode))
28799         *total = 2;
28800       else if (flag_pic && SYMBOLIC_CONST (x)
28801                && (!TARGET_64BIT
28802                    || (!GET_CODE (x) != LABEL_REF
28803                        && (GET_CODE (x) != SYMBOL_REF
28804                            || !SYMBOL_REF_LOCAL_P (x)))))
28805         *total = 1;
28806       else
28807         *total = 0;
28808       return true;
28809
28810     case CONST_DOUBLE:
28811       if (mode == VOIDmode)
28812         *total = 0;
28813       else
28814         switch (standard_80387_constant_p (x))
28815           {
28816           case 1: /* 0.0 */
28817             *total = 1;
28818             break;
28819           default: /* Other constants */
28820             *total = 2;
28821             break;
28822           case 0:
28823           case -1:
28824             /* Start with (MEM (SYMBOL_REF)), since that's where
28825                it'll probably end up.  Add a penalty for size.  */
28826             *total = (COSTS_N_INSNS (1)
28827                       + (flag_pic != 0 && !TARGET_64BIT)
28828                       + (mode == SFmode ? 0 : mode == DFmode ? 1 : 2));
28829             break;
28830           }
28831       return true;
28832
28833     case ZERO_EXTEND:
28834       /* The zero extensions is often completely free on x86_64, so make
28835          it as cheap as possible.  */
28836       if (TARGET_64BIT && mode == DImode
28837           && GET_MODE (XEXP (x, 0)) == SImode)
28838         *total = 1;
28839       else if (TARGET_ZERO_EXTEND_WITH_AND)
28840         *total = cost->add;
28841       else
28842         *total = cost->movzx;
28843       return false;
28844
28845     case SIGN_EXTEND:
28846       *total = cost->movsx;
28847       return false;
28848
28849     case ASHIFT:
28850       if (CONST_INT_P (XEXP (x, 1))
28851           && (GET_MODE (XEXP (x, 0)) != DImode || TARGET_64BIT))
28852         {
28853           HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
28854           if (value == 1)
28855             {
28856               *total = cost->add;
28857               return false;
28858             }
28859           if ((value == 2 || value == 3)
28860               && cost->lea <= cost->shift_const)
28861             {
28862               *total = cost->lea;
28863               return false;
28864             }
28865         }
28866       /* FALLTHRU */
28867
28868     case ROTATE:
28869     case ASHIFTRT:
28870     case LSHIFTRT:
28871     case ROTATERT:
28872       if (!TARGET_64BIT && GET_MODE (XEXP (x, 0)) == DImode)
28873         {
28874           if (CONST_INT_P (XEXP (x, 1)))
28875             {
28876               if (INTVAL (XEXP (x, 1)) > 32)
28877                 *total = cost->shift_const + COSTS_N_INSNS (2);
28878               else
28879                 *total = cost->shift_const * 2;
28880             }
28881           else
28882             {
28883               if (GET_CODE (XEXP (x, 1)) == AND)
28884                 *total = cost->shift_var * 2;
28885               else
28886                 *total = cost->shift_var * 6 + COSTS_N_INSNS (2);
28887             }
28888         }
28889       else
28890         {
28891           if (CONST_INT_P (XEXP (x, 1)))
28892             *total = cost->shift_const;
28893           else
28894             *total = cost->shift_var;
28895         }
28896       return false;
28897
28898     case FMA:
28899       {
28900         rtx sub;
28901
28902         gcc_assert (FLOAT_MODE_P (mode));
28903         gcc_assert (TARGET_FMA || TARGET_FMA4);
28904
28905         /* ??? SSE scalar/vector cost should be used here.  */
28906         /* ??? Bald assumption that fma has the same cost as fmul.  */
28907         *total = cost->fmul;
28908         *total += rtx_cost (XEXP (x, 1), FMA, speed);
28909
28910         /* Negate in op0 or op2 is free: FMS, FNMA, FNMS.  */
28911         sub = XEXP (x, 0);
28912         if (GET_CODE (sub) == NEG)
28913           sub = XEXP (sub, 0);
28914         *total += rtx_cost (sub, FMA, speed);
28915
28916         sub = XEXP (x, 2);
28917         if (GET_CODE (sub) == NEG)
28918           sub = XEXP (sub, 0);
28919         *total += rtx_cost (sub, FMA, speed);
28920         return true;
28921       }
28922
28923     case MULT:
28924       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28925         {
28926           /* ??? SSE scalar cost should be used here.  */
28927           *total = cost->fmul;
28928           return false;
28929         }
28930       else if (X87_FLOAT_MODE_P (mode))
28931         {
28932           *total = cost->fmul;
28933           return false;
28934         }
28935       else if (FLOAT_MODE_P (mode))
28936         {
28937           /* ??? SSE vector cost should be used here.  */
28938           *total = cost->fmul;
28939           return false;
28940         }
28941       else
28942         {
28943           rtx op0 = XEXP (x, 0);
28944           rtx op1 = XEXP (x, 1);
28945           int nbits;
28946           if (CONST_INT_P (XEXP (x, 1)))
28947             {
28948               unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
28949               for (nbits = 0; value != 0; value &= value - 1)
28950                 nbits++;
28951             }
28952           else
28953             /* This is arbitrary.  */
28954             nbits = 7;
28955
28956           /* Compute costs correctly for widening multiplication.  */
28957           if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
28958               && GET_MODE_SIZE (GET_MODE (XEXP (op0, 0))) * 2
28959                  == GET_MODE_SIZE (mode))
28960             {
28961               int is_mulwiden = 0;
28962               enum machine_mode inner_mode = GET_MODE (op0);
28963
28964               if (GET_CODE (op0) == GET_CODE (op1))
28965                 is_mulwiden = 1, op1 = XEXP (op1, 0);
28966               else if (CONST_INT_P (op1))
28967                 {
28968                   if (GET_CODE (op0) == SIGN_EXTEND)
28969                     is_mulwiden = trunc_int_for_mode (INTVAL (op1), inner_mode)
28970                                   == INTVAL (op1);
28971                   else
28972                     is_mulwiden = !(INTVAL (op1) & ~GET_MODE_MASK (inner_mode));
28973                 }
28974
28975               if (is_mulwiden)
28976                 op0 = XEXP (op0, 0), mode = GET_MODE (op0);
28977             }
28978
28979           *total = (cost->mult_init[MODE_INDEX (mode)]
28980                     + nbits * cost->mult_bit
28981                     + rtx_cost (op0, outer_code, speed) + rtx_cost (op1, outer_code, speed));
28982
28983           return true;
28984         }
28985
28986     case DIV:
28987     case UDIV:
28988     case MOD:
28989     case UMOD:
28990       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
28991         /* ??? SSE cost should be used here.  */
28992         *total = cost->fdiv;
28993       else if (X87_FLOAT_MODE_P (mode))
28994         *total = cost->fdiv;
28995       else if (FLOAT_MODE_P (mode))
28996         /* ??? SSE vector cost should be used here.  */
28997         *total = cost->fdiv;
28998       else
28999         *total = cost->divide[MODE_INDEX (mode)];
29000       return false;
29001
29002     case PLUS:
29003       if (GET_MODE_CLASS (mode) == MODE_INT
29004                && GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (Pmode))
29005         {
29006           if (GET_CODE (XEXP (x, 0)) == PLUS
29007               && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
29008               && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
29009               && CONSTANT_P (XEXP (x, 1)))
29010             {
29011               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1));
29012               if (val == 2 || val == 4 || val == 8)
29013                 {
29014                   *total = cost->lea;
29015                   *total += rtx_cost (XEXP (XEXP (x, 0), 1), outer_code, speed);
29016                   *total += rtx_cost (XEXP (XEXP (XEXP (x, 0), 0), 0),
29017                                       outer_code, speed);
29018                   *total += rtx_cost (XEXP (x, 1), outer_code, speed);
29019                   return true;
29020                 }
29021             }
29022           else if (GET_CODE (XEXP (x, 0)) == MULT
29023                    && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
29024             {
29025               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (x, 0), 1));
29026               if (val == 2 || val == 4 || val == 8)
29027                 {
29028                   *total = cost->lea;
29029                   *total += rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed);
29030                   *total += rtx_cost (XEXP (x, 1), outer_code, speed);
29031                   return true;
29032                 }
29033             }
29034           else if (GET_CODE (XEXP (x, 0)) == PLUS)
29035             {
29036               *total = cost->lea;
29037               *total += rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed);
29038               *total += rtx_cost (XEXP (XEXP (x, 0), 1), outer_code, speed);
29039               *total += rtx_cost (XEXP (x, 1), outer_code, speed);
29040               return true;
29041             }
29042         }
29043       /* FALLTHRU */
29044
29045     case MINUS:
29046       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
29047         {
29048           /* ??? SSE cost should be used here.  */
29049           *total = cost->fadd;
29050           return false;
29051         }
29052       else if (X87_FLOAT_MODE_P (mode))
29053         {
29054           *total = cost->fadd;
29055           return false;
29056         }
29057       else if (FLOAT_MODE_P (mode))
29058         {
29059           /* ??? SSE vector cost should be used here.  */
29060           *total = cost->fadd;
29061           return false;
29062         }
29063       /* FALLTHRU */
29064
29065     case AND:
29066     case IOR:
29067     case XOR:
29068       if (!TARGET_64BIT && mode == DImode)
29069         {
29070           *total = (cost->add * 2
29071                     + (rtx_cost (XEXP (x, 0), outer_code, speed)
29072                        << (GET_MODE (XEXP (x, 0)) != DImode))
29073                     + (rtx_cost (XEXP (x, 1), outer_code, speed)
29074                        << (GET_MODE (XEXP (x, 1)) != DImode)));
29075           return true;
29076         }
29077       /* FALLTHRU */
29078
29079     case NEG:
29080       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
29081         {
29082           /* ??? SSE cost should be used here.  */
29083           *total = cost->fchs;
29084           return false;
29085         }
29086       else if (X87_FLOAT_MODE_P (mode))
29087         {
29088           *total = cost->fchs;
29089           return false;
29090         }
29091       else if (FLOAT_MODE_P (mode))
29092         {
29093           /* ??? SSE vector cost should be used here.  */
29094           *total = cost->fchs;
29095           return false;
29096         }
29097       /* FALLTHRU */
29098
29099     case NOT:
29100       if (!TARGET_64BIT && mode == DImode)
29101         *total = cost->add * 2;
29102       else
29103         *total = cost->add;
29104       return false;
29105
29106     case COMPARE:
29107       if (GET_CODE (XEXP (x, 0)) == ZERO_EXTRACT
29108           && XEXP (XEXP (x, 0), 1) == const1_rtx
29109           && CONST_INT_P (XEXP (XEXP (x, 0), 2))
29110           && XEXP (x, 1) == const0_rtx)
29111         {
29112           /* This kind of construct is implemented using test[bwl].
29113              Treat it as if we had an AND.  */
29114           *total = (cost->add
29115                     + rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, speed)
29116                     + rtx_cost (const1_rtx, outer_code, speed));
29117           return true;
29118         }
29119       return false;
29120
29121     case FLOAT_EXTEND:
29122       if (!(SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH))
29123         *total = 0;
29124       return false;
29125
29126     case ABS:
29127       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
29128         /* ??? SSE cost should be used here.  */
29129         *total = cost->fabs;
29130       else if (X87_FLOAT_MODE_P (mode))
29131         *total = cost->fabs;
29132       else if (FLOAT_MODE_P (mode))
29133         /* ??? SSE vector cost should be used here.  */
29134         *total = cost->fabs;
29135       return false;
29136
29137     case SQRT:
29138       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
29139         /* ??? SSE cost should be used here.  */
29140         *total = cost->fsqrt;
29141       else if (X87_FLOAT_MODE_P (mode))
29142         *total = cost->fsqrt;
29143       else if (FLOAT_MODE_P (mode))
29144         /* ??? SSE vector cost should be used here.  */
29145         *total = cost->fsqrt;
29146       return false;
29147
29148     case UNSPEC:
29149       if (XINT (x, 1) == UNSPEC_TP)
29150         *total = 0;
29151       return false;
29152
29153     case VEC_SELECT:
29154     case VEC_CONCAT:
29155     case VEC_MERGE:
29156     case VEC_DUPLICATE:
29157       /* ??? Assume all of these vector manipulation patterns are
29158          recognizable.  In which case they all pretty much have the
29159          same cost.  */
29160      *total = COSTS_N_INSNS (1);
29161      return true;
29162
29163     default:
29164       return false;
29165     }
29166 }
29167
29168 #if TARGET_MACHO
29169
29170 static int current_machopic_label_num;
29171
29172 /* Given a symbol name and its associated stub, write out the
29173    definition of the stub.  */
29174
29175 void
29176 machopic_output_stub (FILE *file, const char *symb, const char *stub)
29177 {
29178   unsigned int length;
29179   char *binder_name, *symbol_name, lazy_ptr_name[32];
29180   int label = ++current_machopic_label_num;
29181
29182   /* For 64-bit we shouldn't get here.  */
29183   gcc_assert (!TARGET_64BIT);
29184
29185   /* Lose our funky encoding stuff so it doesn't contaminate the stub.  */
29186   symb = targetm.strip_name_encoding (symb);
29187
29188   length = strlen (stub);
29189   binder_name = XALLOCAVEC (char, length + 32);
29190   GEN_BINDER_NAME_FOR_STUB (binder_name, stub, length);
29191
29192   length = strlen (symb);
29193   symbol_name = XALLOCAVEC (char, length + 32);
29194   GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
29195
29196   sprintf (lazy_ptr_name, "L%d$lz", label);
29197
29198   if (MACHOPIC_ATT_STUB)
29199     switch_to_section (darwin_sections[machopic_picsymbol_stub3_section]);
29200   else if (MACHOPIC_PURE)
29201     switch_to_section (darwin_sections[machopic_picsymbol_stub2_section]);
29202   else
29203     switch_to_section (darwin_sections[machopic_symbol_stub_section]);
29204
29205   fprintf (file, "%s:\n", stub);
29206   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
29207
29208   if (MACHOPIC_ATT_STUB)
29209     {
29210       fprintf (file, "\thlt ; hlt ; hlt ; hlt ; hlt\n");
29211     }
29212   else if (MACHOPIC_PURE)
29213     {
29214       /* PIC stub.  */
29215       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
29216       rtx tmp = gen_rtx_REG (SImode, 2 /* ECX */);
29217       output_set_got (tmp, NULL_RTX);   /* "CALL ___<cpu>.get_pc_thunk.cx".  */
29218       fprintf (file, "LPC$%d:\tmovl\t%s-LPC$%d(%%ecx),%%ecx\n",
29219                label, lazy_ptr_name, label);
29220       fprintf (file, "\tjmp\t*%%ecx\n");
29221     }
29222   else
29223     fprintf (file, "\tjmp\t*%s\n", lazy_ptr_name);
29224
29225   /* The AT&T-style ("self-modifying") stub is not lazily bound, thus
29226      it needs no stub-binding-helper.  */
29227   if (MACHOPIC_ATT_STUB)
29228     return;
29229
29230   fprintf (file, "%s:\n", binder_name);
29231
29232   if (MACHOPIC_PURE)
29233     {
29234       fprintf (file, "\tlea\t%s-%s(%%ecx),%%ecx\n", lazy_ptr_name, binder_name);
29235       fprintf (file, "\tpushl\t%%ecx\n");
29236     }
29237   else
29238     fprintf (file, "\tpushl\t$%s\n", lazy_ptr_name);
29239
29240   fputs ("\tjmp\tdyld_stub_binding_helper\n", file);
29241
29242   /* N.B. Keep the correspondence of these
29243      'symbol_ptr/symbol_ptr2/symbol_ptr3' sections consistent with the
29244      old-pic/new-pic/non-pic stubs; altering this will break
29245      compatibility with existing dylibs.  */
29246   if (MACHOPIC_PURE)
29247     {
29248       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
29249       switch_to_section (darwin_sections[machopic_lazy_symbol_ptr2_section]);
29250     }
29251   else
29252     /* 16-byte -mdynamic-no-pic stub.  */
29253     switch_to_section(darwin_sections[machopic_lazy_symbol_ptr3_section]);
29254
29255   fprintf (file, "%s:\n", lazy_ptr_name);
29256   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
29257   fprintf (file, ASM_LONG "%s\n", binder_name);
29258 }
29259 #endif /* TARGET_MACHO */
29260
29261 /* Order the registers for register allocator.  */
29262
29263 void
29264 x86_order_regs_for_local_alloc (void)
29265 {
29266    int pos = 0;
29267    int i;
29268
29269    /* First allocate the local general purpose registers.  */
29270    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
29271      if (GENERAL_REGNO_P (i) && call_used_regs[i])
29272         reg_alloc_order [pos++] = i;
29273
29274    /* Global general purpose registers.  */
29275    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
29276      if (GENERAL_REGNO_P (i) && !call_used_regs[i])
29277         reg_alloc_order [pos++] = i;
29278
29279    /* x87 registers come first in case we are doing FP math
29280       using them.  */
29281    if (!TARGET_SSE_MATH)
29282      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
29283        reg_alloc_order [pos++] = i;
29284
29285    /* SSE registers.  */
29286    for (i = FIRST_SSE_REG; i <= LAST_SSE_REG; i++)
29287      reg_alloc_order [pos++] = i;
29288    for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
29289      reg_alloc_order [pos++] = i;
29290
29291    /* x87 registers.  */
29292    if (TARGET_SSE_MATH)
29293      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
29294        reg_alloc_order [pos++] = i;
29295
29296    for (i = FIRST_MMX_REG; i <= LAST_MMX_REG; i++)
29297      reg_alloc_order [pos++] = i;
29298
29299    /* Initialize the rest of array as we do not allocate some registers
29300       at all.  */
29301    while (pos < FIRST_PSEUDO_REGISTER)
29302      reg_alloc_order [pos++] = 0;
29303 }
29304
29305 /* Handle a "callee_pop_aggregate_return" attribute; arguments as
29306    in struct attribute_spec handler.  */
29307 static tree
29308 ix86_handle_callee_pop_aggregate_return (tree *node, tree name,
29309                                               tree args,
29310                                               int flags ATTRIBUTE_UNUSED,
29311                                               bool *no_add_attrs)
29312 {
29313   if (TREE_CODE (*node) != FUNCTION_TYPE
29314       && TREE_CODE (*node) != METHOD_TYPE
29315       && TREE_CODE (*node) != FIELD_DECL
29316       && TREE_CODE (*node) != TYPE_DECL)
29317     {
29318       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29319                name);
29320       *no_add_attrs = true;
29321       return NULL_TREE;
29322     }
29323   if (TARGET_64BIT)
29324     {
29325       warning (OPT_Wattributes, "%qE attribute only available for 32-bit",
29326                name);
29327       *no_add_attrs = true;
29328       return NULL_TREE;
29329     }
29330   if (is_attribute_p ("callee_pop_aggregate_return", name))
29331     {
29332       tree cst;
29333
29334       cst = TREE_VALUE (args);
29335       if (TREE_CODE (cst) != INTEGER_CST)
29336         {
29337           warning (OPT_Wattributes,
29338                    "%qE attribute requires an integer constant argument",
29339                    name);
29340           *no_add_attrs = true;
29341         }
29342       else if (compare_tree_int (cst, 0) != 0
29343                && compare_tree_int (cst, 1) != 0)
29344         {
29345           warning (OPT_Wattributes,
29346                    "argument to %qE attribute is neither zero, nor one",
29347                    name);
29348           *no_add_attrs = true;
29349         }
29350
29351       return NULL_TREE;
29352     }
29353
29354   return NULL_TREE;
29355 }
29356
29357 /* Handle a "ms_abi" or "sysv" attribute; arguments as in
29358    struct attribute_spec.handler.  */
29359 static tree
29360 ix86_handle_abi_attribute (tree *node, tree name,
29361                               tree args ATTRIBUTE_UNUSED,
29362                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29363 {
29364   if (TREE_CODE (*node) != FUNCTION_TYPE
29365       && TREE_CODE (*node) != METHOD_TYPE
29366       && TREE_CODE (*node) != FIELD_DECL
29367       && TREE_CODE (*node) != TYPE_DECL)
29368     {
29369       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29370                name);
29371       *no_add_attrs = true;
29372       return NULL_TREE;
29373     }
29374
29375   /* Can combine regparm with all attributes but fastcall.  */
29376   if (is_attribute_p ("ms_abi", name))
29377     {
29378       if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
29379         {
29380           error ("ms_abi and sysv_abi attributes are not compatible");
29381         }
29382
29383       return NULL_TREE;
29384     }
29385   else if (is_attribute_p ("sysv_abi", name))
29386     {
29387       if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
29388         {
29389           error ("ms_abi and sysv_abi attributes are not compatible");
29390         }
29391
29392       return NULL_TREE;
29393     }
29394
29395   return NULL_TREE;
29396 }
29397
29398 /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
29399    struct attribute_spec.handler.  */
29400 static tree
29401 ix86_handle_struct_attribute (tree *node, tree name,
29402                               tree args ATTRIBUTE_UNUSED,
29403                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29404 {
29405   tree *type = NULL;
29406   if (DECL_P (*node))
29407     {
29408       if (TREE_CODE (*node) == TYPE_DECL)
29409         type = &TREE_TYPE (*node);
29410     }
29411   else
29412     type = node;
29413
29414   if (!(type && (TREE_CODE (*type) == RECORD_TYPE
29415                  || TREE_CODE (*type) == UNION_TYPE)))
29416     {
29417       warning (OPT_Wattributes, "%qE attribute ignored",
29418                name);
29419       *no_add_attrs = true;
29420     }
29421
29422   else if ((is_attribute_p ("ms_struct", name)
29423             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
29424            || ((is_attribute_p ("gcc_struct", name)
29425                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
29426     {
29427       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
29428                name);
29429       *no_add_attrs = true;
29430     }
29431
29432   return NULL_TREE;
29433 }
29434
29435 static tree
29436 ix86_handle_fndecl_attribute (tree *node, tree name,
29437                               tree args ATTRIBUTE_UNUSED,
29438                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
29439 {
29440   if (TREE_CODE (*node) != FUNCTION_DECL)
29441     {
29442       warning (OPT_Wattributes, "%qE attribute only applies to functions",
29443                name);
29444       *no_add_attrs = true;
29445     }
29446   return NULL_TREE;
29447 }
29448
29449 static bool
29450 ix86_ms_bitfield_layout_p (const_tree record_type)
29451 {
29452   return ((TARGET_MS_BITFIELD_LAYOUT
29453            && !lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (record_type)))
29454           || lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (record_type)));
29455 }
29456
29457 /* Returns an expression indicating where the this parameter is
29458    located on entry to the FUNCTION.  */
29459
29460 static rtx
29461 x86_this_parameter (tree function)
29462 {
29463   tree type = TREE_TYPE (function);
29464   bool aggr = aggregate_value_p (TREE_TYPE (type), type) != 0;
29465   int nregs;
29466
29467   if (TARGET_64BIT)
29468     {
29469       const int *parm_regs;
29470
29471       if (ix86_function_type_abi (type) == MS_ABI)
29472         parm_regs = x86_64_ms_abi_int_parameter_registers;
29473       else
29474         parm_regs = x86_64_int_parameter_registers;
29475       return gen_rtx_REG (DImode, parm_regs[aggr]);
29476     }
29477
29478   nregs = ix86_function_regparm (type, function);
29479
29480   if (nregs > 0 && !stdarg_p (type))
29481     {
29482       int regno;
29483       unsigned int ccvt = ix86_get_callcvt (type);
29484
29485       if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
29486         regno = aggr ? DX_REG : CX_REG;
29487       else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
29488         {
29489           regno = CX_REG;
29490           if (aggr)
29491             return gen_rtx_MEM (SImode,
29492                                 plus_constant (stack_pointer_rtx, 4));
29493         }
29494       else
29495         {
29496           regno = AX_REG;
29497           if (aggr)
29498             {
29499               regno = DX_REG;
29500               if (nregs == 1)
29501                 return gen_rtx_MEM (SImode,
29502                                     plus_constant (stack_pointer_rtx, 4));
29503             }
29504         }
29505       return gen_rtx_REG (SImode, regno);
29506     }
29507
29508   return gen_rtx_MEM (SImode, plus_constant (stack_pointer_rtx, aggr ? 8 : 4));
29509 }
29510
29511 /* Determine whether x86_output_mi_thunk can succeed.  */
29512
29513 static bool
29514 x86_can_output_mi_thunk (const_tree thunk ATTRIBUTE_UNUSED,
29515                          HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
29516                          HOST_WIDE_INT vcall_offset, const_tree function)
29517 {
29518   /* 64-bit can handle anything.  */
29519   if (TARGET_64BIT)
29520     return true;
29521
29522   /* For 32-bit, everything's fine if we have one free register.  */
29523   if (ix86_function_regparm (TREE_TYPE (function), function) < 3)
29524     return true;
29525
29526   /* Need a free register for vcall_offset.  */
29527   if (vcall_offset)
29528     return false;
29529
29530   /* Need a free register for GOT references.  */
29531   if (flag_pic && !targetm.binds_local_p (function))
29532     return false;
29533
29534   /* Otherwise ok.  */
29535   return true;
29536 }
29537
29538 /* Output the assembler code for a thunk function.  THUNK_DECL is the
29539    declaration for the thunk function itself, FUNCTION is the decl for
29540    the target function.  DELTA is an immediate constant offset to be
29541    added to THIS.  If VCALL_OFFSET is nonzero, the word at
29542    *(*this + vcall_offset) should be added to THIS.  */
29543
29544 static void
29545 x86_output_mi_thunk (FILE *file,
29546                      tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
29547                      HOST_WIDE_INT vcall_offset, tree function)
29548 {
29549   rtx this_param = x86_this_parameter (function);
29550   rtx this_reg, tmp, fnaddr;
29551
29552   emit_note (NOTE_INSN_PROLOGUE_END);
29553
29554   /* If VCALL_OFFSET, we'll need THIS in a register.  Might as well
29555      pull it in now and let DELTA benefit.  */
29556   if (REG_P (this_param))
29557     this_reg = this_param;
29558   else if (vcall_offset)
29559     {
29560       /* Put the this parameter into %eax.  */
29561       this_reg = gen_rtx_REG (Pmode, AX_REG);
29562       emit_move_insn (this_reg, this_param);
29563     }
29564   else
29565     this_reg = NULL_RTX;
29566
29567   /* Adjust the this parameter by a fixed constant.  */
29568   if (delta)
29569     {
29570       rtx delta_rtx = GEN_INT (delta);
29571       rtx delta_dst = this_reg ? this_reg : this_param;
29572
29573       if (TARGET_64BIT)
29574         {
29575           if (!x86_64_general_operand (delta_rtx, Pmode))
29576             {
29577               tmp = gen_rtx_REG (Pmode, R10_REG);
29578               emit_move_insn (tmp, delta_rtx);
29579               delta_rtx = tmp;
29580             }
29581         }
29582
29583       emit_insn (ix86_gen_add3 (delta_dst, delta_dst, delta_rtx));
29584     }
29585
29586   /* Adjust the this parameter by a value stored in the vtable.  */
29587   if (vcall_offset)
29588     {
29589       rtx vcall_addr, vcall_mem, this_mem;
29590       unsigned int tmp_regno;
29591
29592       if (TARGET_64BIT)
29593         tmp_regno = R10_REG;
29594       else
29595         {
29596           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (function));
29597           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
29598             tmp_regno = AX_REG;
29599           else
29600             tmp_regno = CX_REG;
29601         }
29602       tmp = gen_rtx_REG (Pmode, tmp_regno);
29603
29604       this_mem = gen_rtx_MEM (ptr_mode, this_reg);
29605       if (Pmode != ptr_mode)
29606         this_mem = gen_rtx_ZERO_EXTEND (Pmode, this_mem);
29607       emit_move_insn (tmp, this_mem);
29608
29609       /* Adjust the this parameter.  */
29610       vcall_addr = plus_constant (tmp, vcall_offset);
29611       if (TARGET_64BIT
29612           && !ix86_legitimate_address_p (ptr_mode, vcall_addr, true))
29613         {
29614           rtx tmp2 = gen_rtx_REG (Pmode, R11_REG);
29615           emit_move_insn (tmp2, GEN_INT (vcall_offset));
29616           vcall_addr = gen_rtx_PLUS (Pmode, tmp, tmp2);
29617         }
29618
29619       vcall_mem = gen_rtx_MEM (ptr_mode, vcall_addr);
29620       if (Pmode != ptr_mode)
29621         emit_insn (gen_addsi_1_zext (this_reg,
29622                                      gen_rtx_REG (ptr_mode,
29623                                                   REGNO (this_reg)),
29624                                      vcall_mem));
29625       else
29626         emit_insn (ix86_gen_add3 (this_reg, this_reg, vcall_mem));
29627     }
29628
29629   /* If necessary, drop THIS back to its stack slot.  */
29630   if (this_reg && this_reg != this_param)
29631     emit_move_insn (this_param, this_reg);
29632
29633   fnaddr = XEXP (DECL_RTL (function), 0);
29634   if (TARGET_64BIT)
29635     {
29636       if (!flag_pic || targetm.binds_local_p (function)
29637           || cfun->machine->call_abi == MS_ABI)
29638         ;
29639       else
29640         {
29641           tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOTPCREL);
29642           tmp = gen_rtx_CONST (Pmode, tmp);
29643           fnaddr = gen_rtx_MEM (Pmode, tmp);
29644         }
29645     }
29646   else
29647     {
29648       if (!flag_pic || targetm.binds_local_p (function))
29649         ;
29650 #if TARGET_MACHO
29651       else if (TARGET_MACHO)
29652         {
29653           fnaddr = machopic_indirect_call_target (DECL_RTL (function));
29654           fnaddr = XEXP (fnaddr, 0);
29655         }
29656 #endif /* TARGET_MACHO */
29657       else
29658         {
29659           tmp = gen_rtx_REG (Pmode, CX_REG);
29660           output_set_got (tmp, NULL_RTX);
29661
29662           fnaddr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOT);
29663           fnaddr = gen_rtx_PLUS (Pmode, fnaddr, tmp);
29664           fnaddr = gen_rtx_MEM (Pmode, fnaddr);
29665         }
29666     }
29667
29668   /* Our sibling call patterns do not allow memories, because we have no
29669      predicate that can distinguish between frame and non-frame memory.
29670      For our purposes here, we can get away with (ab)using a jump pattern,
29671      because we're going to do no optimization.  */
29672   if (MEM_P (fnaddr))
29673     emit_jump_insn (gen_indirect_jump (fnaddr));
29674   else
29675     {
29676       tmp = gen_rtx_MEM (QImode, fnaddr);
29677       tmp = gen_rtx_CALL (VOIDmode, tmp, const0_rtx);
29678       tmp = emit_call_insn (tmp);
29679       SIBLING_CALL_P (tmp) = 1;
29680     }
29681   emit_barrier ();
29682
29683   /* Emit just enough of rest_of_compilation to get the insns emitted.
29684      Note that use_thunk calls assemble_start_function et al.  */
29685   tmp = get_insns ();
29686   insn_locators_alloc ();
29687   shorten_branches (tmp);
29688   final_start_function (tmp, file, 1);
29689   final (tmp, file, 1);
29690   final_end_function ();
29691 }
29692
29693 static void
29694 x86_file_start (void)
29695 {
29696   default_file_start ();
29697 #if TARGET_MACHO
29698   darwin_file_start ();
29699 #endif
29700   if (X86_FILE_START_VERSION_DIRECTIVE)
29701     fputs ("\t.version\t\"01.01\"\n", asm_out_file);
29702   if (X86_FILE_START_FLTUSED)
29703     fputs ("\t.global\t__fltused\n", asm_out_file);
29704   if (ix86_asm_dialect == ASM_INTEL)
29705     fputs ("\t.intel_syntax noprefix\n", asm_out_file);
29706 }
29707
29708 int
29709 x86_field_alignment (tree field, int computed)
29710 {
29711   enum machine_mode mode;
29712   tree type = TREE_TYPE (field);
29713
29714   if (TARGET_64BIT || TARGET_ALIGN_DOUBLE)
29715     return computed;
29716   mode = TYPE_MODE (strip_array_types (type));
29717   if (mode == DFmode || mode == DCmode
29718       || GET_MODE_CLASS (mode) == MODE_INT
29719       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
29720     return MIN (32, computed);
29721   return computed;
29722 }
29723
29724 /* Output assembler code to FILE to increment profiler label # LABELNO
29725    for profiling a function entry.  */
29726 void
29727 x86_function_profiler (FILE *file, int labelno ATTRIBUTE_UNUSED)
29728 {
29729   const char *mcount_name = (flag_fentry ? MCOUNT_NAME_BEFORE_PROLOGUE
29730                                          : MCOUNT_NAME);
29731
29732   if (TARGET_64BIT)
29733     {
29734 #ifndef NO_PROFILE_COUNTERS
29735       fprintf (file, "\tleaq\t%sP%d(%%rip),%%r11\n", LPREFIX, labelno);
29736 #endif
29737
29738       if (DEFAULT_ABI == SYSV_ABI && flag_pic)
29739         fprintf (file, "\tcall\t*%s@GOTPCREL(%%rip)\n", mcount_name);
29740       else
29741         fprintf (file, "\tcall\t%s\n", mcount_name);
29742     }
29743   else if (flag_pic)
29744     {
29745 #ifndef NO_PROFILE_COUNTERS
29746       fprintf (file, "\tleal\t%sP%d@GOTOFF(%%ebx),%%" PROFILE_COUNT_REGISTER "\n",
29747                LPREFIX, labelno);
29748 #endif
29749       fprintf (file, "\tcall\t*%s@GOT(%%ebx)\n", mcount_name);
29750     }
29751   else
29752     {
29753 #ifndef NO_PROFILE_COUNTERS
29754       fprintf (file, "\tmovl\t$%sP%d,%%" PROFILE_COUNT_REGISTER "\n",
29755                LPREFIX, labelno);
29756 #endif
29757       fprintf (file, "\tcall\t%s\n", mcount_name);
29758     }
29759 }
29760
29761 /* We don't have exact information about the insn sizes, but we may assume
29762    quite safely that we are informed about all 1 byte insns and memory
29763    address sizes.  This is enough to eliminate unnecessary padding in
29764    99% of cases.  */
29765
29766 static int
29767 min_insn_size (rtx insn)
29768 {
29769   int l = 0, len;
29770
29771   if (!INSN_P (insn) || !active_insn_p (insn))
29772     return 0;
29773
29774   /* Discard alignments we've emit and jump instructions.  */
29775   if (GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE
29776       && XINT (PATTERN (insn), 1) == UNSPECV_ALIGN)
29777     return 0;
29778   if (JUMP_TABLE_DATA_P (insn))
29779     return 0;
29780
29781   /* Important case - calls are always 5 bytes.
29782      It is common to have many calls in the row.  */
29783   if (CALL_P (insn)
29784       && symbolic_reference_mentioned_p (PATTERN (insn))
29785       && !SIBLING_CALL_P (insn))
29786     return 5;
29787   len = get_attr_length (insn);
29788   if (len <= 1)
29789     return 1;
29790
29791   /* For normal instructions we rely on get_attr_length being exact,
29792      with a few exceptions.  */
29793   if (!JUMP_P (insn))
29794     {
29795       enum attr_type type = get_attr_type (insn);
29796
29797       switch (type)
29798         {
29799         case TYPE_MULTI:
29800           if (GET_CODE (PATTERN (insn)) == ASM_INPUT
29801               || asm_noperands (PATTERN (insn)) >= 0)
29802             return 0;
29803           break;
29804         case TYPE_OTHER:
29805         case TYPE_FCMP:
29806           break;
29807         default:
29808           /* Otherwise trust get_attr_length.  */
29809           return len;
29810         }
29811
29812       l = get_attr_length_address (insn);
29813       if (l < 4 && symbolic_reference_mentioned_p (PATTERN (insn)))
29814         l = 4;
29815     }
29816   if (l)
29817     return 1+l;
29818   else
29819     return 2;
29820 }
29821
29822 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
29823
29824 /* AMD K8 core mispredicts jumps when there are more than 3 jumps in 16 byte
29825    window.  */
29826
29827 static void
29828 ix86_avoid_jump_mispredicts (void)
29829 {
29830   rtx insn, start = get_insns ();
29831   int nbytes = 0, njumps = 0;
29832   int isjump = 0;
29833
29834   /* Look for all minimal intervals of instructions containing 4 jumps.
29835      The intervals are bounded by START and INSN.  NBYTES is the total
29836      size of instructions in the interval including INSN and not including
29837      START.  When the NBYTES is smaller than 16 bytes, it is possible
29838      that the end of START and INSN ends up in the same 16byte page.
29839
29840      The smallest offset in the page INSN can start is the case where START
29841      ends on the offset 0.  Offset of INSN is then NBYTES - sizeof (INSN).
29842      We add p2align to 16byte window with maxskip 15 - NBYTES + sizeof (INSN).
29843      */
29844   for (insn = start; insn; insn = NEXT_INSN (insn))
29845     {
29846       int min_size;
29847
29848       if (LABEL_P (insn))
29849         {
29850           int align = label_to_alignment (insn);
29851           int max_skip = label_to_max_skip (insn);
29852
29853           if (max_skip > 15)
29854             max_skip = 15;
29855           /* If align > 3, only up to 16 - max_skip - 1 bytes can be
29856              already in the current 16 byte page, because otherwise
29857              ASM_OUTPUT_MAX_SKIP_ALIGN could skip max_skip or fewer
29858              bytes to reach 16 byte boundary.  */
29859           if (align <= 0
29860               || (align <= 3 && max_skip != (1 << align) - 1))
29861             max_skip = 0;
29862           if (dump_file)
29863             fprintf (dump_file, "Label %i with max_skip %i\n",
29864                      INSN_UID (insn), max_skip);
29865           if (max_skip)
29866             {
29867               while (nbytes + max_skip >= 16)
29868                 {
29869                   start = NEXT_INSN (start);
29870                   if ((JUMP_P (start)
29871                        && GET_CODE (PATTERN (start)) != ADDR_VEC
29872                        && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
29873                       || CALL_P (start))
29874                     njumps--, isjump = 1;
29875                   else
29876                     isjump = 0;
29877                   nbytes -= min_insn_size (start);
29878                 }
29879             }
29880           continue;
29881         }
29882
29883       min_size = min_insn_size (insn);
29884       nbytes += min_size;
29885       if (dump_file)
29886         fprintf (dump_file, "Insn %i estimated to %i bytes\n",
29887                  INSN_UID (insn), min_size);
29888       if ((JUMP_P (insn)
29889            && GET_CODE (PATTERN (insn)) != ADDR_VEC
29890            && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
29891           || CALL_P (insn))
29892         njumps++;
29893       else
29894         continue;
29895
29896       while (njumps > 3)
29897         {
29898           start = NEXT_INSN (start);
29899           if ((JUMP_P (start)
29900                && GET_CODE (PATTERN (start)) != ADDR_VEC
29901                && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
29902               || CALL_P (start))
29903             njumps--, isjump = 1;
29904           else
29905             isjump = 0;
29906           nbytes -= min_insn_size (start);
29907         }
29908       gcc_assert (njumps >= 0);
29909       if (dump_file)
29910         fprintf (dump_file, "Interval %i to %i has %i bytes\n",
29911                  INSN_UID (start), INSN_UID (insn), nbytes);
29912
29913       if (njumps == 3 && isjump && nbytes < 16)
29914         {
29915           int padsize = 15 - nbytes + min_insn_size (insn);
29916
29917           if (dump_file)
29918             fprintf (dump_file, "Padding insn %i by %i bytes!\n",
29919                      INSN_UID (insn), padsize);
29920           emit_insn_before (gen_pad (GEN_INT (padsize)), insn);
29921         }
29922     }
29923 }
29924 #endif
29925
29926 /* AMD Athlon works faster
29927    when RET is not destination of conditional jump or directly preceded
29928    by other jump instruction.  We avoid the penalty by inserting NOP just
29929    before the RET instructions in such cases.  */
29930 static void
29931 ix86_pad_returns (void)
29932 {
29933   edge e;
29934   edge_iterator ei;
29935
29936   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
29937     {
29938       basic_block bb = e->src;
29939       rtx ret = BB_END (bb);
29940       rtx prev;
29941       bool replace = false;
29942
29943       if (!JUMP_P (ret) || GET_CODE (PATTERN (ret)) != RETURN
29944           || optimize_bb_for_size_p (bb))
29945         continue;
29946       for (prev = PREV_INSN (ret); prev; prev = PREV_INSN (prev))
29947         if (active_insn_p (prev) || LABEL_P (prev))
29948           break;
29949       if (prev && LABEL_P (prev))
29950         {
29951           edge e;
29952           edge_iterator ei;
29953
29954           FOR_EACH_EDGE (e, ei, bb->preds)
29955             if (EDGE_FREQUENCY (e) && e->src->index >= 0
29956                 && !(e->flags & EDGE_FALLTHRU))
29957               replace = true;
29958         }
29959       if (!replace)
29960         {
29961           prev = prev_active_insn (ret);
29962           if (prev
29963               && ((JUMP_P (prev) && any_condjump_p (prev))
29964                   || CALL_P (prev)))
29965             replace = true;
29966           /* Empty functions get branch mispredict even when
29967              the jump destination is not visible to us.  */
29968           if (!prev && !optimize_function_for_size_p (cfun))
29969             replace = true;
29970         }
29971       if (replace)
29972         {
29973           emit_jump_insn_before (gen_return_internal_long (), ret);
29974           delete_insn (ret);
29975         }
29976     }
29977 }
29978
29979 /* Count the minimum number of instructions in BB.  Return 4 if the
29980    number of instructions >= 4.  */
29981
29982 static int
29983 ix86_count_insn_bb (basic_block bb)
29984 {
29985   rtx insn;
29986   int insn_count = 0;
29987
29988   /* Count number of instructions in this block.  Return 4 if the number
29989      of instructions >= 4.  */
29990   FOR_BB_INSNS (bb, insn)
29991     {
29992       /* Only happen in exit blocks.  */
29993       if (JUMP_P (insn)
29994           && GET_CODE (PATTERN (insn)) == RETURN)
29995         break;
29996
29997       if (NONDEBUG_INSN_P (insn)
29998           && GET_CODE (PATTERN (insn)) != USE
29999           && GET_CODE (PATTERN (insn)) != CLOBBER)
30000         {
30001           insn_count++;
30002           if (insn_count >= 4)
30003             return insn_count;
30004         }
30005     }
30006
30007   return insn_count;
30008 }
30009
30010
30011 /* Count the minimum number of instructions in code path in BB.
30012    Return 4 if the number of instructions >= 4.  */
30013
30014 static int
30015 ix86_count_insn (basic_block bb)
30016 {
30017   edge e;
30018   edge_iterator ei;
30019   int min_prev_count;
30020
30021   /* Only bother counting instructions along paths with no
30022      more than 2 basic blocks between entry and exit.  Given
30023      that BB has an edge to exit, determine if a predecessor
30024      of BB has an edge from entry.  If so, compute the number
30025      of instructions in the predecessor block.  If there
30026      happen to be multiple such blocks, compute the minimum.  */
30027   min_prev_count = 4;
30028   FOR_EACH_EDGE (e, ei, bb->preds)
30029     {
30030       edge prev_e;
30031       edge_iterator prev_ei;
30032
30033       if (e->src == ENTRY_BLOCK_PTR)
30034         {
30035           min_prev_count = 0;
30036           break;
30037         }
30038       FOR_EACH_EDGE (prev_e, prev_ei, e->src->preds)
30039         {
30040           if (prev_e->src == ENTRY_BLOCK_PTR)
30041             {
30042               int count = ix86_count_insn_bb (e->src);
30043               if (count < min_prev_count)
30044                 min_prev_count = count;
30045               break;
30046             }
30047         }
30048     }
30049
30050   if (min_prev_count < 4)
30051     min_prev_count += ix86_count_insn_bb (bb);
30052
30053   return min_prev_count;
30054 }
30055
30056 /* Pad short funtion to 4 instructions.   */
30057
30058 static void
30059 ix86_pad_short_function (void)
30060 {
30061   edge e;
30062   edge_iterator ei;
30063
30064   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
30065     {
30066       rtx ret = BB_END (e->src);
30067       if (JUMP_P (ret) && GET_CODE (PATTERN (ret)) == RETURN)
30068         {
30069           int insn_count = ix86_count_insn (e->src);
30070
30071           /* Pad short function.  */
30072           if (insn_count < 4)
30073             {
30074               rtx insn = ret;
30075
30076               /* Find epilogue.  */
30077               while (insn
30078                      && (!NOTE_P (insn)
30079                          || NOTE_KIND (insn) != NOTE_INSN_EPILOGUE_BEG))
30080                 insn = PREV_INSN (insn);
30081
30082               if (!insn)
30083                 insn = ret;
30084
30085               /* Two NOPs count as one instruction.  */
30086               insn_count = 2 * (4 - insn_count);
30087               emit_insn_before (gen_nops (GEN_INT (insn_count)), insn);
30088             }
30089         }
30090     }
30091 }
30092
30093 /* Implement machine specific optimizations.  We implement padding of returns
30094    for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window.  */
30095 static void
30096 ix86_reorg (void)
30097 {
30098   /* We are freeing block_for_insn in the toplev to keep compatibility
30099      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
30100   compute_bb_for_insn ();
30101
30102   /* Run the vzeroupper optimization if needed.  */
30103   if (TARGET_VZEROUPPER)
30104     move_or_delete_vzeroupper ();
30105
30106   if (optimize && optimize_function_for_speed_p (cfun))
30107     {
30108       if (TARGET_PAD_SHORT_FUNCTION)
30109         ix86_pad_short_function ();
30110       else if (TARGET_PAD_RETURNS)
30111         ix86_pad_returns ();
30112 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
30113       if (TARGET_FOUR_JUMP_LIMIT)
30114         ix86_avoid_jump_mispredicts ();
30115 #endif
30116     }
30117 }
30118
30119 /* Return nonzero when QImode register that must be represented via REX prefix
30120    is used.  */
30121 bool
30122 x86_extended_QIreg_mentioned_p (rtx insn)
30123 {
30124   int i;
30125   extract_insn_cached (insn);
30126   for (i = 0; i < recog_data.n_operands; i++)
30127     if (REG_P (recog_data.operand[i])
30128         && REGNO (recog_data.operand[i]) > BX_REG)
30129        return true;
30130   return false;
30131 }
30132
30133 /* Return nonzero when P points to register encoded via REX prefix.
30134    Called via for_each_rtx.  */
30135 static int
30136 extended_reg_mentioned_1 (rtx *p, void *data ATTRIBUTE_UNUSED)
30137 {
30138    unsigned int regno;
30139    if (!REG_P (*p))
30140      return 0;
30141    regno = REGNO (*p);
30142    return REX_INT_REGNO_P (regno) || REX_SSE_REGNO_P (regno);
30143 }
30144
30145 /* Return true when INSN mentions register that must be encoded using REX
30146    prefix.  */
30147 bool
30148 x86_extended_reg_mentioned_p (rtx insn)
30149 {
30150   return for_each_rtx (INSN_P (insn) ? &PATTERN (insn) : &insn,
30151                        extended_reg_mentioned_1, NULL);
30152 }
30153
30154 /* If profitable, negate (without causing overflow) integer constant
30155    of mode MODE at location LOC.  Return true in this case.  */
30156 bool
30157 x86_maybe_negate_const_int (rtx *loc, enum machine_mode mode)
30158 {
30159   HOST_WIDE_INT val;
30160
30161   if (!CONST_INT_P (*loc))
30162     return false;
30163
30164   switch (mode)
30165     {
30166     case DImode:
30167       /* DImode x86_64 constants must fit in 32 bits.  */
30168       gcc_assert (x86_64_immediate_operand (*loc, mode));
30169
30170       mode = SImode;
30171       break;
30172
30173     case SImode:
30174     case HImode:
30175     case QImode:
30176       break;
30177
30178     default:
30179       gcc_unreachable ();
30180     }
30181
30182   /* Avoid overflows.  */
30183   if (mode_signbit_p (mode, *loc))
30184     return false;
30185
30186   val = INTVAL (*loc);
30187
30188   /* Make things pretty and `subl $4,%eax' rather than `addl $-4,%eax'.
30189      Exceptions: -128 encodes smaller than 128, so swap sign and op.  */
30190   if ((val < 0 && val != -128)
30191       || val == 128)
30192     {
30193       *loc = GEN_INT (-val);
30194       return true;
30195     }
30196
30197   return false;
30198 }
30199
30200 /* Generate an unsigned DImode/SImode to FP conversion.  This is the same code
30201    optabs would emit if we didn't have TFmode patterns.  */
30202
30203 void
30204 x86_emit_floatuns (rtx operands[2])
30205 {
30206   rtx neglab, donelab, i0, i1, f0, in, out;
30207   enum machine_mode mode, inmode;
30208
30209   inmode = GET_MODE (operands[1]);
30210   gcc_assert (inmode == SImode || inmode == DImode);
30211
30212   out = operands[0];
30213   in = force_reg (inmode, operands[1]);
30214   mode = GET_MODE (out);
30215   neglab = gen_label_rtx ();
30216   donelab = gen_label_rtx ();
30217   f0 = gen_reg_rtx (mode);
30218
30219   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, inmode, 0, neglab);
30220
30221   expand_float (out, in, 0);
30222
30223   emit_jump_insn (gen_jump (donelab));
30224   emit_barrier ();
30225
30226   emit_label (neglab);
30227
30228   i0 = expand_simple_binop (inmode, LSHIFTRT, in, const1_rtx, NULL,
30229                             1, OPTAB_DIRECT);
30230   i1 = expand_simple_binop (inmode, AND, in, const1_rtx, NULL,
30231                             1, OPTAB_DIRECT);
30232   i0 = expand_simple_binop (inmode, IOR, i0, i1, i0, 1, OPTAB_DIRECT);
30233
30234   expand_float (f0, i0, 0);
30235
30236   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
30237
30238   emit_label (donelab);
30239 }
30240 \f
30241 /* AVX does not support 32-byte integer vector operations,
30242    thus the longest vector we are faced with is V16QImode.  */
30243 #define MAX_VECT_LEN    16
30244
30245 struct expand_vec_perm_d
30246 {
30247   rtx target, op0, op1;
30248   unsigned char perm[MAX_VECT_LEN];
30249   enum machine_mode vmode;
30250   unsigned char nelt;
30251   bool testing_p;
30252 };
30253
30254 static bool expand_vec_perm_1 (struct expand_vec_perm_d *d);
30255 static bool expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d);
30256
30257 /* Get a vector mode of the same size as the original but with elements
30258    twice as wide.  This is only guaranteed to apply to integral vectors.  */
30259
30260 static inline enum machine_mode
30261 get_mode_wider_vector (enum machine_mode o)
30262 {
30263   /* ??? Rely on the ordering that genmodes.c gives to vectors.  */
30264   enum machine_mode n = GET_MODE_WIDER_MODE (o);
30265   gcc_assert (GET_MODE_NUNITS (o) == GET_MODE_NUNITS (n) * 2);
30266   gcc_assert (GET_MODE_SIZE (o) == GET_MODE_SIZE (n));
30267   return n;
30268 }
30269
30270 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30271    with all elements equal to VAR.  Return true if successful.  */
30272
30273 static bool
30274 ix86_expand_vector_init_duplicate (bool mmx_ok, enum machine_mode mode,
30275                                    rtx target, rtx val)
30276 {
30277   bool ok;
30278
30279   switch (mode)
30280     {
30281     case V2SImode:
30282     case V2SFmode:
30283       if (!mmx_ok)
30284         return false;
30285       /* FALLTHRU */
30286
30287     case V4DFmode:
30288     case V4DImode:
30289     case V8SFmode:
30290     case V8SImode:
30291     case V2DFmode:
30292     case V2DImode:
30293     case V4SFmode:
30294     case V4SImode:
30295       {
30296         rtx insn, dup;
30297
30298         /* First attempt to recognize VAL as-is.  */
30299         dup = gen_rtx_VEC_DUPLICATE (mode, val);
30300         insn = emit_insn (gen_rtx_SET (VOIDmode, target, dup));
30301         if (recog_memoized (insn) < 0)
30302           {
30303             rtx seq;
30304             /* If that fails, force VAL into a register.  */
30305
30306             start_sequence ();
30307             XEXP (dup, 0) = force_reg (GET_MODE_INNER (mode), val);
30308             seq = get_insns ();
30309             end_sequence ();
30310             if (seq)
30311               emit_insn_before (seq, insn);
30312
30313             ok = recog_memoized (insn) >= 0;
30314             gcc_assert (ok);
30315           }
30316       }
30317       return true;
30318
30319     case V4HImode:
30320       if (!mmx_ok)
30321         return false;
30322       if (TARGET_SSE || TARGET_3DNOW_A)
30323         {
30324           rtx x;
30325
30326           val = gen_lowpart (SImode, val);
30327           x = gen_rtx_TRUNCATE (HImode, val);
30328           x = gen_rtx_VEC_DUPLICATE (mode, x);
30329           emit_insn (gen_rtx_SET (VOIDmode, target, x));
30330           return true;
30331         }
30332       goto widen;
30333
30334     case V8QImode:
30335       if (!mmx_ok)
30336         return false;
30337       goto widen;
30338
30339     case V8HImode:
30340       if (TARGET_SSE2)
30341         {
30342           struct expand_vec_perm_d dperm;
30343           rtx tmp1, tmp2;
30344
30345         permute:
30346           memset (&dperm, 0, sizeof (dperm));
30347           dperm.target = target;
30348           dperm.vmode = mode;
30349           dperm.nelt = GET_MODE_NUNITS (mode);
30350           dperm.op0 = dperm.op1 = gen_reg_rtx (mode);
30351
30352           /* Extend to SImode using a paradoxical SUBREG.  */
30353           tmp1 = gen_reg_rtx (SImode);
30354           emit_move_insn (tmp1, gen_lowpart (SImode, val));
30355
30356           /* Insert the SImode value as low element of a V4SImode vector. */
30357           tmp2 = gen_lowpart (V4SImode, dperm.op0);
30358           emit_insn (gen_vec_setv4si_0 (tmp2, CONST0_RTX (V4SImode), tmp1));
30359
30360           ok = (expand_vec_perm_1 (&dperm)
30361                 || expand_vec_perm_broadcast_1 (&dperm));
30362           gcc_assert (ok);
30363           return ok;
30364         }
30365       goto widen;
30366
30367     case V16QImode:
30368       if (TARGET_SSE2)
30369         goto permute;
30370       goto widen;
30371
30372     widen:
30373       /* Replicate the value once into the next wider mode and recurse.  */
30374       {
30375         enum machine_mode smode, wsmode, wvmode;
30376         rtx x;
30377
30378         smode = GET_MODE_INNER (mode);
30379         wvmode = get_mode_wider_vector (mode);
30380         wsmode = GET_MODE_INNER (wvmode);
30381
30382         val = convert_modes (wsmode, smode, val, true);
30383         x = expand_simple_binop (wsmode, ASHIFT, val,
30384                                  GEN_INT (GET_MODE_BITSIZE (smode)),
30385                                  NULL_RTX, 1, OPTAB_LIB_WIDEN);
30386         val = expand_simple_binop (wsmode, IOR, val, x, x, 1, OPTAB_LIB_WIDEN);
30387
30388         x = gen_lowpart (wvmode, target);
30389         ok = ix86_expand_vector_init_duplicate (mmx_ok, wvmode, x, val);
30390         gcc_assert (ok);
30391         return ok;
30392       }
30393
30394     case V16HImode:
30395     case V32QImode:
30396       {
30397         enum machine_mode hvmode = (mode == V16HImode ? V8HImode : V16QImode);
30398         rtx x = gen_reg_rtx (hvmode);
30399
30400         ok = ix86_expand_vector_init_duplicate (false, hvmode, x, val);
30401         gcc_assert (ok);
30402
30403         x = gen_rtx_VEC_CONCAT (mode, x, x);
30404         emit_insn (gen_rtx_SET (VOIDmode, target, x));
30405       }
30406       return true;
30407
30408     default:
30409       return false;
30410     }
30411 }
30412
30413 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30414    whose ONE_VAR element is VAR, and other elements are zero.  Return true
30415    if successful.  */
30416
30417 static bool
30418 ix86_expand_vector_init_one_nonzero (bool mmx_ok, enum machine_mode mode,
30419                                      rtx target, rtx var, int one_var)
30420 {
30421   enum machine_mode vsimode;
30422   rtx new_target;
30423   rtx x, tmp;
30424   bool use_vector_set = false;
30425
30426   switch (mode)
30427     {
30428     case V2DImode:
30429       /* For SSE4.1, we normally use vector set.  But if the second
30430          element is zero and inter-unit moves are OK, we use movq
30431          instead.  */
30432       use_vector_set = (TARGET_64BIT
30433                         && TARGET_SSE4_1
30434                         && !(TARGET_INTER_UNIT_MOVES
30435                              && one_var == 0));
30436       break;
30437     case V16QImode:
30438     case V4SImode:
30439     case V4SFmode:
30440       use_vector_set = TARGET_SSE4_1;
30441       break;
30442     case V8HImode:
30443       use_vector_set = TARGET_SSE2;
30444       break;
30445     case V4HImode:
30446       use_vector_set = TARGET_SSE || TARGET_3DNOW_A;
30447       break;
30448     case V32QImode:
30449     case V16HImode:
30450     case V8SImode:
30451     case V8SFmode:
30452     case V4DFmode:
30453       use_vector_set = TARGET_AVX;
30454       break;
30455     case V4DImode:
30456       /* Use ix86_expand_vector_set in 64bit mode only.  */
30457       use_vector_set = TARGET_AVX && TARGET_64BIT;
30458       break;
30459     default:
30460       break;
30461     }
30462
30463   if (use_vector_set)
30464     {
30465       emit_insn (gen_rtx_SET (VOIDmode, target, CONST0_RTX (mode)));
30466       var = force_reg (GET_MODE_INNER (mode), var);
30467       ix86_expand_vector_set (mmx_ok, target, var, one_var);
30468       return true;
30469     }
30470
30471   switch (mode)
30472     {
30473     case V2SFmode:
30474     case V2SImode:
30475       if (!mmx_ok)
30476         return false;
30477       /* FALLTHRU */
30478
30479     case V2DFmode:
30480     case V2DImode:
30481       if (one_var != 0)
30482         return false;
30483       var = force_reg (GET_MODE_INNER (mode), var);
30484       x = gen_rtx_VEC_CONCAT (mode, var, CONST0_RTX (GET_MODE_INNER (mode)));
30485       emit_insn (gen_rtx_SET (VOIDmode, target, x));
30486       return true;
30487
30488     case V4SFmode:
30489     case V4SImode:
30490       if (!REG_P (target) || REGNO (target) < FIRST_PSEUDO_REGISTER)
30491         new_target = gen_reg_rtx (mode);
30492       else
30493         new_target = target;
30494       var = force_reg (GET_MODE_INNER (mode), var);
30495       x = gen_rtx_VEC_DUPLICATE (mode, var);
30496       x = gen_rtx_VEC_MERGE (mode, x, CONST0_RTX (mode), const1_rtx);
30497       emit_insn (gen_rtx_SET (VOIDmode, new_target, x));
30498       if (one_var != 0)
30499         {
30500           /* We need to shuffle the value to the correct position, so
30501              create a new pseudo to store the intermediate result.  */
30502
30503           /* With SSE2, we can use the integer shuffle insns.  */
30504           if (mode != V4SFmode && TARGET_SSE2)
30505             {
30506               emit_insn (gen_sse2_pshufd_1 (new_target, new_target,
30507                                             const1_rtx,
30508                                             GEN_INT (one_var == 1 ? 0 : 1),
30509                                             GEN_INT (one_var == 2 ? 0 : 1),
30510                                             GEN_INT (one_var == 3 ? 0 : 1)));
30511               if (target != new_target)
30512                 emit_move_insn (target, new_target);
30513               return true;
30514             }
30515
30516           /* Otherwise convert the intermediate result to V4SFmode and
30517              use the SSE1 shuffle instructions.  */
30518           if (mode != V4SFmode)
30519             {
30520               tmp = gen_reg_rtx (V4SFmode);
30521               emit_move_insn (tmp, gen_lowpart (V4SFmode, new_target));
30522             }
30523           else
30524             tmp = new_target;
30525
30526           emit_insn (gen_sse_shufps_v4sf (tmp, tmp, tmp,
30527                                        const1_rtx,
30528                                        GEN_INT (one_var == 1 ? 0 : 1),
30529                                        GEN_INT (one_var == 2 ? 0+4 : 1+4),
30530                                        GEN_INT (one_var == 3 ? 0+4 : 1+4)));
30531
30532           if (mode != V4SFmode)
30533             emit_move_insn (target, gen_lowpart (V4SImode, tmp));
30534           else if (tmp != target)
30535             emit_move_insn (target, tmp);
30536         }
30537       else if (target != new_target)
30538         emit_move_insn (target, new_target);
30539       return true;
30540
30541     case V8HImode:
30542     case V16QImode:
30543       vsimode = V4SImode;
30544       goto widen;
30545     case V4HImode:
30546     case V8QImode:
30547       if (!mmx_ok)
30548         return false;
30549       vsimode = V2SImode;
30550       goto widen;
30551     widen:
30552       if (one_var != 0)
30553         return false;
30554
30555       /* Zero extend the variable element to SImode and recurse.  */
30556       var = convert_modes (SImode, GET_MODE_INNER (mode), var, true);
30557
30558       x = gen_reg_rtx (vsimode);
30559       if (!ix86_expand_vector_init_one_nonzero (mmx_ok, vsimode, x,
30560                                                 var, one_var))
30561         gcc_unreachable ();
30562
30563       emit_move_insn (target, gen_lowpart (mode, x));
30564       return true;
30565
30566     default:
30567       return false;
30568     }
30569 }
30570
30571 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
30572    consisting of the values in VALS.  It is known that all elements
30573    except ONE_VAR are constants.  Return true if successful.  */
30574
30575 static bool
30576 ix86_expand_vector_init_one_var (bool mmx_ok, enum machine_mode mode,
30577                                  rtx target, rtx vals, int one_var)
30578 {
30579   rtx var = XVECEXP (vals, 0, one_var);
30580   enum machine_mode wmode;
30581   rtx const_vec, x;
30582
30583   const_vec = copy_rtx (vals);
30584   XVECEXP (const_vec, 0, one_var) = CONST0_RTX (GET_MODE_INNER (mode));
30585   const_vec = gen_rtx_CONST_VECTOR (mode, XVEC (const_vec, 0));
30586
30587   switch (mode)
30588     {
30589     case V2DFmode:
30590     case V2DImode:
30591     case V2SFmode:
30592     case V2SImode:
30593       /* For the two element vectors, it's just as easy to use
30594          the general case.  */
30595       return false;
30596
30597     case V4DImode:
30598       /* Use ix86_expand_vector_set in 64bit mode only.  */
30599       if (!TARGET_64BIT)
30600         return false;
30601     case V4DFmode:
30602     case V8SFmode:
30603     case V8SImode:
30604     case V16HImode:
30605     case V32QImode:
30606     case V4SFmode:
30607     case V4SImode:
30608     case V8HImode:
30609     case V4HImode:
30610       break;
30611
30612     case V16QImode:
30613       if (TARGET_SSE4_1)
30614         break;
30615       wmode = V8HImode;
30616       goto widen;
30617     case V8QImode:
30618       wmode = V4HImode;
30619       goto widen;
30620     widen:
30621       /* There's no way to set one QImode entry easily.  Combine
30622          the variable value with its adjacent constant value, and
30623          promote to an HImode set.  */
30624       x = XVECEXP (vals, 0, one_var ^ 1);
30625       if (one_var & 1)
30626         {
30627           var = convert_modes (HImode, QImode, var, true);
30628           var = expand_simple_binop (HImode, ASHIFT, var, GEN_INT (8),
30629                                      NULL_RTX, 1, OPTAB_LIB_WIDEN);
30630           x = GEN_INT (INTVAL (x) & 0xff);
30631         }
30632       else
30633         {
30634           var = convert_modes (HImode, QImode, var, true);
30635           x = gen_int_mode (INTVAL (x) << 8, HImode);
30636         }
30637       if (x != const0_rtx)
30638         var = expand_simple_binop (HImode, IOR, var, x, var,
30639                                    1, OPTAB_LIB_WIDEN);
30640
30641       x = gen_reg_rtx (wmode);
30642       emit_move_insn (x, gen_lowpart (wmode, const_vec));
30643       ix86_expand_vector_set (mmx_ok, x, var, one_var >> 1);
30644
30645       emit_move_insn (target, gen_lowpart (mode, x));
30646       return true;
30647
30648     default:
30649       return false;
30650     }
30651
30652   emit_move_insn (target, const_vec);
30653   ix86_expand_vector_set (mmx_ok, target, var, one_var);
30654   return true;
30655 }
30656
30657 /* A subroutine of ix86_expand_vector_init_general.  Use vector
30658    concatenate to handle the most general case: all values variable,
30659    and none identical.  */
30660
30661 static void
30662 ix86_expand_vector_init_concat (enum machine_mode mode,
30663                                 rtx target, rtx *ops, int n)
30664 {
30665   enum machine_mode cmode, hmode = VOIDmode;
30666   rtx first[8], second[4];
30667   rtvec v;
30668   int i, j;
30669
30670   switch (n)
30671     {
30672     case 2:
30673       switch (mode)
30674         {
30675         case V8SImode:
30676           cmode = V4SImode;
30677           break;
30678         case V8SFmode:
30679           cmode = V4SFmode;
30680           break;
30681         case V4DImode:
30682           cmode = V2DImode;
30683           break;
30684         case V4DFmode:
30685           cmode = V2DFmode;
30686           break;
30687         case V4SImode:
30688           cmode = V2SImode;
30689           break;
30690         case V4SFmode:
30691           cmode = V2SFmode;
30692           break;
30693         case V2DImode:
30694           cmode = DImode;
30695           break;
30696         case V2SImode:
30697           cmode = SImode;
30698           break;
30699         case V2DFmode:
30700           cmode = DFmode;
30701           break;
30702         case V2SFmode:
30703           cmode = SFmode;
30704           break;
30705         default:
30706           gcc_unreachable ();
30707         }
30708
30709       if (!register_operand (ops[1], cmode))
30710         ops[1] = force_reg (cmode, ops[1]);
30711       if (!register_operand (ops[0], cmode))
30712         ops[0] = force_reg (cmode, ops[0]);
30713       emit_insn (gen_rtx_SET (VOIDmode, target,
30714                               gen_rtx_VEC_CONCAT (mode, ops[0],
30715                                                   ops[1])));
30716       break;
30717
30718     case 4:
30719       switch (mode)
30720         {
30721         case V4DImode:
30722           cmode = V2DImode;
30723           break;
30724         case V4DFmode:
30725           cmode = V2DFmode;
30726           break;
30727         case V4SImode:
30728           cmode = V2SImode;
30729           break;
30730         case V4SFmode:
30731           cmode = V2SFmode;
30732           break;
30733         default:
30734           gcc_unreachable ();
30735         }
30736       goto half;
30737
30738     case 8:
30739       switch (mode)
30740         {
30741         case V8SImode:
30742           cmode = V2SImode;
30743           hmode = V4SImode;
30744           break;
30745         case V8SFmode:
30746           cmode = V2SFmode;
30747           hmode = V4SFmode;
30748           break;
30749         default:
30750           gcc_unreachable ();
30751         }
30752       goto half;
30753
30754 half:
30755       /* FIXME: We process inputs backward to help RA.  PR 36222.  */
30756       i = n - 1;
30757       j = (n >> 1) - 1;
30758       for (; i > 0; i -= 2, j--)
30759         {
30760           first[j] = gen_reg_rtx (cmode);
30761           v = gen_rtvec (2, ops[i - 1], ops[i]);
30762           ix86_expand_vector_init (false, first[j],
30763                                    gen_rtx_PARALLEL (cmode, v));
30764         }
30765
30766       n >>= 1;
30767       if (n > 2)
30768         {
30769           gcc_assert (hmode != VOIDmode);
30770           for (i = j = 0; i < n; i += 2, j++)
30771             {
30772               second[j] = gen_reg_rtx (hmode);
30773               ix86_expand_vector_init_concat (hmode, second [j],
30774                                               &first [i], 2);
30775             }
30776           n >>= 1;
30777           ix86_expand_vector_init_concat (mode, target, second, n);
30778         }
30779       else
30780         ix86_expand_vector_init_concat (mode, target, first, n);
30781       break;
30782
30783     default:
30784       gcc_unreachable ();
30785     }
30786 }
30787
30788 /* A subroutine of ix86_expand_vector_init_general.  Use vector
30789    interleave to handle the most general case: all values variable,
30790    and none identical.  */
30791
30792 static void
30793 ix86_expand_vector_init_interleave (enum machine_mode mode,
30794                                     rtx target, rtx *ops, int n)
30795 {
30796   enum machine_mode first_imode, second_imode, third_imode, inner_mode;
30797   int i, j;
30798   rtx op0, op1;
30799   rtx (*gen_load_even) (rtx, rtx, rtx);
30800   rtx (*gen_interleave_first_low) (rtx, rtx, rtx);
30801   rtx (*gen_interleave_second_low) (rtx, rtx, rtx);
30802
30803   switch (mode)
30804     {
30805     case V8HImode:
30806       gen_load_even = gen_vec_setv8hi;
30807       gen_interleave_first_low = gen_vec_interleave_lowv4si;
30808       gen_interleave_second_low = gen_vec_interleave_lowv2di;
30809       inner_mode = HImode;
30810       first_imode = V4SImode;
30811       second_imode = V2DImode;
30812       third_imode = VOIDmode;
30813       break;
30814     case V16QImode:
30815       gen_load_even = gen_vec_setv16qi;
30816       gen_interleave_first_low = gen_vec_interleave_lowv8hi;
30817       gen_interleave_second_low = gen_vec_interleave_lowv4si;
30818       inner_mode = QImode;
30819       first_imode = V8HImode;
30820       second_imode = V4SImode;
30821       third_imode = V2DImode;
30822       break;
30823     default:
30824       gcc_unreachable ();
30825     }
30826
30827   for (i = 0; i < n; i++)
30828     {
30829       /* Extend the odd elment to SImode using a paradoxical SUBREG.  */
30830       op0 = gen_reg_rtx (SImode);
30831       emit_move_insn (op0, gen_lowpart (SImode, ops [i + i]));
30832
30833       /* Insert the SImode value as low element of V4SImode vector. */
30834       op1 = gen_reg_rtx (V4SImode);
30835       op0 = gen_rtx_VEC_MERGE (V4SImode,
30836                                gen_rtx_VEC_DUPLICATE (V4SImode,
30837                                                       op0),
30838                                CONST0_RTX (V4SImode),
30839                                const1_rtx);
30840       emit_insn (gen_rtx_SET (VOIDmode, op1, op0));
30841
30842       /* Cast the V4SImode vector back to a vector in orignal mode.  */
30843       op0 = gen_reg_rtx (mode);
30844       emit_move_insn (op0, gen_lowpart (mode, op1));
30845
30846       /* Load even elements into the second positon.  */
30847       emit_insn (gen_load_even (op0,
30848                                 force_reg (inner_mode,
30849                                            ops [i + i + 1]),
30850                                 const1_rtx));
30851
30852       /* Cast vector to FIRST_IMODE vector.  */
30853       ops[i] = gen_reg_rtx (first_imode);
30854       emit_move_insn (ops[i], gen_lowpart (first_imode, op0));
30855     }
30856
30857   /* Interleave low FIRST_IMODE vectors.  */
30858   for (i = j = 0; i < n; i += 2, j++)
30859     {
30860       op0 = gen_reg_rtx (first_imode);
30861       emit_insn (gen_interleave_first_low (op0, ops[i], ops[i + 1]));
30862
30863       /* Cast FIRST_IMODE vector to SECOND_IMODE vector.  */
30864       ops[j] = gen_reg_rtx (second_imode);
30865       emit_move_insn (ops[j], gen_lowpart (second_imode, op0));
30866     }
30867
30868   /* Interleave low SECOND_IMODE vectors.  */
30869   switch (second_imode)
30870     {
30871     case V4SImode:
30872       for (i = j = 0; i < n / 2; i += 2, j++)
30873         {
30874           op0 = gen_reg_rtx (second_imode);
30875           emit_insn (gen_interleave_second_low (op0, ops[i],
30876                                                 ops[i + 1]));
30877
30878           /* Cast the SECOND_IMODE vector to the THIRD_IMODE
30879              vector.  */
30880           ops[j] = gen_reg_rtx (third_imode);
30881           emit_move_insn (ops[j], gen_lowpart (third_imode, op0));
30882         }
30883       second_imode = V2DImode;
30884       gen_interleave_second_low = gen_vec_interleave_lowv2di;
30885       /* FALLTHRU */
30886
30887     case V2DImode:
30888       op0 = gen_reg_rtx (second_imode);
30889       emit_insn (gen_interleave_second_low (op0, ops[0],
30890                                             ops[1]));
30891
30892       /* Cast the SECOND_IMODE vector back to a vector on original
30893          mode.  */
30894       emit_insn (gen_rtx_SET (VOIDmode, target,
30895                               gen_lowpart (mode, op0)));
30896       break;
30897
30898     default:
30899       gcc_unreachable ();
30900     }
30901 }
30902
30903 /* A subroutine of ix86_expand_vector_init.  Handle the most general case:
30904    all values variable, and none identical.  */
30905
30906 static void
30907 ix86_expand_vector_init_general (bool mmx_ok, enum machine_mode mode,
30908                                  rtx target, rtx vals)
30909 {
30910   rtx ops[32], op0, op1;
30911   enum machine_mode half_mode = VOIDmode;
30912   int n, i;
30913
30914   switch (mode)
30915     {
30916     case V2SFmode:
30917     case V2SImode:
30918       if (!mmx_ok && !TARGET_SSE)
30919         break;
30920       /* FALLTHRU */
30921
30922     case V8SFmode:
30923     case V8SImode:
30924     case V4DFmode:
30925     case V4DImode:
30926     case V4SFmode:
30927     case V4SImode:
30928     case V2DFmode:
30929     case V2DImode:
30930       n = GET_MODE_NUNITS (mode);
30931       for (i = 0; i < n; i++)
30932         ops[i] = XVECEXP (vals, 0, i);
30933       ix86_expand_vector_init_concat (mode, target, ops, n);
30934       return;
30935
30936     case V32QImode:
30937       half_mode = V16QImode;
30938       goto half;
30939
30940     case V16HImode:
30941       half_mode = V8HImode;
30942       goto half;
30943
30944 half:
30945       n = GET_MODE_NUNITS (mode);
30946       for (i = 0; i < n; i++)
30947         ops[i] = XVECEXP (vals, 0, i);
30948       op0 = gen_reg_rtx (half_mode);
30949       op1 = gen_reg_rtx (half_mode);
30950       ix86_expand_vector_init_interleave (half_mode, op0, ops,
30951                                           n >> 2);
30952       ix86_expand_vector_init_interleave (half_mode, op1,
30953                                           &ops [n >> 1], n >> 2);
30954       emit_insn (gen_rtx_SET (VOIDmode, target,
30955                               gen_rtx_VEC_CONCAT (mode, op0, op1)));
30956       return;
30957
30958     case V16QImode:
30959       if (!TARGET_SSE4_1)
30960         break;
30961       /* FALLTHRU */
30962
30963     case V8HImode:
30964       if (!TARGET_SSE2)
30965         break;
30966
30967       /* Don't use ix86_expand_vector_init_interleave if we can't
30968          move from GPR to SSE register directly.  */
30969       if (!TARGET_INTER_UNIT_MOVES)
30970         break;
30971
30972       n = GET_MODE_NUNITS (mode);
30973       for (i = 0; i < n; i++)
30974         ops[i] = XVECEXP (vals, 0, i);
30975       ix86_expand_vector_init_interleave (mode, target, ops, n >> 1);
30976       return;
30977
30978     case V4HImode:
30979     case V8QImode:
30980       break;
30981
30982     default:
30983       gcc_unreachable ();
30984     }
30985
30986     {
30987       int i, j, n_elts, n_words, n_elt_per_word;
30988       enum machine_mode inner_mode;
30989       rtx words[4], shift;
30990
30991       inner_mode = GET_MODE_INNER (mode);
30992       n_elts = GET_MODE_NUNITS (mode);
30993       n_words = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
30994       n_elt_per_word = n_elts / n_words;
30995       shift = GEN_INT (GET_MODE_BITSIZE (inner_mode));
30996
30997       for (i = 0; i < n_words; ++i)
30998         {
30999           rtx word = NULL_RTX;
31000
31001           for (j = 0; j < n_elt_per_word; ++j)
31002             {
31003               rtx elt = XVECEXP (vals, 0, (i+1)*n_elt_per_word - j - 1);
31004               elt = convert_modes (word_mode, inner_mode, elt, true);
31005
31006               if (j == 0)
31007                 word = elt;
31008               else
31009                 {
31010                   word = expand_simple_binop (word_mode, ASHIFT, word, shift,
31011                                               word, 1, OPTAB_LIB_WIDEN);
31012                   word = expand_simple_binop (word_mode, IOR, word, elt,
31013                                               word, 1, OPTAB_LIB_WIDEN);
31014                 }
31015             }
31016
31017           words[i] = word;
31018         }
31019
31020       if (n_words == 1)
31021         emit_move_insn (target, gen_lowpart (mode, words[0]));
31022       else if (n_words == 2)
31023         {
31024           rtx tmp = gen_reg_rtx (mode);
31025           emit_clobber (tmp);
31026           emit_move_insn (gen_lowpart (word_mode, tmp), words[0]);
31027           emit_move_insn (gen_highpart (word_mode, tmp), words[1]);
31028           emit_move_insn (target, tmp);
31029         }
31030       else if (n_words == 4)
31031         {
31032           rtx tmp = gen_reg_rtx (V4SImode);
31033           gcc_assert (word_mode == SImode);
31034           vals = gen_rtx_PARALLEL (V4SImode, gen_rtvec_v (4, words));
31035           ix86_expand_vector_init_general (false, V4SImode, tmp, vals);
31036           emit_move_insn (target, gen_lowpart (mode, tmp));
31037         }
31038       else
31039         gcc_unreachable ();
31040     }
31041 }
31042
31043 /* Initialize vector TARGET via VALS.  Suppress the use of MMX
31044    instructions unless MMX_OK is true.  */
31045
31046 void
31047 ix86_expand_vector_init (bool mmx_ok, rtx target, rtx vals)
31048 {
31049   enum machine_mode mode = GET_MODE (target);
31050   enum machine_mode inner_mode = GET_MODE_INNER (mode);
31051   int n_elts = GET_MODE_NUNITS (mode);
31052   int n_var = 0, one_var = -1;
31053   bool all_same = true, all_const_zero = true;
31054   int i;
31055   rtx x;
31056
31057   for (i = 0; i < n_elts; ++i)
31058     {
31059       x = XVECEXP (vals, 0, i);
31060       if (!(CONST_INT_P (x)
31061             || GET_CODE (x) == CONST_DOUBLE
31062             || GET_CODE (x) == CONST_FIXED))
31063         n_var++, one_var = i;
31064       else if (x != CONST0_RTX (inner_mode))
31065         all_const_zero = false;
31066       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
31067         all_same = false;
31068     }
31069
31070   /* Constants are best loaded from the constant pool.  */
31071   if (n_var == 0)
31072     {
31073       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
31074       return;
31075     }
31076
31077   /* If all values are identical, broadcast the value.  */
31078   if (all_same
31079       && ix86_expand_vector_init_duplicate (mmx_ok, mode, target,
31080                                             XVECEXP (vals, 0, 0)))
31081     return;
31082
31083   /* Values where only one field is non-constant are best loaded from
31084      the pool and overwritten via move later.  */
31085   if (n_var == 1)
31086     {
31087       if (all_const_zero
31088           && ix86_expand_vector_init_one_nonzero (mmx_ok, mode, target,
31089                                                   XVECEXP (vals, 0, one_var),
31090                                                   one_var))
31091         return;
31092
31093       if (ix86_expand_vector_init_one_var (mmx_ok, mode, target, vals, one_var))
31094         return;
31095     }
31096
31097   ix86_expand_vector_init_general (mmx_ok, mode, target, vals);
31098 }
31099
31100 void
31101 ix86_expand_vector_set (bool mmx_ok, rtx target, rtx val, int elt)
31102 {
31103   enum machine_mode mode = GET_MODE (target);
31104   enum machine_mode inner_mode = GET_MODE_INNER (mode);
31105   enum machine_mode half_mode;
31106   bool use_vec_merge = false;
31107   rtx tmp;
31108   static rtx (*gen_extract[6][2]) (rtx, rtx)
31109     = {
31110         { gen_vec_extract_lo_v32qi, gen_vec_extract_hi_v32qi },
31111         { gen_vec_extract_lo_v16hi, gen_vec_extract_hi_v16hi },
31112         { gen_vec_extract_lo_v8si, gen_vec_extract_hi_v8si },
31113         { gen_vec_extract_lo_v4di, gen_vec_extract_hi_v4di },
31114         { gen_vec_extract_lo_v8sf, gen_vec_extract_hi_v8sf },
31115         { gen_vec_extract_lo_v4df, gen_vec_extract_hi_v4df }
31116       };
31117   static rtx (*gen_insert[6][2]) (rtx, rtx, rtx)
31118     = {
31119         { gen_vec_set_lo_v32qi, gen_vec_set_hi_v32qi },
31120         { gen_vec_set_lo_v16hi, gen_vec_set_hi_v16hi },
31121         { gen_vec_set_lo_v8si, gen_vec_set_hi_v8si },
31122         { gen_vec_set_lo_v4di, gen_vec_set_hi_v4di },
31123         { gen_vec_set_lo_v8sf, gen_vec_set_hi_v8sf },
31124         { gen_vec_set_lo_v4df, gen_vec_set_hi_v4df }
31125       };
31126   int i, j, n;
31127
31128   switch (mode)
31129     {
31130     case V2SFmode:
31131     case V2SImode:
31132       if (mmx_ok)
31133         {
31134           tmp = gen_reg_rtx (GET_MODE_INNER (mode));
31135           ix86_expand_vector_extract (true, tmp, target, 1 - elt);
31136           if (elt == 0)
31137             tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
31138           else
31139             tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
31140           emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31141           return;
31142         }
31143       break;
31144
31145     case V2DImode:
31146       use_vec_merge = TARGET_SSE4_1 && TARGET_64BIT;
31147       if (use_vec_merge)
31148         break;
31149
31150       tmp = gen_reg_rtx (GET_MODE_INNER (mode));
31151       ix86_expand_vector_extract (false, tmp, target, 1 - elt);
31152       if (elt == 0)
31153         tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
31154       else
31155         tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
31156       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31157       return;
31158
31159     case V2DFmode:
31160       {
31161         rtx op0, op1;
31162
31163         /* For the two element vectors, we implement a VEC_CONCAT with
31164            the extraction of the other element.  */
31165
31166         tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (1 - elt)));
31167         tmp = gen_rtx_VEC_SELECT (inner_mode, target, tmp);
31168
31169         if (elt == 0)
31170           op0 = val, op1 = tmp;
31171         else
31172           op0 = tmp, op1 = val;
31173
31174         tmp = gen_rtx_VEC_CONCAT (mode, op0, op1);
31175         emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31176       }
31177       return;
31178
31179     case V4SFmode:
31180       use_vec_merge = TARGET_SSE4_1;
31181       if (use_vec_merge)
31182         break;
31183
31184       switch (elt)
31185         {
31186         case 0:
31187           use_vec_merge = true;
31188           break;
31189
31190         case 1:
31191           /* tmp = target = A B C D */
31192           tmp = copy_to_reg (target);
31193           /* target = A A B B */
31194           emit_insn (gen_vec_interleave_lowv4sf (target, target, target));
31195           /* target = X A B B */
31196           ix86_expand_vector_set (false, target, val, 0);
31197           /* target = A X C D  */
31198           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31199                                           const1_rtx, const0_rtx,
31200                                           GEN_INT (2+4), GEN_INT (3+4)));
31201           return;
31202
31203         case 2:
31204           /* tmp = target = A B C D */
31205           tmp = copy_to_reg (target);
31206           /* tmp = X B C D */
31207           ix86_expand_vector_set (false, tmp, val, 0);
31208           /* target = A B X D */
31209           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31210                                           const0_rtx, const1_rtx,
31211                                           GEN_INT (0+4), GEN_INT (3+4)));
31212           return;
31213
31214         case 3:
31215           /* tmp = target = A B C D */
31216           tmp = copy_to_reg (target);
31217           /* tmp = X B C D */
31218           ix86_expand_vector_set (false, tmp, val, 0);
31219           /* target = A B X D */
31220           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
31221                                           const0_rtx, const1_rtx,
31222                                           GEN_INT (2+4), GEN_INT (0+4)));
31223           return;
31224
31225         default:
31226           gcc_unreachable ();
31227         }
31228       break;
31229
31230     case V4SImode:
31231       use_vec_merge = TARGET_SSE4_1;
31232       if (use_vec_merge)
31233         break;
31234
31235       /* Element 0 handled by vec_merge below.  */
31236       if (elt == 0)
31237         {
31238           use_vec_merge = true;
31239           break;
31240         }
31241
31242       if (TARGET_SSE2)
31243         {
31244           /* With SSE2, use integer shuffles to swap element 0 and ELT,
31245              store into element 0, then shuffle them back.  */
31246
31247           rtx order[4];
31248
31249           order[0] = GEN_INT (elt);
31250           order[1] = const1_rtx;
31251           order[2] = const2_rtx;
31252           order[3] = GEN_INT (3);
31253           order[elt] = const0_rtx;
31254
31255           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
31256                                         order[1], order[2], order[3]));
31257
31258           ix86_expand_vector_set (false, target, val, 0);
31259
31260           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
31261                                         order[1], order[2], order[3]));
31262         }
31263       else
31264         {
31265           /* For SSE1, we have to reuse the V4SF code.  */
31266           ix86_expand_vector_set (false, gen_lowpart (V4SFmode, target),
31267                                   gen_lowpart (SFmode, val), elt);
31268         }
31269       return;
31270
31271     case V8HImode:
31272       use_vec_merge = TARGET_SSE2;
31273       break;
31274     case V4HImode:
31275       use_vec_merge = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
31276       break;
31277
31278     case V16QImode:
31279       use_vec_merge = TARGET_SSE4_1;
31280       break;
31281
31282     case V8QImode:
31283       break;
31284
31285     case V32QImode:
31286       half_mode = V16QImode;
31287       j = 0;
31288       n = 16;
31289       goto half;
31290
31291     case V16HImode:
31292       half_mode = V8HImode;
31293       j = 1;
31294       n = 8;
31295       goto half;
31296
31297     case V8SImode:
31298       half_mode = V4SImode;
31299       j = 2;
31300       n = 4;
31301       goto half;
31302
31303     case V4DImode:
31304       half_mode = V2DImode;
31305       j = 3;
31306       n = 2;
31307       goto half;
31308
31309     case V8SFmode:
31310       half_mode = V4SFmode;
31311       j = 4;
31312       n = 4;
31313       goto half;
31314
31315     case V4DFmode:
31316       half_mode = V2DFmode;
31317       j = 5;
31318       n = 2;
31319       goto half;
31320
31321 half:
31322       /* Compute offset.  */
31323       i = elt / n;
31324       elt %= n;
31325
31326       gcc_assert (i <= 1);
31327
31328       /* Extract the half.  */
31329       tmp = gen_reg_rtx (half_mode);
31330       emit_insn (gen_extract[j][i] (tmp, target));
31331
31332       /* Put val in tmp at elt.  */
31333       ix86_expand_vector_set (false, tmp, val, elt);
31334
31335       /* Put it back.  */
31336       emit_insn (gen_insert[j][i] (target, target, tmp));
31337       return;
31338
31339     default:
31340       break;
31341     }
31342
31343   if (use_vec_merge)
31344     {
31345       tmp = gen_rtx_VEC_DUPLICATE (mode, val);
31346       tmp = gen_rtx_VEC_MERGE (mode, tmp, target, GEN_INT (1 << elt));
31347       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31348     }
31349   else
31350     {
31351       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
31352
31353       emit_move_insn (mem, target);
31354
31355       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
31356       emit_move_insn (tmp, val);
31357
31358       emit_move_insn (target, mem);
31359     }
31360 }
31361
31362 void
31363 ix86_expand_vector_extract (bool mmx_ok, rtx target, rtx vec, int elt)
31364 {
31365   enum machine_mode mode = GET_MODE (vec);
31366   enum machine_mode inner_mode = GET_MODE_INNER (mode);
31367   bool use_vec_extr = false;
31368   rtx tmp;
31369
31370   switch (mode)
31371     {
31372     case V2SImode:
31373     case V2SFmode:
31374       if (!mmx_ok)
31375         break;
31376       /* FALLTHRU */
31377
31378     case V2DFmode:
31379     case V2DImode:
31380       use_vec_extr = true;
31381       break;
31382
31383     case V4SFmode:
31384       use_vec_extr = TARGET_SSE4_1;
31385       if (use_vec_extr)
31386         break;
31387
31388       switch (elt)
31389         {
31390         case 0:
31391           tmp = vec;
31392           break;
31393
31394         case 1:
31395         case 3:
31396           tmp = gen_reg_rtx (mode);
31397           emit_insn (gen_sse_shufps_v4sf (tmp, vec, vec,
31398                                        GEN_INT (elt), GEN_INT (elt),
31399                                        GEN_INT (elt+4), GEN_INT (elt+4)));
31400           break;
31401
31402         case 2:
31403           tmp = gen_reg_rtx (mode);
31404           emit_insn (gen_vec_interleave_highv4sf (tmp, vec, vec));
31405           break;
31406
31407         default:
31408           gcc_unreachable ();
31409         }
31410       vec = tmp;
31411       use_vec_extr = true;
31412       elt = 0;
31413       break;
31414
31415     case V4SImode:
31416       use_vec_extr = TARGET_SSE4_1;
31417       if (use_vec_extr)
31418         break;
31419
31420       if (TARGET_SSE2)
31421         {
31422           switch (elt)
31423             {
31424             case 0:
31425               tmp = vec;
31426               break;
31427
31428             case 1:
31429             case 3:
31430               tmp = gen_reg_rtx (mode);
31431               emit_insn (gen_sse2_pshufd_1 (tmp, vec,
31432                                             GEN_INT (elt), GEN_INT (elt),
31433                                             GEN_INT (elt), GEN_INT (elt)));
31434               break;
31435
31436             case 2:
31437               tmp = gen_reg_rtx (mode);
31438               emit_insn (gen_vec_interleave_highv4si (tmp, vec, vec));
31439               break;
31440
31441             default:
31442               gcc_unreachable ();
31443             }
31444           vec = tmp;
31445           use_vec_extr = true;
31446           elt = 0;
31447         }
31448       else
31449         {
31450           /* For SSE1, we have to reuse the V4SF code.  */
31451           ix86_expand_vector_extract (false, gen_lowpart (SFmode, target),
31452                                       gen_lowpart (V4SFmode, vec), elt);
31453           return;
31454         }
31455       break;
31456
31457     case V8HImode:
31458       use_vec_extr = TARGET_SSE2;
31459       break;
31460     case V4HImode:
31461       use_vec_extr = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
31462       break;
31463
31464     case V16QImode:
31465       use_vec_extr = TARGET_SSE4_1;
31466       break;
31467
31468     case V8QImode:
31469       /* ??? Could extract the appropriate HImode element and shift.  */
31470     default:
31471       break;
31472     }
31473
31474   if (use_vec_extr)
31475     {
31476       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (elt)));
31477       tmp = gen_rtx_VEC_SELECT (inner_mode, vec, tmp);
31478
31479       /* Let the rtl optimizers know about the zero extension performed.  */
31480       if (inner_mode == QImode || inner_mode == HImode)
31481         {
31482           tmp = gen_rtx_ZERO_EXTEND (SImode, tmp);
31483           target = gen_lowpart (SImode, target);
31484         }
31485
31486       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
31487     }
31488   else
31489     {
31490       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
31491
31492       emit_move_insn (mem, vec);
31493
31494       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
31495       emit_move_insn (target, tmp);
31496     }
31497 }
31498
31499 /* Expand a vector reduction on V4SFmode for SSE1.  FN is the binary
31500    pattern to reduce; DEST is the destination; IN is the input vector.  */
31501
31502 void
31503 ix86_expand_reduc_v4sf (rtx (*fn) (rtx, rtx, rtx), rtx dest, rtx in)
31504 {
31505   rtx tmp1, tmp2, tmp3;
31506
31507   tmp1 = gen_reg_rtx (V4SFmode);
31508   tmp2 = gen_reg_rtx (V4SFmode);
31509   tmp3 = gen_reg_rtx (V4SFmode);
31510
31511   emit_insn (gen_sse_movhlps (tmp1, in, in));
31512   emit_insn (fn (tmp2, tmp1, in));
31513
31514   emit_insn (gen_sse_shufps_v4sf (tmp3, tmp2, tmp2,
31515                                   const1_rtx, const1_rtx,
31516                                   GEN_INT (1+4), GEN_INT (1+4)));
31517   emit_insn (fn (dest, tmp2, tmp3));
31518 }
31519 \f
31520 /* Target hook for scalar_mode_supported_p.  */
31521 static bool
31522 ix86_scalar_mode_supported_p (enum machine_mode mode)
31523 {
31524   if (DECIMAL_FLOAT_MODE_P (mode))
31525     return default_decimal_float_supported_p ();
31526   else if (mode == TFmode)
31527     return true;
31528   else
31529     return default_scalar_mode_supported_p (mode);
31530 }
31531
31532 /* Implements target hook vector_mode_supported_p.  */
31533 static bool
31534 ix86_vector_mode_supported_p (enum machine_mode mode)
31535 {
31536   if (TARGET_SSE && VALID_SSE_REG_MODE (mode))
31537     return true;
31538   if (TARGET_SSE2 && VALID_SSE2_REG_MODE (mode))
31539     return true;
31540   if (TARGET_AVX && VALID_AVX256_REG_MODE (mode))
31541     return true;
31542   if (TARGET_MMX && VALID_MMX_REG_MODE (mode))
31543     return true;
31544   if (TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW (mode))
31545     return true;
31546   return false;
31547 }
31548
31549 /* Target hook for c_mode_for_suffix.  */
31550 static enum machine_mode
31551 ix86_c_mode_for_suffix (char suffix)
31552 {
31553   if (suffix == 'q')
31554     return TFmode;
31555   if (suffix == 'w')
31556     return XFmode;
31557
31558   return VOIDmode;
31559 }
31560
31561 /* Worker function for TARGET_MD_ASM_CLOBBERS.
31562
31563    We do this in the new i386 backend to maintain source compatibility
31564    with the old cc0-based compiler.  */
31565
31566 static tree
31567 ix86_md_asm_clobbers (tree outputs ATTRIBUTE_UNUSED,
31568                       tree inputs ATTRIBUTE_UNUSED,
31569                       tree clobbers)
31570 {
31571   clobbers = tree_cons (NULL_TREE, build_string (5, "flags"),
31572                         clobbers);
31573   clobbers = tree_cons (NULL_TREE, build_string (4, "fpsr"),
31574                         clobbers);
31575   return clobbers;
31576 }
31577
31578 /* Implements target vector targetm.asm.encode_section_info.  */
31579
31580 static void ATTRIBUTE_UNUSED
31581 ix86_encode_section_info (tree decl, rtx rtl, int first)
31582 {
31583   default_encode_section_info (decl, rtl, first);
31584
31585   if (TREE_CODE (decl) == VAR_DECL
31586       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
31587       && ix86_in_large_data_p (decl))
31588     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_FAR_ADDR;
31589 }
31590
31591 /* Worker function for REVERSE_CONDITION.  */
31592
31593 enum rtx_code
31594 ix86_reverse_condition (enum rtx_code code, enum machine_mode mode)
31595 {
31596   return (mode != CCFPmode && mode != CCFPUmode
31597           ? reverse_condition (code)
31598           : reverse_condition_maybe_unordered (code));
31599 }
31600
31601 /* Output code to perform an x87 FP register move, from OPERANDS[1]
31602    to OPERANDS[0].  */
31603
31604 const char *
31605 output_387_reg_move (rtx insn, rtx *operands)
31606 {
31607   if (REG_P (operands[0]))
31608     {
31609       if (REG_P (operands[1])
31610           && find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
31611         {
31612           if (REGNO (operands[0]) == FIRST_STACK_REG)
31613             return output_387_ffreep (operands, 0);
31614           return "fstp\t%y0";
31615         }
31616       if (STACK_TOP_P (operands[0]))
31617         return "fld%Z1\t%y1";
31618       return "fst\t%y0";
31619     }
31620   else if (MEM_P (operands[0]))
31621     {
31622       gcc_assert (REG_P (operands[1]));
31623       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
31624         return "fstp%Z0\t%y0";
31625       else
31626         {
31627           /* There is no non-popping store to memory for XFmode.
31628              So if we need one, follow the store with a load.  */
31629           if (GET_MODE (operands[0]) == XFmode)
31630             return "fstp%Z0\t%y0\n\tfld%Z0\t%y0";
31631           else
31632             return "fst%Z0\t%y0";
31633         }
31634     }
31635   else
31636     gcc_unreachable();
31637 }
31638
31639 /* Output code to perform a conditional jump to LABEL, if C2 flag in
31640    FP status register is set.  */
31641
31642 void
31643 ix86_emit_fp_unordered_jump (rtx label)
31644 {
31645   rtx reg = gen_reg_rtx (HImode);
31646   rtx temp;
31647
31648   emit_insn (gen_x86_fnstsw_1 (reg));
31649
31650   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ()))
31651     {
31652       emit_insn (gen_x86_sahf_1 (reg));
31653
31654       temp = gen_rtx_REG (CCmode, FLAGS_REG);
31655       temp = gen_rtx_UNORDERED (VOIDmode, temp, const0_rtx);
31656     }
31657   else
31658     {
31659       emit_insn (gen_testqi_ext_ccno_0 (reg, GEN_INT (0x04)));
31660
31661       temp = gen_rtx_REG (CCNOmode, FLAGS_REG);
31662       temp = gen_rtx_NE (VOIDmode, temp, const0_rtx);
31663     }
31664
31665   temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
31666                               gen_rtx_LABEL_REF (VOIDmode, label),
31667                               pc_rtx);
31668   temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
31669
31670   emit_jump_insn (temp);
31671   predict_jump (REG_BR_PROB_BASE * 10 / 100);
31672 }
31673
31674 /* Output code to perform a log1p XFmode calculation.  */
31675
31676 void ix86_emit_i387_log1p (rtx op0, rtx op1)
31677 {
31678   rtx label1 = gen_label_rtx ();
31679   rtx label2 = gen_label_rtx ();
31680
31681   rtx tmp = gen_reg_rtx (XFmode);
31682   rtx tmp2 = gen_reg_rtx (XFmode);
31683   rtx test;
31684
31685   emit_insn (gen_absxf2 (tmp, op1));
31686   test = gen_rtx_GE (VOIDmode, tmp,
31687     CONST_DOUBLE_FROM_REAL_VALUE (
31688        REAL_VALUE_ATOF ("0.29289321881345247561810596348408353", XFmode),
31689        XFmode));
31690   emit_jump_insn (gen_cbranchxf4 (test, XEXP (test, 0), XEXP (test, 1), label1));
31691
31692   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
31693   emit_insn (gen_fyl2xp1xf3_i387 (op0, op1, tmp2));
31694   emit_jump (label2);
31695
31696   emit_label (label1);
31697   emit_move_insn (tmp, CONST1_RTX (XFmode));
31698   emit_insn (gen_addxf3 (tmp, op1, tmp));
31699   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
31700   emit_insn (gen_fyl2xxf3_i387 (op0, tmp, tmp2));
31701
31702   emit_label (label2);
31703 }
31704
31705 /* Output code to perform a Newton-Rhapson approximation of a single precision
31706    floating point divide [http://en.wikipedia.org/wiki/N-th_root_algorithm].  */
31707
31708 void ix86_emit_swdivsf (rtx res, rtx a, rtx b, enum machine_mode mode)
31709 {
31710   rtx x0, x1, e0, e1;
31711
31712   x0 = gen_reg_rtx (mode);
31713   e0 = gen_reg_rtx (mode);
31714   e1 = gen_reg_rtx (mode);
31715   x1 = gen_reg_rtx (mode);
31716
31717   /* a / b = a * ((rcp(b) + rcp(b)) - (b * rcp(b) * rcp (b))) */
31718
31719   /* x0 = rcp(b) estimate */
31720   emit_insn (gen_rtx_SET (VOIDmode, x0,
31721                           gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
31722                                           UNSPEC_RCP)));
31723   /* e0 = x0 * b */
31724   emit_insn (gen_rtx_SET (VOIDmode, e0,
31725                           gen_rtx_MULT (mode, x0, b)));
31726
31727   /* e0 = x0 * e0 */
31728   emit_insn (gen_rtx_SET (VOIDmode, e0,
31729                           gen_rtx_MULT (mode, x0, e0)));
31730
31731   /* e1 = x0 + x0 */
31732   emit_insn (gen_rtx_SET (VOIDmode, e1,
31733                           gen_rtx_PLUS (mode, x0, x0)));
31734
31735   /* x1 = e1 - e0 */
31736   emit_insn (gen_rtx_SET (VOIDmode, x1,
31737                           gen_rtx_MINUS (mode, e1, e0)));
31738
31739   /* res = a * x1 */
31740   emit_insn (gen_rtx_SET (VOIDmode, res,
31741                           gen_rtx_MULT (mode, a, x1)));
31742 }
31743
31744 /* Output code to perform a Newton-Rhapson approximation of a
31745    single precision floating point [reciprocal] square root.  */
31746
31747 void ix86_emit_swsqrtsf (rtx res, rtx a, enum machine_mode mode,
31748                          bool recip)
31749 {
31750   rtx x0, e0, e1, e2, e3, mthree, mhalf;
31751   REAL_VALUE_TYPE r;
31752
31753   x0 = gen_reg_rtx (mode);
31754   e0 = gen_reg_rtx (mode);
31755   e1 = gen_reg_rtx (mode);
31756   e2 = gen_reg_rtx (mode);
31757   e3 = gen_reg_rtx (mode);
31758
31759   real_from_integer (&r, VOIDmode, -3, -1, 0);
31760   mthree = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
31761
31762   real_arithmetic (&r, NEGATE_EXPR, &dconsthalf, NULL);
31763   mhalf = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
31764
31765   if (VECTOR_MODE_P (mode))
31766     {
31767       mthree = ix86_build_const_vector (mode, true, mthree);
31768       mhalf = ix86_build_const_vector (mode, true, mhalf);
31769     }
31770
31771   /* sqrt(a)  = -0.5 * a * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0)
31772      rsqrt(a) = -0.5     * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0) */
31773
31774   /* x0 = rsqrt(a) estimate */
31775   emit_insn (gen_rtx_SET (VOIDmode, x0,
31776                           gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
31777                                           UNSPEC_RSQRT)));
31778
31779   /* If (a == 0.0) Filter out infinity to prevent NaN for sqrt(0.0).  */
31780   if (!recip)
31781     {
31782       rtx zero, mask;
31783
31784       zero = gen_reg_rtx (mode);
31785       mask = gen_reg_rtx (mode);
31786
31787       zero = force_reg (mode, CONST0_RTX(mode));
31788       emit_insn (gen_rtx_SET (VOIDmode, mask,
31789                               gen_rtx_NE (mode, zero, a)));
31790
31791       emit_insn (gen_rtx_SET (VOIDmode, x0,
31792                               gen_rtx_AND (mode, x0, mask)));
31793     }
31794
31795   /* e0 = x0 * a */
31796   emit_insn (gen_rtx_SET (VOIDmode, e0,
31797                           gen_rtx_MULT (mode, x0, a)));
31798   /* e1 = e0 * x0 */
31799   emit_insn (gen_rtx_SET (VOIDmode, e1,
31800                           gen_rtx_MULT (mode, e0, x0)));
31801
31802   /* e2 = e1 - 3. */
31803   mthree = force_reg (mode, mthree);
31804   emit_insn (gen_rtx_SET (VOIDmode, e2,
31805                           gen_rtx_PLUS (mode, e1, mthree)));
31806
31807   mhalf = force_reg (mode, mhalf);
31808   if (recip)
31809     /* e3 = -.5 * x0 */
31810     emit_insn (gen_rtx_SET (VOIDmode, e3,
31811                             gen_rtx_MULT (mode, x0, mhalf)));
31812   else
31813     /* e3 = -.5 * e0 */
31814     emit_insn (gen_rtx_SET (VOIDmode, e3,
31815                             gen_rtx_MULT (mode, e0, mhalf)));
31816   /* ret = e2 * e3 */
31817   emit_insn (gen_rtx_SET (VOIDmode, res,
31818                           gen_rtx_MULT (mode, e2, e3)));
31819 }
31820
31821 #ifdef TARGET_SOLARIS
31822 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
31823
31824 static void
31825 i386_solaris_elf_named_section (const char *name, unsigned int flags,
31826                                 tree decl)
31827 {
31828   /* With Binutils 2.15, the "@unwind" marker must be specified on
31829      every occurrence of the ".eh_frame" section, not just the first
31830      one.  */
31831   if (TARGET_64BIT
31832       && strcmp (name, ".eh_frame") == 0)
31833     {
31834       fprintf (asm_out_file, "\t.section\t%s,\"%s\",@unwind\n", name,
31835                flags & SECTION_WRITE ? "aw" : "a");
31836       return;
31837     }
31838
31839 #ifndef USE_GAS
31840   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
31841     {
31842       solaris_elf_asm_comdat_section (name, flags, decl);
31843       return;
31844     }
31845 #endif
31846
31847   default_elf_asm_named_section (name, flags, decl);
31848 }
31849 #endif /* TARGET_SOLARIS */
31850
31851 /* Return the mangling of TYPE if it is an extended fundamental type.  */
31852
31853 static const char *
31854 ix86_mangle_type (const_tree type)
31855 {
31856   type = TYPE_MAIN_VARIANT (type);
31857
31858   if (TREE_CODE (type) != VOID_TYPE && TREE_CODE (type) != BOOLEAN_TYPE
31859       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
31860     return NULL;
31861
31862   switch (TYPE_MODE (type))
31863     {
31864     case TFmode:
31865       /* __float128 is "g".  */
31866       return "g";
31867     case XFmode:
31868       /* "long double" or __float80 is "e".  */
31869       return "e";
31870     default:
31871       return NULL;
31872     }
31873 }
31874
31875 /* For 32-bit code we can save PIC register setup by using
31876    __stack_chk_fail_local hidden function instead of calling
31877    __stack_chk_fail directly.  64-bit code doesn't need to setup any PIC
31878    register, so it is better to call __stack_chk_fail directly.  */
31879
31880 static tree ATTRIBUTE_UNUSED
31881 ix86_stack_protect_fail (void)
31882 {
31883   return TARGET_64BIT
31884          ? default_external_stack_protect_fail ()
31885          : default_hidden_stack_protect_fail ();
31886 }
31887
31888 /* Select a format to encode pointers in exception handling data.  CODE
31889    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
31890    true if the symbol may be affected by dynamic relocations.
31891
31892    ??? All x86 object file formats are capable of representing this.
31893    After all, the relocation needed is the same as for the call insn.
31894    Whether or not a particular assembler allows us to enter such, I
31895    guess we'll have to see.  */
31896 int
31897 asm_preferred_eh_data_format (int code, int global)
31898 {
31899   if (flag_pic)
31900     {
31901       int type = DW_EH_PE_sdata8;
31902       if (!TARGET_64BIT
31903           || ix86_cmodel == CM_SMALL_PIC
31904           || (ix86_cmodel == CM_MEDIUM_PIC && (global || code)))
31905         type = DW_EH_PE_sdata4;
31906       return (global ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | type;
31907     }
31908   if (ix86_cmodel == CM_SMALL
31909       || (ix86_cmodel == CM_MEDIUM && code))
31910     return DW_EH_PE_udata4;
31911   return DW_EH_PE_absptr;
31912 }
31913 \f
31914 /* Expand copysign from SIGN to the positive value ABS_VALUE
31915    storing in RESULT.  If MASK is non-null, it shall be a mask to mask out
31916    the sign-bit.  */
31917 static void
31918 ix86_sse_copysign_to_positive (rtx result, rtx abs_value, rtx sign, rtx mask)
31919 {
31920   enum machine_mode mode = GET_MODE (sign);
31921   rtx sgn = gen_reg_rtx (mode);
31922   if (mask == NULL_RTX)
31923     {
31924       enum machine_mode vmode;
31925
31926       if (mode == SFmode)
31927         vmode = V4SFmode;
31928       else if (mode == DFmode)
31929         vmode = V2DFmode;
31930       else
31931         vmode = mode;
31932
31933       mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), false);
31934       if (!VECTOR_MODE_P (mode))
31935         {
31936           /* We need to generate a scalar mode mask in this case.  */
31937           rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
31938           tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
31939           mask = gen_reg_rtx (mode);
31940           emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
31941         }
31942     }
31943   else
31944     mask = gen_rtx_NOT (mode, mask);
31945   emit_insn (gen_rtx_SET (VOIDmode, sgn,
31946                           gen_rtx_AND (mode, mask, sign)));
31947   emit_insn (gen_rtx_SET (VOIDmode, result,
31948                           gen_rtx_IOR (mode, abs_value, sgn)));
31949 }
31950
31951 /* Expand fabs (OP0) and return a new rtx that holds the result.  The
31952    mask for masking out the sign-bit is stored in *SMASK, if that is
31953    non-null.  */
31954 static rtx
31955 ix86_expand_sse_fabs (rtx op0, rtx *smask)
31956 {
31957   enum machine_mode vmode, mode = GET_MODE (op0);
31958   rtx xa, mask;
31959
31960   xa = gen_reg_rtx (mode);
31961   if (mode == SFmode)
31962     vmode = V4SFmode;
31963   else if (mode == DFmode)
31964     vmode = V2DFmode;
31965   else
31966     vmode = mode;
31967   mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), true);
31968   if (!VECTOR_MODE_P (mode))
31969     {
31970       /* We need to generate a scalar mode mask in this case.  */
31971       rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
31972       tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
31973       mask = gen_reg_rtx (mode);
31974       emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
31975     }
31976   emit_insn (gen_rtx_SET (VOIDmode, xa,
31977                           gen_rtx_AND (mode, op0, mask)));
31978
31979   if (smask)
31980     *smask = mask;
31981
31982   return xa;
31983 }
31984
31985 /* Expands a comparison of OP0 with OP1 using comparison code CODE,
31986    swapping the operands if SWAP_OPERANDS is true.  The expanded
31987    code is a forward jump to a newly created label in case the
31988    comparison is true.  The generated label rtx is returned.  */
31989 static rtx
31990 ix86_expand_sse_compare_and_jump (enum rtx_code code, rtx op0, rtx op1,
31991                                   bool swap_operands)
31992 {
31993   rtx label, tmp;
31994
31995   if (swap_operands)
31996     {
31997       tmp = op0;
31998       op0 = op1;
31999       op1 = tmp;
32000     }
32001
32002   label = gen_label_rtx ();
32003   tmp = gen_rtx_REG (CCFPUmode, FLAGS_REG);
32004   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32005                           gen_rtx_COMPARE (CCFPUmode, op0, op1)));
32006   tmp = gen_rtx_fmt_ee (code, VOIDmode, tmp, const0_rtx);
32007   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
32008                               gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
32009   tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
32010   JUMP_LABEL (tmp) = label;
32011
32012   return label;
32013 }
32014
32015 /* Expand a mask generating SSE comparison instruction comparing OP0 with OP1
32016    using comparison code CODE.  Operands are swapped for the comparison if
32017    SWAP_OPERANDS is true.  Returns a rtx for the generated mask.  */
32018 static rtx
32019 ix86_expand_sse_compare_mask (enum rtx_code code, rtx op0, rtx op1,
32020                               bool swap_operands)
32021 {
32022   rtx (*insn)(rtx, rtx, rtx, rtx);
32023   enum machine_mode mode = GET_MODE (op0);
32024   rtx mask = gen_reg_rtx (mode);
32025
32026   if (swap_operands)
32027     {
32028       rtx tmp = op0;
32029       op0 = op1;
32030       op1 = tmp;
32031     }
32032
32033   insn = mode == DFmode ? gen_setcc_df_sse : gen_setcc_sf_sse;
32034
32035   emit_insn (insn (mask, op0, op1,
32036                    gen_rtx_fmt_ee (code, mode, op0, op1)));
32037   return mask;
32038 }
32039
32040 /* Generate and return a rtx of mode MODE for 2**n where n is the number
32041    of bits of the mantissa of MODE, which must be one of DFmode or SFmode.  */
32042 static rtx
32043 ix86_gen_TWO52 (enum machine_mode mode)
32044 {
32045   REAL_VALUE_TYPE TWO52r;
32046   rtx TWO52;
32047
32048   real_ldexp (&TWO52r, &dconst1, mode == DFmode ? 52 : 23);
32049   TWO52 = const_double_from_real_value (TWO52r, mode);
32050   TWO52 = force_reg (mode, TWO52);
32051
32052   return TWO52;
32053 }
32054
32055 /* Expand SSE sequence for computing lround from OP1 storing
32056    into OP0.  */
32057 void
32058 ix86_expand_lround (rtx op0, rtx op1)
32059 {
32060   /* C code for the stuff we're doing below:
32061        tmp = op1 + copysign (nextafter (0.5, 0.0), op1)
32062        return (long)tmp;
32063    */
32064   enum machine_mode mode = GET_MODE (op1);
32065   const struct real_format *fmt;
32066   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
32067   rtx adj;
32068
32069   /* load nextafter (0.5, 0.0) */
32070   fmt = REAL_MODE_FORMAT (mode);
32071   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
32072   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
32073
32074   /* adj = copysign (0.5, op1) */
32075   adj = force_reg (mode, const_double_from_real_value (pred_half, mode));
32076   ix86_sse_copysign_to_positive (adj, adj, force_reg (mode, op1), NULL_RTX);
32077
32078   /* adj = op1 + adj */
32079   adj = expand_simple_binop (mode, PLUS, adj, op1, NULL_RTX, 0, OPTAB_DIRECT);
32080
32081   /* op0 = (imode)adj */
32082   expand_fix (op0, adj, 0);
32083 }
32084
32085 /* Expand SSE2 sequence for computing lround from OPERAND1 storing
32086    into OPERAND0.  */
32087 void
32088 ix86_expand_lfloorceil (rtx op0, rtx op1, bool do_floor)
32089 {
32090   /* C code for the stuff we're doing below (for do_floor):
32091         xi = (long)op1;
32092         xi -= (double)xi > op1 ? 1 : 0;
32093         return xi;
32094    */
32095   enum machine_mode fmode = GET_MODE (op1);
32096   enum machine_mode imode = GET_MODE (op0);
32097   rtx ireg, freg, label, tmp;
32098
32099   /* reg = (long)op1 */
32100   ireg = gen_reg_rtx (imode);
32101   expand_fix (ireg, op1, 0);
32102
32103   /* freg = (double)reg */
32104   freg = gen_reg_rtx (fmode);
32105   expand_float (freg, ireg, 0);
32106
32107   /* ireg = (freg > op1) ? ireg - 1 : ireg */
32108   label = ix86_expand_sse_compare_and_jump (UNLE,
32109                                             freg, op1, !do_floor);
32110   tmp = expand_simple_binop (imode, do_floor ? MINUS : PLUS,
32111                              ireg, const1_rtx, NULL_RTX, 0, OPTAB_DIRECT);
32112   emit_move_insn (ireg, tmp);
32113
32114   emit_label (label);
32115   LABEL_NUSES (label) = 1;
32116
32117   emit_move_insn (op0, ireg);
32118 }
32119
32120 /* Expand rint (IEEE round to nearest) rounding OPERAND1 and storing the
32121    result in OPERAND0.  */
32122 void
32123 ix86_expand_rint (rtx operand0, rtx operand1)
32124 {
32125   /* C code for the stuff we're doing below:
32126         xa = fabs (operand1);
32127         if (!isless (xa, 2**52))
32128           return operand1;
32129         xa = xa + 2**52 - 2**52;
32130         return copysign (xa, operand1);
32131    */
32132   enum machine_mode mode = GET_MODE (operand0);
32133   rtx res, xa, label, TWO52, mask;
32134
32135   res = gen_reg_rtx (mode);
32136   emit_move_insn (res, operand1);
32137
32138   /* xa = abs (operand1) */
32139   xa = ix86_expand_sse_fabs (res, &mask);
32140
32141   /* if (!isless (xa, TWO52)) goto label; */
32142   TWO52 = ix86_gen_TWO52 (mode);
32143   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32144
32145   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32146   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
32147
32148   ix86_sse_copysign_to_positive (res, xa, res, mask);
32149
32150   emit_label (label);
32151   LABEL_NUSES (label) = 1;
32152
32153   emit_move_insn (operand0, res);
32154 }
32155
32156 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
32157    into OPERAND0.  */
32158 void
32159 ix86_expand_floorceildf_32 (rtx operand0, rtx operand1, bool do_floor)
32160 {
32161   /* C code for the stuff we expand below.
32162         double xa = fabs (x), x2;
32163         if (!isless (xa, TWO52))
32164           return x;
32165         xa = xa + TWO52 - TWO52;
32166         x2 = copysign (xa, x);
32167      Compensate.  Floor:
32168         if (x2 > x)
32169           x2 -= 1;
32170      Compensate.  Ceil:
32171         if (x2 < x)
32172           x2 -= -1;
32173         return x2;
32174    */
32175   enum machine_mode mode = GET_MODE (operand0);
32176   rtx xa, TWO52, tmp, label, one, res, mask;
32177
32178   TWO52 = ix86_gen_TWO52 (mode);
32179
32180   /* Temporary for holding the result, initialized to the input
32181      operand to ease control flow.  */
32182   res = gen_reg_rtx (mode);
32183   emit_move_insn (res, operand1);
32184
32185   /* xa = abs (operand1) */
32186   xa = ix86_expand_sse_fabs (res, &mask);
32187
32188   /* if (!isless (xa, TWO52)) goto label; */
32189   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32190
32191   /* xa = xa + TWO52 - TWO52; */
32192   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32193   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
32194
32195   /* xa = copysign (xa, operand1) */
32196   ix86_sse_copysign_to_positive (xa, xa, res, mask);
32197
32198   /* generate 1.0 or -1.0 */
32199   one = force_reg (mode,
32200                    const_double_from_real_value (do_floor
32201                                                  ? dconst1 : dconstm1, mode));
32202
32203   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
32204   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
32205   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32206                           gen_rtx_AND (mode, one, tmp)));
32207   /* We always need to subtract here to preserve signed zero.  */
32208   tmp = expand_simple_binop (mode, MINUS,
32209                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32210   emit_move_insn (res, tmp);
32211
32212   emit_label (label);
32213   LABEL_NUSES (label) = 1;
32214
32215   emit_move_insn (operand0, res);
32216 }
32217
32218 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
32219    into OPERAND0.  */
32220 void
32221 ix86_expand_floorceil (rtx operand0, rtx operand1, bool do_floor)
32222 {
32223   /* C code for the stuff we expand below.
32224         double xa = fabs (x), x2;
32225         if (!isless (xa, TWO52))
32226           return x;
32227         x2 = (double)(long)x;
32228      Compensate.  Floor:
32229         if (x2 > x)
32230           x2 -= 1;
32231      Compensate.  Ceil:
32232         if (x2 < x)
32233           x2 += 1;
32234         if (HONOR_SIGNED_ZEROS (mode))
32235           return copysign (x2, x);
32236         return x2;
32237    */
32238   enum machine_mode mode = GET_MODE (operand0);
32239   rtx xa, xi, TWO52, tmp, label, one, res, mask;
32240
32241   TWO52 = ix86_gen_TWO52 (mode);
32242
32243   /* Temporary for holding the result, initialized to the input
32244      operand to ease control flow.  */
32245   res = gen_reg_rtx (mode);
32246   emit_move_insn (res, operand1);
32247
32248   /* xa = abs (operand1) */
32249   xa = ix86_expand_sse_fabs (res, &mask);
32250
32251   /* if (!isless (xa, TWO52)) goto label; */
32252   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32253
32254   /* xa = (double)(long)x */
32255   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32256   expand_fix (xi, res, 0);
32257   expand_float (xa, xi, 0);
32258
32259   /* generate 1.0 */
32260   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
32261
32262   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
32263   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
32264   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32265                           gen_rtx_AND (mode, one, tmp)));
32266   tmp = expand_simple_binop (mode, do_floor ? MINUS : PLUS,
32267                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32268   emit_move_insn (res, tmp);
32269
32270   if (HONOR_SIGNED_ZEROS (mode))
32271     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
32272
32273   emit_label (label);
32274   LABEL_NUSES (label) = 1;
32275
32276   emit_move_insn (operand0, res);
32277 }
32278
32279 /* Expand SSE sequence for computing round from OPERAND1 storing
32280    into OPERAND0.  Sequence that works without relying on DImode truncation
32281    via cvttsd2siq that is only available on 64bit targets.  */
32282 void
32283 ix86_expand_rounddf_32 (rtx operand0, rtx operand1)
32284 {
32285   /* C code for the stuff we expand below.
32286         double xa = fabs (x), xa2, x2;
32287         if (!isless (xa, TWO52))
32288           return x;
32289      Using the absolute value and copying back sign makes
32290      -0.0 -> -0.0 correct.
32291         xa2 = xa + TWO52 - TWO52;
32292      Compensate.
32293         dxa = xa2 - xa;
32294         if (dxa <= -0.5)
32295           xa2 += 1;
32296         else if (dxa > 0.5)
32297           xa2 -= 1;
32298         x2 = copysign (xa2, x);
32299         return x2;
32300    */
32301   enum machine_mode mode = GET_MODE (operand0);
32302   rtx xa, xa2, dxa, TWO52, tmp, label, half, mhalf, one, res, mask;
32303
32304   TWO52 = ix86_gen_TWO52 (mode);
32305
32306   /* Temporary for holding the result, initialized to the input
32307      operand to ease control flow.  */
32308   res = gen_reg_rtx (mode);
32309   emit_move_insn (res, operand1);
32310
32311   /* xa = abs (operand1) */
32312   xa = ix86_expand_sse_fabs (res, &mask);
32313
32314   /* if (!isless (xa, TWO52)) goto label; */
32315   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32316
32317   /* xa2 = xa + TWO52 - TWO52; */
32318   xa2 = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32319   xa2 = expand_simple_binop (mode, MINUS, xa2, TWO52, xa2, 0, OPTAB_DIRECT);
32320
32321   /* dxa = xa2 - xa; */
32322   dxa = expand_simple_binop (mode, MINUS, xa2, xa, NULL_RTX, 0, OPTAB_DIRECT);
32323
32324   /* generate 0.5, 1.0 and -0.5 */
32325   half = force_reg (mode, const_double_from_real_value (dconsthalf, mode));
32326   one = expand_simple_binop (mode, PLUS, half, half, NULL_RTX, 0, OPTAB_DIRECT);
32327   mhalf = expand_simple_binop (mode, MINUS, half, one, NULL_RTX,
32328                                0, OPTAB_DIRECT);
32329
32330   /* Compensate.  */
32331   tmp = gen_reg_rtx (mode);
32332   /* xa2 = xa2 - (dxa > 0.5 ? 1 : 0) */
32333   tmp = ix86_expand_sse_compare_mask (UNGT, dxa, half, false);
32334   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32335                           gen_rtx_AND (mode, one, tmp)));
32336   xa2 = expand_simple_binop (mode, MINUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32337   /* xa2 = xa2 + (dxa <= -0.5 ? 1 : 0) */
32338   tmp = ix86_expand_sse_compare_mask (UNGE, mhalf, dxa, false);
32339   emit_insn (gen_rtx_SET (VOIDmode, tmp,
32340                           gen_rtx_AND (mode, one, tmp)));
32341   xa2 = expand_simple_binop (mode, PLUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
32342
32343   /* res = copysign (xa2, operand1) */
32344   ix86_sse_copysign_to_positive (res, xa2, force_reg (mode, operand1), mask);
32345
32346   emit_label (label);
32347   LABEL_NUSES (label) = 1;
32348
32349   emit_move_insn (operand0, res);
32350 }
32351
32352 /* Expand SSE sequence for computing trunc from OPERAND1 storing
32353    into OPERAND0.  */
32354 void
32355 ix86_expand_trunc (rtx operand0, rtx operand1)
32356 {
32357   /* C code for SSE variant we expand below.
32358         double xa = fabs (x), x2;
32359         if (!isless (xa, TWO52))
32360           return x;
32361         x2 = (double)(long)x;
32362         if (HONOR_SIGNED_ZEROS (mode))
32363           return copysign (x2, x);
32364         return x2;
32365    */
32366   enum machine_mode mode = GET_MODE (operand0);
32367   rtx xa, xi, TWO52, label, res, mask;
32368
32369   TWO52 = ix86_gen_TWO52 (mode);
32370
32371   /* Temporary for holding the result, initialized to the input
32372      operand to ease control flow.  */
32373   res = gen_reg_rtx (mode);
32374   emit_move_insn (res, operand1);
32375
32376   /* xa = abs (operand1) */
32377   xa = ix86_expand_sse_fabs (res, &mask);
32378
32379   /* if (!isless (xa, TWO52)) goto label; */
32380   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32381
32382   /* x = (double)(long)x */
32383   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32384   expand_fix (xi, res, 0);
32385   expand_float (res, xi, 0);
32386
32387   if (HONOR_SIGNED_ZEROS (mode))
32388     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
32389
32390   emit_label (label);
32391   LABEL_NUSES (label) = 1;
32392
32393   emit_move_insn (operand0, res);
32394 }
32395
32396 /* Expand SSE sequence for computing trunc from OPERAND1 storing
32397    into OPERAND0.  */
32398 void
32399 ix86_expand_truncdf_32 (rtx operand0, rtx operand1)
32400 {
32401   enum machine_mode mode = GET_MODE (operand0);
32402   rtx xa, mask, TWO52, label, one, res, smask, tmp;
32403
32404   /* C code for SSE variant we expand below.
32405         double xa = fabs (x), x2;
32406         if (!isless (xa, TWO52))
32407           return x;
32408         xa2 = xa + TWO52 - TWO52;
32409      Compensate:
32410         if (xa2 > xa)
32411           xa2 -= 1.0;
32412         x2 = copysign (xa2, x);
32413         return x2;
32414    */
32415
32416   TWO52 = ix86_gen_TWO52 (mode);
32417
32418   /* Temporary for holding the result, initialized to the input
32419      operand to ease control flow.  */
32420   res = gen_reg_rtx (mode);
32421   emit_move_insn (res, operand1);
32422
32423   /* xa = abs (operand1) */
32424   xa = ix86_expand_sse_fabs (res, &smask);
32425
32426   /* if (!isless (xa, TWO52)) goto label; */
32427   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32428
32429   /* res = xa + TWO52 - TWO52; */
32430   tmp = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
32431   tmp = expand_simple_binop (mode, MINUS, tmp, TWO52, tmp, 0, OPTAB_DIRECT);
32432   emit_move_insn (res, tmp);
32433
32434   /* generate 1.0 */
32435   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
32436
32437   /* Compensate: res = xa2 - (res > xa ? 1 : 0)  */
32438   mask = ix86_expand_sse_compare_mask (UNGT, res, xa, false);
32439   emit_insn (gen_rtx_SET (VOIDmode, mask,
32440                           gen_rtx_AND (mode, mask, one)));
32441   tmp = expand_simple_binop (mode, MINUS,
32442                              res, mask, NULL_RTX, 0, OPTAB_DIRECT);
32443   emit_move_insn (res, tmp);
32444
32445   /* res = copysign (res, operand1) */
32446   ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), smask);
32447
32448   emit_label (label);
32449   LABEL_NUSES (label) = 1;
32450
32451   emit_move_insn (operand0, res);
32452 }
32453
32454 /* Expand SSE sequence for computing round from OPERAND1 storing
32455    into OPERAND0.  */
32456 void
32457 ix86_expand_round (rtx operand0, rtx operand1)
32458 {
32459   /* C code for the stuff we're doing below:
32460         double xa = fabs (x);
32461         if (!isless (xa, TWO52))
32462           return x;
32463         xa = (double)(long)(xa + nextafter (0.5, 0.0));
32464         return copysign (xa, x);
32465    */
32466   enum machine_mode mode = GET_MODE (operand0);
32467   rtx res, TWO52, xa, label, xi, half, mask;
32468   const struct real_format *fmt;
32469   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
32470
32471   /* Temporary for holding the result, initialized to the input
32472      operand to ease control flow.  */
32473   res = gen_reg_rtx (mode);
32474   emit_move_insn (res, operand1);
32475
32476   TWO52 = ix86_gen_TWO52 (mode);
32477   xa = ix86_expand_sse_fabs (res, &mask);
32478   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
32479
32480   /* load nextafter (0.5, 0.0) */
32481   fmt = REAL_MODE_FORMAT (mode);
32482   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
32483   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
32484
32485   /* xa = xa + 0.5 */
32486   half = force_reg (mode, const_double_from_real_value (pred_half, mode));
32487   xa = expand_simple_binop (mode, PLUS, xa, half, NULL_RTX, 0, OPTAB_DIRECT);
32488
32489   /* xa = (double)(int64_t)xa */
32490   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
32491   expand_fix (xi, xa, 0);
32492   expand_float (xa, xi, 0);
32493
32494   /* res = copysign (xa, operand1) */
32495   ix86_sse_copysign_to_positive (res, xa, force_reg (mode, operand1), mask);
32496
32497   emit_label (label);
32498   LABEL_NUSES (label) = 1;
32499
32500   emit_move_insn (operand0, res);
32501 }
32502 \f
32503
32504 /* Table of valid machine attributes.  */
32505 static const struct attribute_spec ix86_attribute_table[] =
32506 {
32507   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
32508        affects_type_identity } */
32509   /* Stdcall attribute says callee is responsible for popping arguments
32510      if they are not variable.  */
32511   { "stdcall",   0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32512     true },
32513   /* Fastcall attribute says callee is responsible for popping arguments
32514      if they are not variable.  */
32515   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32516     true },
32517   /* Thiscall attribute says callee is responsible for popping arguments
32518      if they are not variable.  */
32519   { "thiscall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32520     true },
32521   /* Cdecl attribute says the callee is a normal C declaration */
32522   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute,
32523     true },
32524   /* Regparm attribute specifies how many integer arguments are to be
32525      passed in registers.  */
32526   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute,
32527     true },
32528   /* Sseregparm attribute says we are using x86_64 calling conventions
32529      for FP arguments.  */
32530   { "sseregparm", 0, 0, false, true, true, ix86_handle_cconv_attribute,
32531     true },
32532   /* force_align_arg_pointer says this function realigns the stack at entry.  */
32533   { (const char *)&ix86_force_align_arg_pointer_string, 0, 0,
32534     false, true,  true, ix86_handle_cconv_attribute, false },
32535 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
32536   { "dllimport", 0, 0, false, false, false, handle_dll_attribute, false },
32537   { "dllexport", 0, 0, false, false, false, handle_dll_attribute, false },
32538   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute,
32539     false },
32540 #endif
32541   { "ms_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
32542     false },
32543   { "gcc_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
32544     false },
32545 #ifdef SUBTARGET_ATTRIBUTE_TABLE
32546   SUBTARGET_ATTRIBUTE_TABLE,
32547 #endif
32548   /* ms_abi and sysv_abi calling convention function attributes.  */
32549   { "ms_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
32550   { "sysv_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
32551   { "ms_hook_prologue", 0, 0, true, false, false, ix86_handle_fndecl_attribute,
32552     false },
32553   { "callee_pop_aggregate_return", 1, 1, false, true, true,
32554     ix86_handle_callee_pop_aggregate_return, true },
32555   /* End element.  */
32556   { NULL,        0, 0, false, false, false, NULL, false }
32557 };
32558
32559 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
32560 static int
32561 ix86_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
32562                                  tree vectype ATTRIBUTE_UNUSED,
32563                                  int misalign ATTRIBUTE_UNUSED)
32564 {
32565   switch (type_of_cost)
32566     {
32567       case scalar_stmt:
32568         return ix86_cost->scalar_stmt_cost;
32569
32570       case scalar_load:
32571         return ix86_cost->scalar_load_cost;
32572
32573       case scalar_store:
32574         return ix86_cost->scalar_store_cost;
32575
32576       case vector_stmt:
32577         return ix86_cost->vec_stmt_cost;
32578
32579       case vector_load:
32580         return ix86_cost->vec_align_load_cost;
32581
32582       case vector_store:
32583         return ix86_cost->vec_store_cost;
32584
32585       case vec_to_scalar:
32586         return ix86_cost->vec_to_scalar_cost;
32587
32588       case scalar_to_vec:
32589         return ix86_cost->scalar_to_vec_cost;
32590
32591       case unaligned_load:
32592       case unaligned_store:
32593         return ix86_cost->vec_unalign_load_cost;
32594
32595       case cond_branch_taken:
32596         return ix86_cost->cond_taken_branch_cost;
32597
32598       case cond_branch_not_taken:
32599         return ix86_cost->cond_not_taken_branch_cost;
32600
32601       case vec_perm:
32602         return 1;
32603
32604       default:
32605         gcc_unreachable ();
32606     }
32607 }
32608
32609
32610 /* Implement targetm.vectorize.builtin_vec_perm.  */
32611
32612 static tree
32613 ix86_vectorize_builtin_vec_perm (tree vec_type, tree *mask_type)
32614 {
32615   tree itype = TREE_TYPE (vec_type);
32616   bool u = TYPE_UNSIGNED (itype);
32617   enum machine_mode vmode = TYPE_MODE (vec_type);
32618   enum ix86_builtins fcode;
32619   bool ok = TARGET_SSE2;
32620
32621   switch (vmode)
32622     {
32623     case V4DFmode:
32624       ok = TARGET_AVX;
32625       fcode = IX86_BUILTIN_VEC_PERM_V4DF;
32626       goto get_di;
32627     case V2DFmode:
32628       fcode = IX86_BUILTIN_VEC_PERM_V2DF;
32629     get_di:
32630       itype = ix86_get_builtin_type (IX86_BT_DI);
32631       break;
32632
32633     case V8SFmode:
32634       ok = TARGET_AVX;
32635       fcode = IX86_BUILTIN_VEC_PERM_V8SF;
32636       goto get_si;
32637     case V4SFmode:
32638       ok = TARGET_SSE;
32639       fcode = IX86_BUILTIN_VEC_PERM_V4SF;
32640     get_si:
32641       itype = ix86_get_builtin_type (IX86_BT_SI);
32642       break;
32643
32644     case V2DImode:
32645       fcode = u ? IX86_BUILTIN_VEC_PERM_V2DI_U : IX86_BUILTIN_VEC_PERM_V2DI;
32646       break;
32647     case V4SImode:
32648       fcode = u ? IX86_BUILTIN_VEC_PERM_V4SI_U : IX86_BUILTIN_VEC_PERM_V4SI;
32649       break;
32650     case V8HImode:
32651       fcode = u ? IX86_BUILTIN_VEC_PERM_V8HI_U : IX86_BUILTIN_VEC_PERM_V8HI;
32652       break;
32653     case V16QImode:
32654       fcode = u ? IX86_BUILTIN_VEC_PERM_V16QI_U : IX86_BUILTIN_VEC_PERM_V16QI;
32655       break;
32656     default:
32657       ok = false;
32658       break;
32659     }
32660
32661   if (!ok)
32662     return NULL_TREE;
32663
32664   *mask_type = itype;
32665   return ix86_builtins[(int) fcode];
32666 }
32667
32668 /* Return a vector mode with twice as many elements as VMODE.  */
32669 /* ??? Consider moving this to a table generated by genmodes.c.  */
32670
32671 static enum machine_mode
32672 doublesize_vector_mode (enum machine_mode vmode)
32673 {
32674   switch (vmode)
32675     {
32676     case V2SFmode:      return V4SFmode;
32677     case V1DImode:      return V2DImode;
32678     case V2SImode:      return V4SImode;
32679     case V4HImode:      return V8HImode;
32680     case V8QImode:      return V16QImode;
32681
32682     case V2DFmode:      return V4DFmode;
32683     case V4SFmode:      return V8SFmode;
32684     case V2DImode:      return V4DImode;
32685     case V4SImode:      return V8SImode;
32686     case V8HImode:      return V16HImode;
32687     case V16QImode:     return V32QImode;
32688
32689     case V4DFmode:      return V8DFmode;
32690     case V8SFmode:      return V16SFmode;
32691     case V4DImode:      return V8DImode;
32692     case V8SImode:      return V16SImode;
32693     case V16HImode:     return V32HImode;
32694     case V32QImode:     return V64QImode;
32695
32696     default:
32697       gcc_unreachable ();
32698     }
32699 }
32700
32701 /* Construct (set target (vec_select op0 (parallel perm))) and
32702    return true if that's a valid instruction in the active ISA.  */
32703
32704 static bool
32705 expand_vselect (rtx target, rtx op0, const unsigned char *perm, unsigned nelt)
32706 {
32707   rtx rperm[MAX_VECT_LEN], x;
32708   unsigned i;
32709
32710   for (i = 0; i < nelt; ++i)
32711     rperm[i] = GEN_INT (perm[i]);
32712
32713   x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
32714   x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
32715   x = gen_rtx_SET (VOIDmode, target, x);
32716
32717   x = emit_insn (x);
32718   if (recog_memoized (x) < 0)
32719     {
32720       remove_insn (x);
32721       return false;
32722     }
32723   return true;
32724 }
32725
32726 /* Similar, but generate a vec_concat from op0 and op1 as well.  */
32727
32728 static bool
32729 expand_vselect_vconcat (rtx target, rtx op0, rtx op1,
32730                         const unsigned char *perm, unsigned nelt)
32731 {
32732   enum machine_mode v2mode;
32733   rtx x;
32734
32735   v2mode = doublesize_vector_mode (GET_MODE (op0));
32736   x = gen_rtx_VEC_CONCAT (v2mode, op0, op1);
32737   return expand_vselect (target, x, perm, nelt);
32738 }
32739
32740 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32741    in terms of blendp[sd] / pblendw / pblendvb.  */
32742
32743 static bool
32744 expand_vec_perm_blend (struct expand_vec_perm_d *d)
32745 {
32746   enum machine_mode vmode = d->vmode;
32747   unsigned i, mask, nelt = d->nelt;
32748   rtx target, op0, op1, x;
32749
32750   if (!TARGET_SSE4_1 || d->op0 == d->op1)
32751     return false;
32752   if (!(GET_MODE_SIZE (vmode) == 16 || vmode == V4DFmode || vmode == V8SFmode))
32753     return false;
32754
32755   /* This is a blend, not a permute.  Elements must stay in their
32756      respective lanes.  */
32757   for (i = 0; i < nelt; ++i)
32758     {
32759       unsigned e = d->perm[i];
32760       if (!(e == i || e == i + nelt))
32761         return false;
32762     }
32763
32764   if (d->testing_p)
32765     return true;
32766
32767   /* ??? Without SSE4.1, we could implement this with and/andn/or.  This
32768      decision should be extracted elsewhere, so that we only try that
32769      sequence once all budget==3 options have been tried.  */
32770
32771   /* For bytes, see if bytes move in pairs so we can use pblendw with
32772      an immediate argument, rather than pblendvb with a vector argument.  */
32773   if (vmode == V16QImode)
32774     {
32775       bool pblendw_ok = true;
32776       for (i = 0; i < 16 && pblendw_ok; i += 2)
32777         pblendw_ok = (d->perm[i] + 1 == d->perm[i + 1]);
32778
32779       if (!pblendw_ok)
32780         {
32781           rtx rperm[16], vperm;
32782
32783           for (i = 0; i < nelt; ++i)
32784             rperm[i] = (d->perm[i] < nelt ? const0_rtx : constm1_rtx);
32785
32786           vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
32787           vperm = force_reg (V16QImode, vperm);
32788
32789           emit_insn (gen_sse4_1_pblendvb (d->target, d->op0, d->op1, vperm));
32790           return true;
32791         }
32792     }
32793
32794   target = d->target;
32795   op0 = d->op0;
32796   op1 = d->op1;
32797   mask = 0;
32798
32799   switch (vmode)
32800     {
32801     case V4DFmode:
32802     case V8SFmode:
32803     case V2DFmode:
32804     case V4SFmode:
32805     case V8HImode:
32806       for (i = 0; i < nelt; ++i)
32807         mask |= (d->perm[i] >= nelt) << i;
32808       break;
32809
32810     case V2DImode:
32811       for (i = 0; i < 2; ++i)
32812         mask |= (d->perm[i] >= 2 ? 15 : 0) << (i * 4);
32813       goto do_subreg;
32814
32815     case V4SImode:
32816       for (i = 0; i < 4; ++i)
32817         mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
32818       goto do_subreg;
32819
32820     case V16QImode:
32821       for (i = 0; i < 8; ++i)
32822         mask |= (d->perm[i * 2] >= 16) << i;
32823
32824     do_subreg:
32825       vmode = V8HImode;
32826       target = gen_lowpart (vmode, target);
32827       op0 = gen_lowpart (vmode, op0);
32828       op1 = gen_lowpart (vmode, op1);
32829       break;
32830
32831     default:
32832       gcc_unreachable ();
32833     }
32834
32835   /* This matches five different patterns with the different modes.  */
32836   x = gen_rtx_VEC_MERGE (vmode, op1, op0, GEN_INT (mask));
32837   x = gen_rtx_SET (VOIDmode, target, x);
32838   emit_insn (x);
32839
32840   return true;
32841 }
32842
32843 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32844    in terms of the variable form of vpermilps.
32845
32846    Note that we will have already failed the immediate input vpermilps,
32847    which requires that the high and low part shuffle be identical; the
32848    variable form doesn't require that.  */
32849
32850 static bool
32851 expand_vec_perm_vpermil (struct expand_vec_perm_d *d)
32852 {
32853   rtx rperm[8], vperm;
32854   unsigned i;
32855
32856   if (!TARGET_AVX || d->vmode != V8SFmode || d->op0 != d->op1)
32857     return false;
32858
32859   /* We can only permute within the 128-bit lane.  */
32860   for (i = 0; i < 8; ++i)
32861     {
32862       unsigned e = d->perm[i];
32863       if (i < 4 ? e >= 4 : e < 4)
32864         return false;
32865     }
32866
32867   if (d->testing_p)
32868     return true;
32869
32870   for (i = 0; i < 8; ++i)
32871     {
32872       unsigned e = d->perm[i];
32873
32874       /* Within each 128-bit lane, the elements of op0 are numbered
32875          from 0 and the elements of op1 are numbered from 4.  */
32876       if (e >= 8 + 4)
32877         e -= 8;
32878       else if (e >= 4)
32879         e -= 4;
32880
32881       rperm[i] = GEN_INT (e);
32882     }
32883
32884   vperm = gen_rtx_CONST_VECTOR (V8SImode, gen_rtvec_v (8, rperm));
32885   vperm = force_reg (V8SImode, vperm);
32886   emit_insn (gen_avx_vpermilvarv8sf3 (d->target, d->op0, vperm));
32887
32888   return true;
32889 }
32890
32891 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
32892    in terms of pshufb or vpperm.  */
32893
32894 static bool
32895 expand_vec_perm_pshufb (struct expand_vec_perm_d *d)
32896 {
32897   unsigned i, nelt, eltsz;
32898   rtx rperm[16], vperm, target, op0, op1;
32899
32900   if (!(d->op0 == d->op1 ? TARGET_SSSE3 : TARGET_XOP))
32901     return false;
32902   if (GET_MODE_SIZE (d->vmode) != 16)
32903     return false;
32904
32905   if (d->testing_p)
32906     return true;
32907
32908   nelt = d->nelt;
32909   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
32910
32911   for (i = 0; i < nelt; ++i)
32912     {
32913       unsigned j, e = d->perm[i];
32914       for (j = 0; j < eltsz; ++j)
32915         rperm[i * eltsz + j] = GEN_INT (e * eltsz + j);
32916     }
32917
32918   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm));
32919   vperm = force_reg (V16QImode, vperm);
32920
32921   target = gen_lowpart (V16QImode, d->target);
32922   op0 = gen_lowpart (V16QImode, d->op0);
32923   if (d->op0 == d->op1)
32924     emit_insn (gen_ssse3_pshufbv16qi3 (target, op0, vperm));
32925   else
32926     {
32927       op1 = gen_lowpart (V16QImode, d->op1);
32928       emit_insn (gen_xop_pperm (target, op0, op1, vperm));
32929     }
32930
32931   return true;
32932 }
32933
32934 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to instantiate D
32935    in a single instruction.  */
32936
32937 static bool
32938 expand_vec_perm_1 (struct expand_vec_perm_d *d)
32939 {
32940   unsigned i, nelt = d->nelt;
32941   unsigned char perm2[MAX_VECT_LEN];
32942
32943   /* Check plain VEC_SELECT first, because AVX has instructions that could
32944      match both SEL and SEL+CONCAT, but the plain SEL will allow a memory
32945      input where SEL+CONCAT may not.  */
32946   if (d->op0 == d->op1)
32947     {
32948       int mask = nelt - 1;
32949
32950       for (i = 0; i < nelt; i++)
32951         perm2[i] = d->perm[i] & mask;
32952
32953       if (expand_vselect (d->target, d->op0, perm2, nelt))
32954         return true;
32955
32956       /* There are plenty of patterns in sse.md that are written for
32957          SEL+CONCAT and are not replicated for a single op.  Perhaps
32958          that should be changed, to avoid the nastiness here.  */
32959
32960       /* Recognize interleave style patterns, which means incrementing
32961          every other permutation operand.  */
32962       for (i = 0; i < nelt; i += 2)
32963         {
32964           perm2[i] = d->perm[i] & mask;
32965           perm2[i + 1] = (d->perm[i + 1] & mask) + nelt;
32966         }
32967       if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
32968         return true;
32969
32970       /* Recognize shufps, which means adding {0, 0, nelt, nelt}.  */
32971       if (nelt >= 4)
32972         {
32973           for (i = 0; i < nelt; i += 4)
32974             {
32975               perm2[i + 0] = d->perm[i + 0] & mask;
32976               perm2[i + 1] = d->perm[i + 1] & mask;
32977               perm2[i + 2] = (d->perm[i + 2] & mask) + nelt;
32978               perm2[i + 3] = (d->perm[i + 3] & mask) + nelt;
32979             }
32980
32981           if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
32982             return true;
32983         }
32984     }
32985
32986   /* Finally, try the fully general two operand permute.  */
32987   if (expand_vselect_vconcat (d->target, d->op0, d->op1, d->perm, nelt))
32988     return true;
32989
32990   /* Recognize interleave style patterns with reversed operands.  */
32991   if (d->op0 != d->op1)
32992     {
32993       for (i = 0; i < nelt; ++i)
32994         {
32995           unsigned e = d->perm[i];
32996           if (e >= nelt)
32997             e -= nelt;
32998           else
32999             e += nelt;
33000           perm2[i] = e;
33001         }
33002
33003       if (expand_vselect_vconcat (d->target, d->op1, d->op0, perm2, nelt))
33004         return true;
33005     }
33006
33007   /* Try the SSE4.1 blend variable merge instructions.  */
33008   if (expand_vec_perm_blend (d))
33009     return true;
33010
33011   /* Try one of the AVX vpermil variable permutations.  */
33012   if (expand_vec_perm_vpermil (d))
33013     return true;
33014
33015   /* Try the SSSE3 pshufb or XOP vpperm variable permutation.  */
33016   if (expand_vec_perm_pshufb (d))
33017     return true;
33018
33019   return false;
33020 }
33021
33022 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
33023    in terms of a pair of pshuflw + pshufhw instructions.  */
33024
33025 static bool
33026 expand_vec_perm_pshuflw_pshufhw (struct expand_vec_perm_d *d)
33027 {
33028   unsigned char perm2[MAX_VECT_LEN];
33029   unsigned i;
33030   bool ok;
33031
33032   if (d->vmode != V8HImode || d->op0 != d->op1)
33033     return false;
33034
33035   /* The two permutations only operate in 64-bit lanes.  */
33036   for (i = 0; i < 4; ++i)
33037     if (d->perm[i] >= 4)
33038       return false;
33039   for (i = 4; i < 8; ++i)
33040     if (d->perm[i] < 4)
33041       return false;
33042
33043   if (d->testing_p)
33044     return true;
33045
33046   /* Emit the pshuflw.  */
33047   memcpy (perm2, d->perm, 4);
33048   for (i = 4; i < 8; ++i)
33049     perm2[i] = i;
33050   ok = expand_vselect (d->target, d->op0, perm2, 8);
33051   gcc_assert (ok);
33052
33053   /* Emit the pshufhw.  */
33054   memcpy (perm2 + 4, d->perm + 4, 4);
33055   for (i = 0; i < 4; ++i)
33056     perm2[i] = i;
33057   ok = expand_vselect (d->target, d->target, perm2, 8);
33058   gcc_assert (ok);
33059
33060   return true;
33061 }
33062
33063 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
33064    the permutation using the SSSE3 palignr instruction.  This succeeds
33065    when all of the elements in PERM fit within one vector and we merely
33066    need to shift them down so that a single vector permutation has a
33067    chance to succeed.  */
33068
33069 static bool
33070 expand_vec_perm_palignr (struct expand_vec_perm_d *d)
33071 {
33072   unsigned i, nelt = d->nelt;
33073   unsigned min, max;
33074   bool in_order, ok;
33075   rtx shift;
33076
33077   /* Even with AVX, palignr only operates on 128-bit vectors.  */
33078   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
33079     return false;
33080
33081   min = nelt, max = 0;
33082   for (i = 0; i < nelt; ++i)
33083     {
33084       unsigned e = d->perm[i];
33085       if (e < min)
33086         min = e;
33087       if (e > max)
33088         max = e;
33089     }
33090   if (min == 0 || max - min >= nelt)
33091     return false;
33092
33093   /* Given that we have SSSE3, we know we'll be able to implement the
33094      single operand permutation after the palignr with pshufb.  */
33095   if (d->testing_p)
33096     return true;
33097
33098   shift = GEN_INT (min * GET_MODE_BITSIZE (GET_MODE_INNER (d->vmode)));
33099   emit_insn (gen_ssse3_palignrti (gen_lowpart (TImode, d->target),
33100                                   gen_lowpart (TImode, d->op1),
33101                                   gen_lowpart (TImode, d->op0), shift));
33102
33103   d->op0 = d->op1 = d->target;
33104
33105   in_order = true;
33106   for (i = 0; i < nelt; ++i)
33107     {
33108       unsigned e = d->perm[i] - min;
33109       if (e != i)
33110         in_order = false;
33111       d->perm[i] = e;
33112     }
33113
33114   /* Test for the degenerate case where the alignment by itself
33115      produces the desired permutation.  */
33116   if (in_order)
33117     return true;
33118
33119   ok = expand_vec_perm_1 (d);
33120   gcc_assert (ok);
33121
33122   return ok;
33123 }
33124
33125 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
33126    a two vector permutation into a single vector permutation by using
33127    an interleave operation to merge the vectors.  */
33128
33129 static bool
33130 expand_vec_perm_interleave2 (struct expand_vec_perm_d *d)
33131 {
33132   struct expand_vec_perm_d dremap, dfinal;
33133   unsigned i, nelt = d->nelt, nelt2 = nelt / 2;
33134   unsigned contents, h1, h2, h3, h4;
33135   unsigned char remap[2 * MAX_VECT_LEN];
33136   rtx seq;
33137   bool ok;
33138
33139   if (d->op0 == d->op1)
33140     return false;
33141
33142   /* The 256-bit unpck[lh]p[sd] instructions only operate within the 128-bit
33143      lanes.  We can use similar techniques with the vperm2f128 instruction,
33144      but it requires slightly different logic.  */
33145   if (GET_MODE_SIZE (d->vmode) != 16)
33146     return false;
33147
33148   /* Examine from whence the elements come.  */
33149   contents = 0;
33150   for (i = 0; i < nelt; ++i)
33151     contents |= 1u << d->perm[i];
33152
33153   /* Split the two input vectors into 4 halves.  */
33154   h1 = (1u << nelt2) - 1;
33155   h2 = h1 << nelt2;
33156   h3 = h2 << nelt2;
33157   h4 = h3 << nelt2;
33158
33159   memset (remap, 0xff, sizeof (remap));
33160   dremap = *d;
33161
33162   /* If the elements from the low halves use interleave low, and similarly
33163      for interleave high.  If the elements are from mis-matched halves, we
33164      can use shufps for V4SF/V4SI or do a DImode shuffle.  */
33165   if ((contents & (h1 | h3)) == contents)
33166     {
33167       for (i = 0; i < nelt2; ++i)
33168         {
33169           remap[i] = i * 2;
33170           remap[i + nelt] = i * 2 + 1;
33171           dremap.perm[i * 2] = i;
33172           dremap.perm[i * 2 + 1] = i + nelt;
33173         }
33174     }
33175   else if ((contents & (h2 | h4)) == contents)
33176     {
33177       for (i = 0; i < nelt2; ++i)
33178         {
33179           remap[i + nelt2] = i * 2;
33180           remap[i + nelt + nelt2] = i * 2 + 1;
33181           dremap.perm[i * 2] = i + nelt2;
33182           dremap.perm[i * 2 + 1] = i + nelt + nelt2;
33183         }
33184     }
33185   else if ((contents & (h1 | h4)) == contents)
33186     {
33187       for (i = 0; i < nelt2; ++i)
33188         {
33189           remap[i] = i;
33190           remap[i + nelt + nelt2] = i + nelt2;
33191           dremap.perm[i] = i;
33192           dremap.perm[i + nelt2] = i + nelt + nelt2;
33193         }
33194       if (nelt != 4)
33195         {
33196           dremap.vmode = V2DImode;
33197           dremap.nelt = 2;
33198           dremap.perm[0] = 0;
33199           dremap.perm[1] = 3;
33200         }
33201     }
33202   else if ((contents & (h2 | h3)) == contents)
33203     {
33204       for (i = 0; i < nelt2; ++i)
33205         {
33206           remap[i + nelt2] = i;
33207           remap[i + nelt] = i + nelt2;
33208           dremap.perm[i] = i + nelt2;
33209           dremap.perm[i + nelt2] = i + nelt;
33210         }
33211       if (nelt != 4)
33212         {
33213           dremap.vmode = V2DImode;
33214           dremap.nelt = 2;
33215           dremap.perm[0] = 1;
33216           dremap.perm[1] = 2;
33217         }
33218     }
33219   else
33220     return false;
33221
33222   /* Use the remapping array set up above to move the elements from their
33223      swizzled locations into their final destinations.  */
33224   dfinal = *d;
33225   for (i = 0; i < nelt; ++i)
33226     {
33227       unsigned e = remap[d->perm[i]];
33228       gcc_assert (e < nelt);
33229       dfinal.perm[i] = e;
33230     }
33231   dfinal.op0 = gen_reg_rtx (dfinal.vmode);
33232   dfinal.op1 = dfinal.op0;
33233   dremap.target = dfinal.op0;
33234
33235   /* Test if the final remap can be done with a single insn.  For V4SFmode or
33236      V4SImode this *will* succeed.  For V8HImode or V16QImode it may not.  */
33237   start_sequence ();
33238   ok = expand_vec_perm_1 (&dfinal);
33239   seq = get_insns ();
33240   end_sequence ();
33241
33242   if (!ok)
33243     return false;
33244
33245   if (dremap.vmode != dfinal.vmode)
33246     {
33247       dremap.target = gen_lowpart (dremap.vmode, dremap.target);
33248       dremap.op0 = gen_lowpart (dremap.vmode, dremap.op0);
33249       dremap.op1 = gen_lowpart (dremap.vmode, dremap.op1);
33250     }
33251
33252   ok = expand_vec_perm_1 (&dremap);
33253   gcc_assert (ok);
33254
33255   emit_insn (seq);
33256   return true;
33257 }
33258
33259 /* A subroutine of expand_vec_perm_even_odd_1.  Implement the double-word
33260    permutation with two pshufb insns and an ior.  We should have already
33261    failed all two instruction sequences.  */
33262
33263 static bool
33264 expand_vec_perm_pshufb2 (struct expand_vec_perm_d *d)
33265 {
33266   rtx rperm[2][16], vperm, l, h, op, m128;
33267   unsigned int i, nelt, eltsz;
33268
33269   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
33270     return false;
33271   gcc_assert (d->op0 != d->op1);
33272
33273   nelt = d->nelt;
33274   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
33275
33276   /* Generate two permutation masks.  If the required element is within
33277      the given vector it is shuffled into the proper lane.  If the required
33278      element is in the other vector, force a zero into the lane by setting
33279      bit 7 in the permutation mask.  */
33280   m128 = GEN_INT (-128);
33281   for (i = 0; i < nelt; ++i)
33282     {
33283       unsigned j, e = d->perm[i];
33284       unsigned which = (e >= nelt);
33285       if (e >= nelt)
33286         e -= nelt;
33287
33288       for (j = 0; j < eltsz; ++j)
33289         {
33290           rperm[which][i*eltsz + j] = GEN_INT (e*eltsz + j);
33291           rperm[1-which][i*eltsz + j] = m128;
33292         }
33293     }
33294
33295   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[0]));
33296   vperm = force_reg (V16QImode, vperm);
33297
33298   l = gen_reg_rtx (V16QImode);
33299   op = gen_lowpart (V16QImode, d->op0);
33300   emit_insn (gen_ssse3_pshufbv16qi3 (l, op, vperm));
33301
33302   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[1]));
33303   vperm = force_reg (V16QImode, vperm);
33304
33305   h = gen_reg_rtx (V16QImode);
33306   op = gen_lowpart (V16QImode, d->op1);
33307   emit_insn (gen_ssse3_pshufbv16qi3 (h, op, vperm));
33308
33309   op = gen_lowpart (V16QImode, d->target);
33310   emit_insn (gen_iorv16qi3 (op, l, h));
33311
33312   return true;
33313 }
33314
33315 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement extract-even
33316    and extract-odd permutations.  */
33317
33318 static bool
33319 expand_vec_perm_even_odd_1 (struct expand_vec_perm_d *d, unsigned odd)
33320 {
33321   rtx t1, t2, t3;
33322
33323   switch (d->vmode)
33324     {
33325     case V4DFmode:
33326       t1 = gen_reg_rtx (V4DFmode);
33327       t2 = gen_reg_rtx (V4DFmode);
33328
33329       /* Shuffle the lanes around into { 0 1 4 5 } and { 2 3 6 7 }.  */
33330       emit_insn (gen_avx_vperm2f128v4df3 (t1, d->op0, d->op1, GEN_INT (0x20)));
33331       emit_insn (gen_avx_vperm2f128v4df3 (t2, d->op0, d->op1, GEN_INT (0x31)));
33332
33333       /* Now an unpck[lh]pd will produce the result required.  */
33334       if (odd)
33335         t3 = gen_avx_unpckhpd256 (d->target, t1, t2);
33336       else
33337         t3 = gen_avx_unpcklpd256 (d->target, t1, t2);
33338       emit_insn (t3);
33339       break;
33340
33341     case V8SFmode:
33342       {
33343         int mask = odd ? 0xdd : 0x88;
33344
33345         t1 = gen_reg_rtx (V8SFmode);
33346         t2 = gen_reg_rtx (V8SFmode);
33347         t3 = gen_reg_rtx (V8SFmode);
33348
33349         /* Shuffle within the 128-bit lanes to produce:
33350            { 0 2 8 a 4 6 c e } | { 1 3 9 b 5 7 d f }.  */
33351         emit_insn (gen_avx_shufps256 (t1, d->op0, d->op1,
33352                                       GEN_INT (mask)));
33353
33354         /* Shuffle the lanes around to produce:
33355            { 4 6 c e 0 2 8 a } and { 5 7 d f 1 3 9 b }.  */
33356         emit_insn (gen_avx_vperm2f128v8sf3 (t2, t1, t1,
33357                                             GEN_INT (0x3)));
33358
33359         /* Shuffle within the 128-bit lanes to produce:
33360            { 0 2 4 6 4 6 0 2 } | { 1 3 5 7 5 7 1 3 }.  */
33361         emit_insn (gen_avx_shufps256 (t3, t1, t2, GEN_INT (0x44)));
33362
33363         /* Shuffle within the 128-bit lanes to produce:
33364            { 8 a c e c e 8 a } | { 9 b d f d f 9 b }.  */
33365         emit_insn (gen_avx_shufps256 (t2, t1, t2, GEN_INT (0xee)));
33366
33367         /* Shuffle the lanes around to produce:
33368            { 0 2 4 6 8 a c e } | { 1 3 5 7 9 b d f }.  */
33369         emit_insn (gen_avx_vperm2f128v8sf3 (d->target, t3, t2,
33370                                             GEN_INT (0x20)));
33371       }
33372       break;
33373
33374     case V2DFmode:
33375     case V4SFmode:
33376     case V2DImode:
33377     case V4SImode:
33378       /* These are always directly implementable by expand_vec_perm_1.  */
33379       gcc_unreachable ();
33380
33381     case V8HImode:
33382       if (TARGET_SSSE3)
33383         return expand_vec_perm_pshufb2 (d);
33384       else
33385         {
33386           /* We need 2*log2(N)-1 operations to achieve odd/even
33387              with interleave. */
33388           t1 = gen_reg_rtx (V8HImode);
33389           t2 = gen_reg_rtx (V8HImode);
33390           emit_insn (gen_vec_interleave_highv8hi (t1, d->op0, d->op1));
33391           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->op0, d->op1));
33392           emit_insn (gen_vec_interleave_highv8hi (t2, d->target, t1));
33393           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->target, t1));
33394           if (odd)
33395             t3 = gen_vec_interleave_highv8hi (d->target, d->target, t2);
33396           else
33397             t3 = gen_vec_interleave_lowv8hi (d->target, d->target, t2);
33398           emit_insn (t3);
33399         }
33400       break;
33401
33402     case V16QImode:
33403       if (TARGET_SSSE3)
33404         return expand_vec_perm_pshufb2 (d);
33405       else
33406         {
33407           t1 = gen_reg_rtx (V16QImode);
33408           t2 = gen_reg_rtx (V16QImode);
33409           t3 = gen_reg_rtx (V16QImode);
33410           emit_insn (gen_vec_interleave_highv16qi (t1, d->op0, d->op1));
33411           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->op0, d->op1));
33412           emit_insn (gen_vec_interleave_highv16qi (t2, d->target, t1));
33413           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t1));
33414           emit_insn (gen_vec_interleave_highv16qi (t3, d->target, t2));
33415           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t2));
33416           if (odd)
33417             t3 = gen_vec_interleave_highv16qi (d->target, d->target, t3);
33418           else
33419             t3 = gen_vec_interleave_lowv16qi (d->target, d->target, t3);
33420           emit_insn (t3);
33421         }
33422       break;
33423
33424     default:
33425       gcc_unreachable ();
33426     }
33427
33428   return true;
33429 }
33430
33431 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
33432    extract-even and extract-odd permutations.  */
33433
33434 static bool
33435 expand_vec_perm_even_odd (struct expand_vec_perm_d *d)
33436 {
33437   unsigned i, odd, nelt = d->nelt;
33438
33439   odd = d->perm[0];
33440   if (odd != 0 && odd != 1)
33441     return false;
33442
33443   for (i = 1; i < nelt; ++i)
33444     if (d->perm[i] != 2 * i + odd)
33445       return false;
33446
33447   return expand_vec_perm_even_odd_1 (d, odd);
33448 }
33449
33450 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement broadcast
33451    permutations.  We assume that expand_vec_perm_1 has already failed.  */
33452
33453 static bool
33454 expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d)
33455 {
33456   unsigned elt = d->perm[0], nelt2 = d->nelt / 2;
33457   enum machine_mode vmode = d->vmode;
33458   unsigned char perm2[4];
33459   rtx op0 = d->op0;
33460   bool ok;
33461
33462   switch (vmode)
33463     {
33464     case V4DFmode:
33465     case V8SFmode:
33466       /* These are special-cased in sse.md so that we can optionally
33467          use the vbroadcast instruction.  They expand to two insns
33468          if the input happens to be in a register.  */
33469       gcc_unreachable ();
33470
33471     case V2DFmode:
33472     case V2DImode:
33473     case V4SFmode:
33474     case V4SImode:
33475       /* These are always implementable using standard shuffle patterns.  */
33476       gcc_unreachable ();
33477
33478     case V8HImode:
33479     case V16QImode:
33480       /* These can be implemented via interleave.  We save one insn by
33481          stopping once we have promoted to V4SImode and then use pshufd.  */
33482       do
33483         {
33484           optab otab = vec_interleave_low_optab;
33485
33486           if (elt >= nelt2)
33487             {
33488               otab = vec_interleave_high_optab;
33489               elt -= nelt2;
33490             }
33491           nelt2 /= 2;
33492
33493           op0 = expand_binop (vmode, otab, op0, op0, NULL, 0, OPTAB_DIRECT);
33494           vmode = get_mode_wider_vector (vmode);
33495           op0 = gen_lowpart (vmode, op0);
33496         }
33497       while (vmode != V4SImode);
33498
33499       memset (perm2, elt, 4);
33500       ok = expand_vselect (gen_lowpart (V4SImode, d->target), op0, perm2, 4);
33501       gcc_assert (ok);
33502       return true;
33503
33504     default:
33505       gcc_unreachable ();
33506     }
33507 }
33508
33509 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
33510    broadcast permutations.  */
33511
33512 static bool
33513 expand_vec_perm_broadcast (struct expand_vec_perm_d *d)
33514 {
33515   unsigned i, elt, nelt = d->nelt;
33516
33517   if (d->op0 != d->op1)
33518     return false;
33519
33520   elt = d->perm[0];
33521   for (i = 1; i < nelt; ++i)
33522     if (d->perm[i] != elt)
33523       return false;
33524
33525   return expand_vec_perm_broadcast_1 (d);
33526 }
33527
33528 /* The guts of ix86_expand_vec_perm_builtin, also used by the ok hook.
33529    With all of the interface bits taken care of, perform the expansion
33530    in D and return true on success.  */
33531
33532 static bool
33533 ix86_expand_vec_perm_builtin_1 (struct expand_vec_perm_d *d)
33534 {
33535   /* Try a single instruction expansion.  */
33536   if (expand_vec_perm_1 (d))
33537     return true;
33538
33539   /* Try sequences of two instructions.  */
33540
33541   if (expand_vec_perm_pshuflw_pshufhw (d))
33542     return true;
33543
33544   if (expand_vec_perm_palignr (d))
33545     return true;
33546
33547   if (expand_vec_perm_interleave2 (d))
33548     return true;
33549
33550   if (expand_vec_perm_broadcast (d))
33551     return true;
33552
33553   /* Try sequences of three instructions.  */
33554
33555   if (expand_vec_perm_pshufb2 (d))
33556     return true;
33557
33558   /* ??? Look for narrow permutations whose element orderings would
33559      allow the promotion to a wider mode.  */
33560
33561   /* ??? Look for sequences of interleave or a wider permute that place
33562      the data into the correct lanes for a half-vector shuffle like
33563      pshuf[lh]w or vpermilps.  */
33564
33565   /* ??? Look for sequences of interleave that produce the desired results.
33566      The combinatorics of punpck[lh] get pretty ugly... */
33567
33568   if (expand_vec_perm_even_odd (d))
33569     return true;
33570
33571   return false;
33572 }
33573
33574 /* Extract the values from the vector CST into the permutation array in D.
33575    Return 0 on error, 1 if all values from the permutation come from the
33576    first vector, 2 if all values from the second vector, and 3 otherwise.  */
33577
33578 static int
33579 extract_vec_perm_cst (struct expand_vec_perm_d *d, tree cst)
33580 {
33581   tree list = TREE_VECTOR_CST_ELTS (cst);
33582   unsigned i, nelt = d->nelt;
33583   int ret = 0;
33584
33585   for (i = 0; i < nelt; ++i, list = TREE_CHAIN (list))
33586     {
33587       unsigned HOST_WIDE_INT e;
33588
33589       if (!host_integerp (TREE_VALUE (list), 1))
33590         return 0;
33591       e = tree_low_cst (TREE_VALUE (list), 1);
33592       if (e >= 2 * nelt)
33593         return 0;
33594
33595       ret |= (e < nelt ? 1 : 2);
33596       d->perm[i] = e;
33597     }
33598   gcc_assert (list == NULL);
33599
33600   /* For all elements from second vector, fold the elements to first.  */
33601   if (ret == 2)
33602     for (i = 0; i < nelt; ++i)
33603       d->perm[i] -= nelt;
33604
33605   return ret;
33606 }
33607
33608 static rtx
33609 ix86_expand_vec_perm_builtin (tree exp)
33610 {
33611   struct expand_vec_perm_d d;
33612   tree arg0, arg1, arg2;
33613
33614   arg0 = CALL_EXPR_ARG (exp, 0);
33615   arg1 = CALL_EXPR_ARG (exp, 1);
33616   arg2 = CALL_EXPR_ARG (exp, 2);
33617
33618   d.vmode = TYPE_MODE (TREE_TYPE (arg0));
33619   d.nelt = GET_MODE_NUNITS (d.vmode);
33620   d.testing_p = false;
33621   gcc_assert (VECTOR_MODE_P (d.vmode));
33622
33623   if (TREE_CODE (arg2) != VECTOR_CST)
33624     {
33625       error_at (EXPR_LOCATION (exp),
33626                 "vector permutation requires vector constant");
33627       goto exit_error;
33628     }
33629
33630   switch (extract_vec_perm_cst (&d, arg2))
33631     {
33632     default:
33633       gcc_unreachable();
33634
33635     case 0:
33636       error_at (EXPR_LOCATION (exp), "invalid vector permutation constant");
33637       goto exit_error;
33638
33639     case 3:
33640       if (!operand_equal_p (arg0, arg1, 0))
33641         {
33642           d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
33643           d.op0 = force_reg (d.vmode, d.op0);
33644           d.op1 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
33645           d.op1 = force_reg (d.vmode, d.op1);
33646           break;
33647         }
33648
33649       /* The elements of PERM do not suggest that only the first operand
33650          is used, but both operands are identical.  Allow easier matching
33651          of the permutation by folding the permutation into the single
33652          input vector.  */
33653       {
33654         unsigned i, nelt = d.nelt;
33655         for (i = 0; i < nelt; ++i)
33656           if (d.perm[i] >= nelt)
33657             d.perm[i] -= nelt;
33658       }
33659       /* FALLTHRU */
33660
33661     case 1:
33662       d.op0 = expand_expr (arg0, NULL_RTX, d.vmode, EXPAND_NORMAL);
33663       d.op0 = force_reg (d.vmode, d.op0);
33664       d.op1 = d.op0;
33665       break;
33666
33667     case 2:
33668       d.op0 = expand_expr (arg1, NULL_RTX, d.vmode, EXPAND_NORMAL);
33669       d.op0 = force_reg (d.vmode, d.op0);
33670       d.op1 = d.op0;
33671       break;
33672     }
33673
33674   d.target = gen_reg_rtx (d.vmode);
33675   if (ix86_expand_vec_perm_builtin_1 (&d))
33676     return d.target;
33677
33678   /* For compiler generated permutations, we should never got here, because
33679      the compiler should also be checking the ok hook.  But since this is a
33680      builtin the user has access too, so don't abort.  */
33681   switch (d.nelt)
33682     {
33683     case 2:
33684       sorry ("vector permutation (%d %d)", d.perm[0], d.perm[1]);
33685       break;
33686     case 4:
33687       sorry ("vector permutation (%d %d %d %d)",
33688              d.perm[0], d.perm[1], d.perm[2], d.perm[3]);
33689       break;
33690     case 8:
33691       sorry ("vector permutation (%d %d %d %d %d %d %d %d)",
33692              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
33693              d.perm[4], d.perm[5], d.perm[6], d.perm[7]);
33694       break;
33695     case 16:
33696       sorry ("vector permutation "
33697              "(%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d)",
33698              d.perm[0], d.perm[1], d.perm[2], d.perm[3],
33699              d.perm[4], d.perm[5], d.perm[6], d.perm[7],
33700              d.perm[8], d.perm[9], d.perm[10], d.perm[11],
33701              d.perm[12], d.perm[13], d.perm[14], d.perm[15]);
33702       break;
33703     default:
33704       gcc_unreachable ();
33705     }
33706  exit_error:
33707   return CONST0_RTX (d.vmode);
33708 }
33709
33710 /* Implement targetm.vectorize.builtin_vec_perm_ok.  */
33711
33712 static bool
33713 ix86_vectorize_builtin_vec_perm_ok (tree vec_type, tree mask)
33714 {
33715   struct expand_vec_perm_d d;
33716   int vec_mask;
33717   bool ret, one_vec;
33718
33719   d.vmode = TYPE_MODE (vec_type);
33720   d.nelt = GET_MODE_NUNITS (d.vmode);
33721   d.testing_p = true;
33722
33723   /* Given sufficient ISA support we can just return true here
33724      for selected vector modes.  */
33725   if (GET_MODE_SIZE (d.vmode) == 16)
33726     {
33727       /* All implementable with a single vpperm insn.  */
33728       if (TARGET_XOP)
33729         return true;
33730       /* All implementable with 2 pshufb + 1 ior.  */
33731       if (TARGET_SSSE3)
33732         return true;
33733       /* All implementable with shufpd or unpck[lh]pd.  */
33734       if (d.nelt == 2)
33735         return true;
33736     }
33737
33738   vec_mask = extract_vec_perm_cst (&d, mask);
33739
33740   /* This hook is cannot be called in response to something that the
33741      user does (unlike the builtin expander) so we shouldn't ever see
33742      an error generated from the extract.  */
33743   gcc_assert (vec_mask > 0 && vec_mask <= 3);
33744   one_vec = (vec_mask != 3);
33745
33746   /* Implementable with shufps or pshufd.  */
33747   if (one_vec && (d.vmode == V4SFmode || d.vmode == V4SImode))
33748     return true;
33749
33750   /* Otherwise we have to go through the motions and see if we can
33751      figure out how to generate the requested permutation.  */
33752   d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1);
33753   d.op1 = d.op0 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 2);
33754   if (!one_vec)
33755     d.op1 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 3);
33756
33757   start_sequence ();
33758   ret = ix86_expand_vec_perm_builtin_1 (&d);
33759   end_sequence ();
33760
33761   return ret;
33762 }
33763
33764 void
33765 ix86_expand_vec_extract_even_odd (rtx targ, rtx op0, rtx op1, unsigned odd)
33766 {
33767   struct expand_vec_perm_d d;
33768   unsigned i, nelt;
33769
33770   d.target = targ;
33771   d.op0 = op0;
33772   d.op1 = op1;
33773   d.vmode = GET_MODE (targ);
33774   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
33775   d.testing_p = false;
33776
33777   for (i = 0; i < nelt; ++i)
33778     d.perm[i] = i * 2 + odd;
33779
33780   /* We'll either be able to implement the permutation directly...  */
33781   if (expand_vec_perm_1 (&d))
33782     return;
33783
33784   /* ... or we use the special-case patterns.  */
33785   expand_vec_perm_even_odd_1 (&d, odd);
33786 }
33787
33788 /* Expand an insert into a vector register through pinsr insn.
33789    Return true if successful.  */
33790
33791 bool
33792 ix86_expand_pinsr (rtx *operands)
33793 {
33794   rtx dst = operands[0];
33795   rtx src = operands[3];
33796
33797   unsigned int size = INTVAL (operands[1]);
33798   unsigned int pos = INTVAL (operands[2]);
33799
33800   if (GET_CODE (dst) == SUBREG)
33801     {
33802       pos += SUBREG_BYTE (dst) * BITS_PER_UNIT;
33803       dst = SUBREG_REG (dst);
33804     }
33805
33806   if (GET_CODE (src) == SUBREG)
33807     src = SUBREG_REG (src);
33808
33809   switch (GET_MODE (dst))
33810     {
33811     case V16QImode:
33812     case V8HImode:
33813     case V4SImode:
33814     case V2DImode:
33815       {
33816         enum machine_mode srcmode, dstmode;
33817         rtx (*pinsr)(rtx, rtx, rtx, rtx);
33818
33819         srcmode = mode_for_size (size, MODE_INT, 0);
33820
33821         switch (srcmode)
33822           {
33823           case QImode:
33824             if (!TARGET_SSE4_1)
33825               return false;
33826             dstmode = V16QImode;
33827             pinsr = gen_sse4_1_pinsrb;
33828             break;
33829
33830           case HImode:
33831             if (!TARGET_SSE2)
33832               return false;
33833             dstmode = V8HImode;
33834             pinsr = gen_sse2_pinsrw;
33835             break;
33836
33837           case SImode:
33838             if (!TARGET_SSE4_1)
33839               return false;
33840             dstmode = V4SImode;
33841             pinsr = gen_sse4_1_pinsrd;
33842             break;
33843
33844           case DImode:
33845             gcc_assert (TARGET_64BIT);
33846             if (!TARGET_SSE4_1)
33847               return false;
33848             dstmode = V2DImode;
33849             pinsr = gen_sse4_1_pinsrq;
33850             break;
33851
33852           default:
33853             return false;
33854           }
33855
33856         dst = gen_lowpart (dstmode, dst);
33857         src = gen_lowpart (srcmode, src);
33858
33859         pos /= size;
33860
33861         emit_insn (pinsr (dst, dst, src, GEN_INT (1 << pos)));
33862         return true;
33863       }
33864
33865     default:
33866       return false;
33867     }
33868 }
33869 \f
33870 /* This function returns the calling abi specific va_list type node.
33871    It returns  the FNDECL specific va_list type.  */
33872
33873 static tree
33874 ix86_fn_abi_va_list (tree fndecl)
33875 {
33876   if (!TARGET_64BIT)
33877     return va_list_type_node;
33878   gcc_assert (fndecl != NULL_TREE);
33879
33880   if (ix86_function_abi ((const_tree) fndecl) == MS_ABI)
33881     return ms_va_list_type_node;
33882   else
33883     return sysv_va_list_type_node;
33884 }
33885
33886 /* Returns the canonical va_list type specified by TYPE. If there
33887    is no valid TYPE provided, it return NULL_TREE.  */
33888
33889 static tree
33890 ix86_canonical_va_list_type (tree type)
33891 {
33892   tree wtype, htype;
33893
33894   /* Resolve references and pointers to va_list type.  */
33895   if (TREE_CODE (type) == MEM_REF)
33896     type = TREE_TYPE (type);
33897   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
33898     type = TREE_TYPE (type);
33899   else if (POINTER_TYPE_P (type) && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
33900     type = TREE_TYPE (type);
33901
33902   if (TARGET_64BIT && va_list_type_node != NULL_TREE)
33903     {
33904       wtype = va_list_type_node;
33905           gcc_assert (wtype != NULL_TREE);
33906       htype = type;
33907       if (TREE_CODE (wtype) == ARRAY_TYPE)
33908         {
33909           /* If va_list is an array type, the argument may have decayed
33910              to a pointer type, e.g. by being passed to another function.
33911              In that case, unwrap both types so that we can compare the
33912              underlying records.  */
33913           if (TREE_CODE (htype) == ARRAY_TYPE
33914               || POINTER_TYPE_P (htype))
33915             {
33916               wtype = TREE_TYPE (wtype);
33917               htype = TREE_TYPE (htype);
33918             }
33919         }
33920       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33921         return va_list_type_node;
33922       wtype = sysv_va_list_type_node;
33923           gcc_assert (wtype != NULL_TREE);
33924       htype = type;
33925       if (TREE_CODE (wtype) == ARRAY_TYPE)
33926         {
33927           /* If va_list is an array type, the argument may have decayed
33928              to a pointer type, e.g. by being passed to another function.
33929              In that case, unwrap both types so that we can compare the
33930              underlying records.  */
33931           if (TREE_CODE (htype) == ARRAY_TYPE
33932               || POINTER_TYPE_P (htype))
33933             {
33934               wtype = TREE_TYPE (wtype);
33935               htype = TREE_TYPE (htype);
33936             }
33937         }
33938       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33939         return sysv_va_list_type_node;
33940       wtype = ms_va_list_type_node;
33941           gcc_assert (wtype != NULL_TREE);
33942       htype = type;
33943       if (TREE_CODE (wtype) == ARRAY_TYPE)
33944         {
33945           /* If va_list is an array type, the argument may have decayed
33946              to a pointer type, e.g. by being passed to another function.
33947              In that case, unwrap both types so that we can compare the
33948              underlying records.  */
33949           if (TREE_CODE (htype) == ARRAY_TYPE
33950               || POINTER_TYPE_P (htype))
33951             {
33952               wtype = TREE_TYPE (wtype);
33953               htype = TREE_TYPE (htype);
33954             }
33955         }
33956       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
33957         return ms_va_list_type_node;
33958       return NULL_TREE;
33959     }
33960   return std_canonical_va_list_type (type);
33961 }
33962
33963 /* Iterate through the target-specific builtin types for va_list.
33964    IDX denotes the iterator, *PTREE is set to the result type of
33965    the va_list builtin, and *PNAME to its internal type.
33966    Returns zero if there is no element for this index, otherwise
33967    IDX should be increased upon the next call.
33968    Note, do not iterate a base builtin's name like __builtin_va_list.
33969    Used from c_common_nodes_and_builtins.  */
33970
33971 static int
33972 ix86_enum_va_list (int idx, const char **pname, tree *ptree)
33973 {
33974   if (TARGET_64BIT)
33975     {
33976       switch (idx)
33977         {
33978         default:
33979           break;
33980
33981         case 0:
33982           *ptree = ms_va_list_type_node;
33983           *pname = "__builtin_ms_va_list";
33984           return 1;
33985
33986         case 1:
33987           *ptree = sysv_va_list_type_node;
33988           *pname = "__builtin_sysv_va_list";
33989           return 1;
33990         }
33991     }
33992
33993   return 0;
33994 }
33995
33996 #undef TARGET_SCHED_DISPATCH
33997 #define TARGET_SCHED_DISPATCH has_dispatch
33998 #undef TARGET_SCHED_DISPATCH_DO
33999 #define TARGET_SCHED_DISPATCH_DO do_dispatch
34000
34001 /* The size of the dispatch window is the total number of bytes of
34002    object code allowed in a window.  */
34003 #define DISPATCH_WINDOW_SIZE 16
34004
34005 /* Number of dispatch windows considered for scheduling.  */
34006 #define MAX_DISPATCH_WINDOWS 3
34007
34008 /* Maximum number of instructions in a window.  */
34009 #define MAX_INSN 4
34010
34011 /* Maximum number of immediate operands in a window.  */
34012 #define MAX_IMM 4
34013
34014 /* Maximum number of immediate bits allowed in a window.  */
34015 #define MAX_IMM_SIZE 128
34016
34017 /* Maximum number of 32 bit immediates allowed in a window.  */
34018 #define MAX_IMM_32 4
34019
34020 /* Maximum number of 64 bit immediates allowed in a window.  */
34021 #define MAX_IMM_64 2
34022
34023 /* Maximum total of loads or prefetches allowed in a window.  */
34024 #define MAX_LOAD 2
34025
34026 /* Maximum total of stores allowed in a window.  */
34027 #define MAX_STORE 1
34028
34029 #undef BIG
34030 #define BIG 100
34031
34032
34033 /* Dispatch groups.  Istructions that affect the mix in a dispatch window.  */
34034 enum dispatch_group {
34035   disp_no_group = 0,
34036   disp_load,
34037   disp_store,
34038   disp_load_store,
34039   disp_prefetch,
34040   disp_imm,
34041   disp_imm_32,
34042   disp_imm_64,
34043   disp_branch,
34044   disp_cmp,
34045   disp_jcc,
34046   disp_last
34047 };
34048
34049 /* Number of allowable groups in a dispatch window.  It is an array
34050    indexed by dispatch_group enum.  100 is used as a big number,
34051    because the number of these kind of operations does not have any
34052    effect in dispatch window, but we need them for other reasons in
34053    the table.  */
34054 static unsigned int num_allowable_groups[disp_last] = {
34055   0, 2, 1, 1, 2, 4, 4, 2, 1, BIG, BIG
34056 };
34057
34058 char group_name[disp_last + 1][16] = {
34059   "disp_no_group", "disp_load", "disp_store", "disp_load_store",
34060   "disp_prefetch", "disp_imm", "disp_imm_32", "disp_imm_64",
34061   "disp_branch", "disp_cmp", "disp_jcc", "disp_last"
34062 };
34063
34064 /* Instruction path.  */
34065 enum insn_path {
34066   no_path = 0,
34067   path_single, /* Single micro op.  */
34068   path_double, /* Double micro op.  */
34069   path_multi,  /* Instructions with more than 2 micro op..  */
34070   last_path
34071 };
34072
34073 /* sched_insn_info defines a window to the instructions scheduled in
34074    the basic block.  It contains a pointer to the insn_info table and
34075    the instruction scheduled.
34076
34077    Windows are allocated for each basic block and are linked
34078    together.  */
34079 typedef struct sched_insn_info_s {
34080   rtx insn;
34081   enum dispatch_group group;
34082   enum insn_path path;
34083   int byte_len;
34084   int imm_bytes;
34085 } sched_insn_info;
34086
34087 /* Linked list of dispatch windows.  This is a two way list of
34088    dispatch windows of a basic block.  It contains information about
34089    the number of uops in the window and the total number of
34090    instructions and of bytes in the object code for this dispatch
34091    window.  */
34092 typedef struct dispatch_windows_s {
34093   int num_insn;            /* Number of insn in the window.  */
34094   int num_uops;            /* Number of uops in the window.  */
34095   int window_size;         /* Number of bytes in the window.  */
34096   int window_num;          /* Window number between 0 or 1.  */
34097   int num_imm;             /* Number of immediates in an insn.  */
34098   int num_imm_32;          /* Number of 32 bit immediates in an insn.  */
34099   int num_imm_64;          /* Number of 64 bit immediates in an insn.  */
34100   int imm_size;            /* Total immediates in the window.  */
34101   int num_loads;           /* Total memory loads in the window.  */
34102   int num_stores;          /* Total memory stores in the window.  */
34103   int violation;          /* Violation exists in window.  */
34104   sched_insn_info *window; /* Pointer to the window.  */
34105   struct dispatch_windows_s *next;
34106   struct dispatch_windows_s *prev;
34107 } dispatch_windows;
34108
34109 /* Immediate valuse used in an insn.  */
34110 typedef struct imm_info_s
34111   {
34112     int imm;
34113     int imm32;
34114     int imm64;
34115   } imm_info;
34116
34117 static dispatch_windows *dispatch_window_list;
34118 static dispatch_windows *dispatch_window_list1;
34119
34120 /* Get dispatch group of insn.  */
34121
34122 static enum dispatch_group
34123 get_mem_group (rtx insn)
34124 {
34125   enum attr_memory memory;
34126
34127   if (INSN_CODE (insn) < 0)
34128     return disp_no_group;
34129   memory = get_attr_memory (insn);
34130   if (memory == MEMORY_STORE)
34131     return disp_store;
34132
34133   if (memory == MEMORY_LOAD)
34134     return disp_load;
34135
34136   if (memory == MEMORY_BOTH)
34137     return disp_load_store;
34138
34139   return disp_no_group;
34140 }
34141
34142 /* Return true if insn is a compare instruction.  */
34143
34144 static bool
34145 is_cmp (rtx insn)
34146 {
34147   enum attr_type type;
34148
34149   type = get_attr_type (insn);
34150   return (type == TYPE_TEST
34151           || type == TYPE_ICMP
34152           || type == TYPE_FCMP
34153           || GET_CODE (PATTERN (insn)) == COMPARE);
34154 }
34155
34156 /* Return true if a dispatch violation encountered.  */
34157
34158 static bool
34159 dispatch_violation (void)
34160 {
34161   if (dispatch_window_list->next)
34162     return dispatch_window_list->next->violation;
34163   return dispatch_window_list->violation;
34164 }
34165
34166 /* Return true if insn is a branch instruction.  */
34167
34168 static bool
34169 is_branch (rtx insn)
34170 {
34171   return (CALL_P (insn) || JUMP_P (insn));
34172 }
34173
34174 /* Return true if insn is a prefetch instruction.  */
34175
34176 static bool
34177 is_prefetch (rtx insn)
34178 {
34179   return NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == PREFETCH;
34180 }
34181
34182 /* This function initializes a dispatch window and the list container holding a
34183    pointer to the window.  */
34184
34185 static void
34186 init_window (int window_num)
34187 {
34188   int i;
34189   dispatch_windows *new_list;
34190
34191   if (window_num == 0)
34192     new_list = dispatch_window_list;
34193   else
34194     new_list = dispatch_window_list1;
34195
34196   new_list->num_insn = 0;
34197   new_list->num_uops = 0;
34198   new_list->window_size = 0;
34199   new_list->next = NULL;
34200   new_list->prev = NULL;
34201   new_list->window_num = window_num;
34202   new_list->num_imm = 0;
34203   new_list->num_imm_32 = 0;
34204   new_list->num_imm_64 = 0;
34205   new_list->imm_size = 0;
34206   new_list->num_loads = 0;
34207   new_list->num_stores = 0;
34208   new_list->violation = false;
34209
34210   for (i = 0; i < MAX_INSN; i++)
34211     {
34212       new_list->window[i].insn = NULL;
34213       new_list->window[i].group = disp_no_group;
34214       new_list->window[i].path = no_path;
34215       new_list->window[i].byte_len = 0;
34216       new_list->window[i].imm_bytes = 0;
34217     }
34218   return;
34219 }
34220
34221 /* This function allocates and initializes a dispatch window and the
34222    list container holding a pointer to the window.  */
34223
34224 static dispatch_windows *
34225 allocate_window (void)
34226 {
34227   dispatch_windows *new_list = XNEW (struct dispatch_windows_s);
34228   new_list->window = XNEWVEC (struct sched_insn_info_s, MAX_INSN + 1);
34229
34230   return new_list;
34231 }
34232
34233 /* This routine initializes the dispatch scheduling information.  It
34234    initiates building dispatch scheduler tables and constructs the
34235    first dispatch window.  */
34236
34237 static void
34238 init_dispatch_sched (void)
34239 {
34240   /* Allocate a dispatch list and a window.  */
34241   dispatch_window_list = allocate_window ();
34242   dispatch_window_list1 = allocate_window ();
34243   init_window (0);
34244   init_window (1);
34245 }
34246
34247 /* This function returns true if a branch is detected.  End of a basic block
34248    does not have to be a branch, but here we assume only branches end a
34249    window.  */
34250
34251 static bool
34252 is_end_basic_block (enum dispatch_group group)
34253 {
34254   return group == disp_branch;
34255 }
34256
34257 /* This function is called when the end of a window processing is reached.  */
34258
34259 static void
34260 process_end_window (void)
34261 {
34262   gcc_assert (dispatch_window_list->num_insn <= MAX_INSN);
34263   if (dispatch_window_list->next)
34264     {
34265       gcc_assert (dispatch_window_list1->num_insn <= MAX_INSN);
34266       gcc_assert (dispatch_window_list->window_size
34267                   + dispatch_window_list1->window_size <= 48);
34268       init_window (1);
34269     }
34270   init_window (0);
34271 }
34272
34273 /* Allocates a new dispatch window and adds it to WINDOW_LIST.
34274    WINDOW_NUM is either 0 or 1.  A maximum of two windows are generated
34275    for 48 bytes of instructions.  Note that these windows are not dispatch
34276    windows that their sizes are DISPATCH_WINDOW_SIZE.  */
34277
34278 static dispatch_windows *
34279 allocate_next_window (int window_num)
34280 {
34281   if (window_num == 0)
34282     {
34283       if (dispatch_window_list->next)
34284           init_window (1);
34285       init_window (0);
34286       return dispatch_window_list;
34287     }
34288
34289   dispatch_window_list->next = dispatch_window_list1;
34290   dispatch_window_list1->prev = dispatch_window_list;
34291
34292   return dispatch_window_list1;
34293 }
34294
34295 /* Increment the number of immediate operands of an instruction.  */
34296
34297 static int
34298 find_constant_1 (rtx *in_rtx, imm_info *imm_values)
34299 {
34300   if (*in_rtx == 0)
34301     return 0;
34302
34303     switch ( GET_CODE (*in_rtx))
34304     {
34305     case CONST:
34306     case SYMBOL_REF:
34307     case CONST_INT:
34308       (imm_values->imm)++;
34309       if (x86_64_immediate_operand (*in_rtx, SImode))
34310         (imm_values->imm32)++;
34311       else
34312         (imm_values->imm64)++;
34313       break;
34314
34315     case CONST_DOUBLE:
34316       (imm_values->imm)++;
34317       (imm_values->imm64)++;
34318       break;
34319
34320     case CODE_LABEL:
34321       if (LABEL_KIND (*in_rtx) == LABEL_NORMAL)
34322         {
34323           (imm_values->imm)++;
34324           (imm_values->imm32)++;
34325         }
34326       break;
34327
34328     default:
34329       break;
34330     }
34331
34332   return 0;
34333 }
34334
34335 /* Compute number of immediate operands of an instruction.  */
34336
34337 static void
34338 find_constant (rtx in_rtx, imm_info *imm_values)
34339 {
34340   for_each_rtx (INSN_P (in_rtx) ? &PATTERN (in_rtx) : &in_rtx,
34341                 (rtx_function) find_constant_1, (void *) imm_values);
34342 }
34343
34344 /* Return total size of immediate operands of an instruction along with number
34345    of corresponding immediate-operands.  It initializes its parameters to zero
34346    befor calling FIND_CONSTANT.
34347    INSN is the input instruction.  IMM is the total of immediates.
34348    IMM32 is the number of 32 bit immediates.  IMM64 is the number of 64
34349    bit immediates.  */
34350
34351 static int
34352 get_num_immediates (rtx insn, int *imm, int *imm32, int *imm64)
34353 {
34354   imm_info imm_values = {0, 0, 0};
34355
34356   find_constant (insn, &imm_values);
34357   *imm = imm_values.imm;
34358   *imm32 = imm_values.imm32;
34359   *imm64 = imm_values.imm64;
34360   return imm_values.imm32 * 4 + imm_values.imm64 * 8;
34361 }
34362
34363 /* This function indicates if an operand of an instruction is an
34364    immediate.  */
34365
34366 static bool
34367 has_immediate (rtx insn)
34368 {
34369   int num_imm_operand;
34370   int num_imm32_operand;
34371   int num_imm64_operand;
34372
34373   if (insn)
34374     return get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34375                                &num_imm64_operand);
34376   return false;
34377 }
34378
34379 /* Return single or double path for instructions.  */
34380
34381 static enum insn_path
34382 get_insn_path (rtx insn)
34383 {
34384   enum attr_amdfam10_decode path = get_attr_amdfam10_decode (insn);
34385
34386   if ((int)path == 0)
34387     return path_single;
34388
34389   if ((int)path == 1)
34390     return path_double;
34391
34392   return path_multi;
34393 }
34394
34395 /* Return insn dispatch group.  */
34396
34397 static enum dispatch_group
34398 get_insn_group (rtx insn)
34399 {
34400   enum dispatch_group group = get_mem_group (insn);
34401   if (group)
34402     return group;
34403
34404   if (is_branch (insn))
34405     return disp_branch;
34406
34407   if (is_cmp (insn))
34408     return disp_cmp;
34409
34410   if (has_immediate (insn))
34411     return disp_imm;
34412
34413   if (is_prefetch (insn))
34414     return disp_prefetch;
34415
34416   return disp_no_group;
34417 }
34418
34419 /* Count number of GROUP restricted instructions in a dispatch
34420    window WINDOW_LIST.  */
34421
34422 static int
34423 count_num_restricted (rtx insn, dispatch_windows *window_list)
34424 {
34425   enum dispatch_group group = get_insn_group (insn);
34426   int imm_size;
34427   int num_imm_operand;
34428   int num_imm32_operand;
34429   int num_imm64_operand;
34430
34431   if (group == disp_no_group)
34432     return 0;
34433
34434   if (group == disp_imm)
34435     {
34436       imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34437                               &num_imm64_operand);
34438       if (window_list->imm_size + imm_size > MAX_IMM_SIZE
34439           || num_imm_operand + window_list->num_imm > MAX_IMM
34440           || (num_imm32_operand > 0
34441               && (window_list->num_imm_32 + num_imm32_operand > MAX_IMM_32
34442                   || window_list->num_imm_64 * 2 + num_imm32_operand > MAX_IMM_32))
34443           || (num_imm64_operand > 0
34444               && (window_list->num_imm_64 + num_imm64_operand > MAX_IMM_64
34445                   || window_list->num_imm_32 + num_imm64_operand * 2 > MAX_IMM_32))
34446           || (window_list->imm_size + imm_size == MAX_IMM_SIZE
34447               && num_imm64_operand > 0
34448               && ((window_list->num_imm_64 > 0
34449                    && window_list->num_insn >= 2)
34450                   || window_list->num_insn >= 3)))
34451         return BIG;
34452
34453       return 1;
34454     }
34455
34456   if ((group == disp_load_store
34457        && (window_list->num_loads >= MAX_LOAD
34458            || window_list->num_stores >= MAX_STORE))
34459       || ((group == disp_load
34460            || group == disp_prefetch)
34461           && window_list->num_loads >= MAX_LOAD)
34462       || (group == disp_store
34463           && window_list->num_stores >= MAX_STORE))
34464     return BIG;
34465
34466   return 1;
34467 }
34468
34469 /* This function returns true if insn satisfies dispatch rules on the
34470    last window scheduled.  */
34471
34472 static bool
34473 fits_dispatch_window (rtx insn)
34474 {
34475   dispatch_windows *window_list = dispatch_window_list;
34476   dispatch_windows *window_list_next = dispatch_window_list->next;
34477   unsigned int num_restrict;
34478   enum dispatch_group group = get_insn_group (insn);
34479   enum insn_path path = get_insn_path (insn);
34480   int sum;
34481
34482   /* Make disp_cmp and disp_jcc get scheduled at the latest.  These
34483      instructions should be given the lowest priority in the
34484      scheduling process in Haifa scheduler to make sure they will be
34485      scheduled in the same dispatch window as the refrence to them.  */
34486   if (group == disp_jcc || group == disp_cmp)
34487     return false;
34488
34489   /* Check nonrestricted.  */
34490   if (group == disp_no_group || group == disp_branch)
34491     return true;
34492
34493   /* Get last dispatch window.  */
34494   if (window_list_next)
34495     window_list = window_list_next;
34496
34497   if (window_list->window_num == 1)
34498     {
34499       sum = window_list->prev->window_size + window_list->window_size;
34500
34501       if (sum == 32
34502           || (min_insn_size (insn) + sum) >= 48)
34503         /* Window 1 is full.  Go for next window.  */
34504         return true;
34505     }
34506
34507   num_restrict = count_num_restricted (insn, window_list);
34508
34509   if (num_restrict > num_allowable_groups[group])
34510     return false;
34511
34512   /* See if it fits in the first window.  */
34513   if (window_list->window_num == 0)
34514     {
34515       /* The first widow should have only single and double path
34516          uops.  */
34517       if (path == path_double
34518           && (window_list->num_uops + 2) > MAX_INSN)
34519         return false;
34520       else if (path != path_single)
34521         return false;
34522     }
34523   return true;
34524 }
34525
34526 /* Add an instruction INSN with NUM_UOPS micro-operations to the
34527    dispatch window WINDOW_LIST.  */
34528
34529 static void
34530 add_insn_window (rtx insn, dispatch_windows *window_list, int num_uops)
34531 {
34532   int byte_len = min_insn_size (insn);
34533   int num_insn = window_list->num_insn;
34534   int imm_size;
34535   sched_insn_info *window = window_list->window;
34536   enum dispatch_group group = get_insn_group (insn);
34537   enum insn_path path = get_insn_path (insn);
34538   int num_imm_operand;
34539   int num_imm32_operand;
34540   int num_imm64_operand;
34541
34542   if (!window_list->violation && group != disp_cmp
34543       && !fits_dispatch_window (insn))
34544     window_list->violation = true;
34545
34546   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34547                                  &num_imm64_operand);
34548
34549   /* Initialize window with new instruction.  */
34550   window[num_insn].insn = insn;
34551   window[num_insn].byte_len = byte_len;
34552   window[num_insn].group = group;
34553   window[num_insn].path = path;
34554   window[num_insn].imm_bytes = imm_size;
34555
34556   window_list->window_size += byte_len;
34557   window_list->num_insn = num_insn + 1;
34558   window_list->num_uops = window_list->num_uops + num_uops;
34559   window_list->imm_size += imm_size;
34560   window_list->num_imm += num_imm_operand;
34561   window_list->num_imm_32 += num_imm32_operand;
34562   window_list->num_imm_64 += num_imm64_operand;
34563
34564   if (group == disp_store)
34565     window_list->num_stores += 1;
34566   else if (group == disp_load
34567            || group == disp_prefetch)
34568     window_list->num_loads += 1;
34569   else if (group == disp_load_store)
34570     {
34571       window_list->num_stores += 1;
34572       window_list->num_loads += 1;
34573     }
34574 }
34575
34576 /* Adds a scheduled instruction, INSN, to the current dispatch window.
34577    If the total bytes of instructions or the number of instructions in
34578    the window exceed allowable, it allocates a new window.  */
34579
34580 static void
34581 add_to_dispatch_window (rtx insn)
34582 {
34583   int byte_len;
34584   dispatch_windows *window_list;
34585   dispatch_windows *next_list;
34586   dispatch_windows *window0_list;
34587   enum insn_path path;
34588   enum dispatch_group insn_group;
34589   bool insn_fits;
34590   int num_insn;
34591   int num_uops;
34592   int window_num;
34593   int insn_num_uops;
34594   int sum;
34595
34596   if (INSN_CODE (insn) < 0)
34597     return;
34598
34599   byte_len = min_insn_size (insn);
34600   window_list = dispatch_window_list;
34601   next_list = window_list->next;
34602   path = get_insn_path (insn);
34603   insn_group = get_insn_group (insn);
34604
34605   /* Get the last dispatch window.  */
34606   if (next_list)
34607       window_list = dispatch_window_list->next;
34608
34609   if (path == path_single)
34610     insn_num_uops = 1;
34611   else if (path == path_double)
34612     insn_num_uops = 2;
34613   else
34614     insn_num_uops = (int) path;
34615
34616   /* If current window is full, get a new window.
34617      Window number zero is full, if MAX_INSN uops are scheduled in it.
34618      Window number one is full, if window zero's bytes plus window
34619      one's bytes is 32, or if the bytes of the new instruction added
34620      to the total makes it greater than 48, or it has already MAX_INSN
34621      instructions in it.  */
34622   num_insn = window_list->num_insn;
34623   num_uops = window_list->num_uops;
34624   window_num = window_list->window_num;
34625   insn_fits = fits_dispatch_window (insn);
34626
34627   if (num_insn >= MAX_INSN
34628       || num_uops + insn_num_uops > MAX_INSN
34629       || !(insn_fits))
34630     {
34631       window_num = ~window_num & 1;
34632       window_list = allocate_next_window (window_num);
34633     }
34634
34635   if (window_num == 0)
34636     {
34637       add_insn_window (insn, window_list, insn_num_uops);
34638       if (window_list->num_insn >= MAX_INSN
34639           && insn_group == disp_branch)
34640         {
34641           process_end_window ();
34642           return;
34643         }
34644     }
34645   else if (window_num == 1)
34646     {
34647       window0_list = window_list->prev;
34648       sum = window0_list->window_size + window_list->window_size;
34649       if (sum == 32
34650           || (byte_len + sum) >= 48)
34651         {
34652           process_end_window ();
34653           window_list = dispatch_window_list;
34654         }
34655
34656       add_insn_window (insn, window_list, insn_num_uops);
34657     }
34658   else
34659     gcc_unreachable ();
34660
34661   if (is_end_basic_block (insn_group))
34662     {
34663       /* End of basic block is reached do end-basic-block process.  */
34664       process_end_window ();
34665       return;
34666     }
34667 }
34668
34669 /* Print the dispatch window, WINDOW_NUM, to FILE.  */
34670
34671 DEBUG_FUNCTION static void
34672 debug_dispatch_window_file (FILE *file, int window_num)
34673 {
34674   dispatch_windows *list;
34675   int i;
34676
34677   if (window_num == 0)
34678     list = dispatch_window_list;
34679   else
34680     list = dispatch_window_list1;
34681
34682   fprintf (file, "Window #%d:\n", list->window_num);
34683   fprintf (file, "  num_insn = %d, num_uops = %d, window_size = %d\n",
34684           list->num_insn, list->num_uops, list->window_size);
34685   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
34686            list->num_imm, list->num_imm_32, list->num_imm_64, list->imm_size);
34687
34688   fprintf (file, "  num_loads = %d, num_stores = %d\n", list->num_loads,
34689           list->num_stores);
34690   fprintf (file, " insn info:\n");
34691
34692   for (i = 0; i < MAX_INSN; i++)
34693     {
34694       if (!list->window[i].insn)
34695         break;
34696       fprintf (file, "    group[%d] = %s, insn[%d] = %p, path[%d] = %d byte_len[%d] = %d, imm_bytes[%d] = %d\n",
34697               i, group_name[list->window[i].group],
34698               i, (void *)list->window[i].insn,
34699               i, list->window[i].path,
34700               i, list->window[i].byte_len,
34701               i, list->window[i].imm_bytes);
34702     }
34703 }
34704
34705 /* Print to stdout a dispatch window.  */
34706
34707 DEBUG_FUNCTION void
34708 debug_dispatch_window (int window_num)
34709 {
34710   debug_dispatch_window_file (stdout, window_num);
34711 }
34712
34713 /* Print INSN dispatch information to FILE.  */
34714
34715 DEBUG_FUNCTION static void
34716 debug_insn_dispatch_info_file (FILE *file, rtx insn)
34717 {
34718   int byte_len;
34719   enum insn_path path;
34720   enum dispatch_group group;
34721   int imm_size;
34722   int num_imm_operand;
34723   int num_imm32_operand;
34724   int num_imm64_operand;
34725
34726   if (INSN_CODE (insn) < 0)
34727     return;
34728
34729   byte_len = min_insn_size (insn);
34730   path = get_insn_path (insn);
34731   group = get_insn_group (insn);
34732   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
34733                                  &num_imm64_operand);
34734
34735   fprintf (file, " insn info:\n");
34736   fprintf (file, "  group = %s, path = %d, byte_len = %d\n",
34737            group_name[group], path, byte_len);
34738   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
34739            num_imm_operand, num_imm32_operand, num_imm64_operand, imm_size);
34740 }
34741
34742 /* Print to STDERR the status of the ready list with respect to
34743    dispatch windows.  */
34744
34745 DEBUG_FUNCTION void
34746 debug_ready_dispatch (void)
34747 {
34748   int i;
34749   int no_ready = number_in_ready ();
34750
34751   fprintf (stdout, "Number of ready: %d\n", no_ready);
34752
34753   for (i = 0; i < no_ready; i++)
34754     debug_insn_dispatch_info_file (stdout, get_ready_element (i));
34755 }
34756
34757 /* This routine is the driver of the dispatch scheduler.  */
34758
34759 static void
34760 do_dispatch (rtx insn, int mode)
34761 {
34762   if (mode == DISPATCH_INIT)
34763     init_dispatch_sched ();
34764   else if (mode == ADD_TO_DISPATCH_WINDOW)
34765     add_to_dispatch_window (insn);
34766 }
34767
34768 /* Return TRUE if Dispatch Scheduling is supported.  */
34769
34770 static bool
34771 has_dispatch (rtx insn, int action)
34772 {
34773   if ((ix86_tune == PROCESSOR_BDVER1 || ix86_tune == PROCESSOR_BDVER2)
34774       && flag_dispatch_scheduler)
34775     switch (action)
34776       {
34777       default:
34778         return false;
34779
34780       case IS_DISPATCH_ON:
34781         return true;
34782         break;
34783
34784       case IS_CMP:
34785         return is_cmp (insn);
34786
34787       case DISPATCH_VIOLATION:
34788         return dispatch_violation ();
34789
34790       case FITS_DISPATCH_WINDOW:
34791         return fits_dispatch_window (insn);
34792       }
34793
34794   return false;
34795 }
34796
34797 /* ??? No autovectorization into MMX or 3DNOW until we can reliably
34798    place emms and femms instructions.  */
34799
34800 static enum machine_mode
34801 ix86_preferred_simd_mode (enum machine_mode mode)
34802 {
34803   if (!TARGET_SSE)
34804     return word_mode;
34805
34806   switch (mode)
34807     {
34808     case QImode:
34809       return V16QImode;
34810     case HImode:
34811       return V8HImode;
34812     case SImode:
34813       return V4SImode;
34814     case DImode:
34815       return V2DImode;
34816
34817     case SFmode:
34818       if (TARGET_AVX && !TARGET_PREFER_AVX128)
34819         return V8SFmode;
34820       else
34821         return V4SFmode;
34822
34823     case DFmode:
34824       if (!TARGET_VECTORIZE_DOUBLE)
34825         return word_mode;
34826       else if (TARGET_AVX && !TARGET_PREFER_AVX128)
34827         return V4DFmode;
34828       else if (TARGET_SSE2)
34829         return V2DFmode;
34830       /* FALLTHRU */
34831
34832     default:
34833       return word_mode;
34834     }
34835 }
34836
34837 /* If AVX is enabled then try vectorizing with both 256bit and 128bit
34838    vectors.  */
34839
34840 static unsigned int
34841 ix86_autovectorize_vector_sizes (void)
34842 {
34843   return (TARGET_AVX && !TARGET_PREFER_AVX128) ? 32 | 16 : 0;
34844 }
34845
34846 /* Initialize the GCC target structure.  */
34847 #undef TARGET_RETURN_IN_MEMORY
34848 #define TARGET_RETURN_IN_MEMORY ix86_return_in_memory
34849
34850 #undef TARGET_LEGITIMIZE_ADDRESS
34851 #define TARGET_LEGITIMIZE_ADDRESS ix86_legitimize_address
34852
34853 #undef TARGET_ATTRIBUTE_TABLE
34854 #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table
34855 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
34856 #  undef TARGET_MERGE_DECL_ATTRIBUTES
34857 #  define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
34858 #endif
34859
34860 #undef TARGET_COMP_TYPE_ATTRIBUTES
34861 #define TARGET_COMP_TYPE_ATTRIBUTES ix86_comp_type_attributes
34862
34863 #undef TARGET_INIT_BUILTINS
34864 #define TARGET_INIT_BUILTINS ix86_init_builtins
34865 #undef TARGET_BUILTIN_DECL
34866 #define TARGET_BUILTIN_DECL ix86_builtin_decl
34867 #undef TARGET_EXPAND_BUILTIN
34868 #define TARGET_EXPAND_BUILTIN ix86_expand_builtin
34869
34870 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
34871 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
34872   ix86_builtin_vectorized_function
34873
34874 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
34875 #define TARGET_VECTORIZE_BUILTIN_CONVERSION ix86_vectorize_builtin_conversion
34876
34877 #undef TARGET_BUILTIN_RECIPROCAL
34878 #define TARGET_BUILTIN_RECIPROCAL ix86_builtin_reciprocal
34879
34880 #undef TARGET_ASM_FUNCTION_EPILOGUE
34881 #define TARGET_ASM_FUNCTION_EPILOGUE ix86_output_function_epilogue
34882
34883 #undef TARGET_ENCODE_SECTION_INFO
34884 #ifndef SUBTARGET_ENCODE_SECTION_INFO
34885 #define TARGET_ENCODE_SECTION_INFO ix86_encode_section_info
34886 #else
34887 #define TARGET_ENCODE_SECTION_INFO SUBTARGET_ENCODE_SECTION_INFO
34888 #endif
34889
34890 #undef TARGET_ASM_OPEN_PAREN
34891 #define TARGET_ASM_OPEN_PAREN ""
34892 #undef TARGET_ASM_CLOSE_PAREN
34893 #define TARGET_ASM_CLOSE_PAREN ""
34894
34895 #undef TARGET_ASM_BYTE_OP
34896 #define TARGET_ASM_BYTE_OP ASM_BYTE
34897
34898 #undef TARGET_ASM_ALIGNED_HI_OP
34899 #define TARGET_ASM_ALIGNED_HI_OP ASM_SHORT
34900 #undef TARGET_ASM_ALIGNED_SI_OP
34901 #define TARGET_ASM_ALIGNED_SI_OP ASM_LONG
34902 #ifdef ASM_QUAD
34903 #undef TARGET_ASM_ALIGNED_DI_OP
34904 #define TARGET_ASM_ALIGNED_DI_OP ASM_QUAD
34905 #endif
34906
34907 #undef TARGET_PROFILE_BEFORE_PROLOGUE
34908 #define TARGET_PROFILE_BEFORE_PROLOGUE ix86_profile_before_prologue
34909
34910 #undef TARGET_ASM_UNALIGNED_HI_OP
34911 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
34912 #undef TARGET_ASM_UNALIGNED_SI_OP
34913 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
34914 #undef TARGET_ASM_UNALIGNED_DI_OP
34915 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
34916
34917 #undef TARGET_PRINT_OPERAND
34918 #define TARGET_PRINT_OPERAND ix86_print_operand
34919 #undef TARGET_PRINT_OPERAND_ADDRESS
34920 #define TARGET_PRINT_OPERAND_ADDRESS ix86_print_operand_address
34921 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
34922 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P ix86_print_operand_punct_valid_p
34923 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
34924 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA i386_asm_output_addr_const_extra
34925
34926 #undef TARGET_SCHED_INIT_GLOBAL
34927 #define TARGET_SCHED_INIT_GLOBAL ix86_sched_init_global
34928 #undef TARGET_SCHED_ADJUST_COST
34929 #define TARGET_SCHED_ADJUST_COST ix86_adjust_cost
34930 #undef TARGET_SCHED_ISSUE_RATE
34931 #define TARGET_SCHED_ISSUE_RATE ix86_issue_rate
34932 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
34933 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
34934   ia32_multipass_dfa_lookahead
34935
34936 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
34937 #define TARGET_FUNCTION_OK_FOR_SIBCALL ix86_function_ok_for_sibcall
34938
34939 #ifdef HAVE_AS_TLS
34940 #undef TARGET_HAVE_TLS
34941 #define TARGET_HAVE_TLS true
34942 #endif
34943 #undef TARGET_CANNOT_FORCE_CONST_MEM
34944 #define TARGET_CANNOT_FORCE_CONST_MEM ix86_cannot_force_const_mem
34945 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
34946 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_const_rtx_true
34947
34948 #undef TARGET_DELEGITIMIZE_ADDRESS
34949 #define TARGET_DELEGITIMIZE_ADDRESS ix86_delegitimize_address
34950
34951 #undef TARGET_MS_BITFIELD_LAYOUT_P
34952 #define TARGET_MS_BITFIELD_LAYOUT_P ix86_ms_bitfield_layout_p
34953
34954 #if TARGET_MACHO
34955 #undef TARGET_BINDS_LOCAL_P
34956 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
34957 #endif
34958 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
34959 #undef TARGET_BINDS_LOCAL_P
34960 #define TARGET_BINDS_LOCAL_P i386_pe_binds_local_p
34961 #endif
34962
34963 #undef TARGET_ASM_OUTPUT_MI_THUNK
34964 #define TARGET_ASM_OUTPUT_MI_THUNK x86_output_mi_thunk
34965 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
34966 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK x86_can_output_mi_thunk
34967
34968 #undef TARGET_ASM_FILE_START
34969 #define TARGET_ASM_FILE_START x86_file_start
34970
34971 #undef TARGET_OPTION_OVERRIDE
34972 #define TARGET_OPTION_OVERRIDE ix86_option_override
34973
34974 #undef TARGET_REGISTER_MOVE_COST
34975 #define TARGET_REGISTER_MOVE_COST ix86_register_move_cost
34976 #undef TARGET_MEMORY_MOVE_COST
34977 #define TARGET_MEMORY_MOVE_COST ix86_memory_move_cost
34978 #undef TARGET_RTX_COSTS
34979 #define TARGET_RTX_COSTS ix86_rtx_costs
34980 #undef TARGET_ADDRESS_COST
34981 #define TARGET_ADDRESS_COST ix86_address_cost
34982
34983 #undef TARGET_FIXED_CONDITION_CODE_REGS
34984 #define TARGET_FIXED_CONDITION_CODE_REGS ix86_fixed_condition_code_regs
34985 #undef TARGET_CC_MODES_COMPATIBLE
34986 #define TARGET_CC_MODES_COMPATIBLE ix86_cc_modes_compatible
34987
34988 #undef TARGET_MACHINE_DEPENDENT_REORG
34989 #define TARGET_MACHINE_DEPENDENT_REORG ix86_reorg
34990
34991 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
34992 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE ix86_builtin_setjmp_frame_value
34993
34994 #undef TARGET_BUILD_BUILTIN_VA_LIST
34995 #define TARGET_BUILD_BUILTIN_VA_LIST ix86_build_builtin_va_list
34996
34997 #undef TARGET_ENUM_VA_LIST_P
34998 #define TARGET_ENUM_VA_LIST_P ix86_enum_va_list
34999
35000 #undef TARGET_FN_ABI_VA_LIST
35001 #define TARGET_FN_ABI_VA_LIST ix86_fn_abi_va_list
35002
35003 #undef TARGET_CANONICAL_VA_LIST_TYPE
35004 #define TARGET_CANONICAL_VA_LIST_TYPE ix86_canonical_va_list_type
35005
35006 #undef TARGET_EXPAND_BUILTIN_VA_START
35007 #define TARGET_EXPAND_BUILTIN_VA_START ix86_va_start
35008
35009 #undef TARGET_MD_ASM_CLOBBERS
35010 #define TARGET_MD_ASM_CLOBBERS ix86_md_asm_clobbers
35011
35012 #undef TARGET_PROMOTE_PROTOTYPES
35013 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
35014 #undef TARGET_STRUCT_VALUE_RTX
35015 #define TARGET_STRUCT_VALUE_RTX ix86_struct_value_rtx
35016 #undef TARGET_SETUP_INCOMING_VARARGS
35017 #define TARGET_SETUP_INCOMING_VARARGS ix86_setup_incoming_varargs
35018 #undef TARGET_MUST_PASS_IN_STACK
35019 #define TARGET_MUST_PASS_IN_STACK ix86_must_pass_in_stack
35020 #undef TARGET_FUNCTION_ARG_ADVANCE
35021 #define TARGET_FUNCTION_ARG_ADVANCE ix86_function_arg_advance
35022 #undef TARGET_FUNCTION_ARG
35023 #define TARGET_FUNCTION_ARG ix86_function_arg
35024 #undef TARGET_FUNCTION_ARG_BOUNDARY
35025 #define TARGET_FUNCTION_ARG_BOUNDARY ix86_function_arg_boundary
35026 #undef TARGET_PASS_BY_REFERENCE
35027 #define TARGET_PASS_BY_REFERENCE ix86_pass_by_reference
35028 #undef TARGET_INTERNAL_ARG_POINTER
35029 #define TARGET_INTERNAL_ARG_POINTER ix86_internal_arg_pointer
35030 #undef TARGET_UPDATE_STACK_BOUNDARY
35031 #define TARGET_UPDATE_STACK_BOUNDARY ix86_update_stack_boundary
35032 #undef TARGET_GET_DRAP_RTX
35033 #define TARGET_GET_DRAP_RTX ix86_get_drap_rtx
35034 #undef TARGET_STRICT_ARGUMENT_NAMING
35035 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
35036 #undef TARGET_STATIC_CHAIN
35037 #define TARGET_STATIC_CHAIN ix86_static_chain
35038 #undef TARGET_TRAMPOLINE_INIT
35039 #define TARGET_TRAMPOLINE_INIT ix86_trampoline_init
35040 #undef TARGET_RETURN_POPS_ARGS
35041 #define TARGET_RETURN_POPS_ARGS ix86_return_pops_args
35042
35043 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
35044 #define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
35045
35046 #undef TARGET_SCALAR_MODE_SUPPORTED_P
35047 #define TARGET_SCALAR_MODE_SUPPORTED_P ix86_scalar_mode_supported_p
35048
35049 #undef TARGET_VECTOR_MODE_SUPPORTED_P
35050 #define TARGET_VECTOR_MODE_SUPPORTED_P ix86_vector_mode_supported_p
35051
35052 #undef TARGET_C_MODE_FOR_SUFFIX
35053 #define TARGET_C_MODE_FOR_SUFFIX ix86_c_mode_for_suffix
35054
35055 #ifdef HAVE_AS_TLS
35056 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
35057 #define TARGET_ASM_OUTPUT_DWARF_DTPREL i386_output_dwarf_dtprel
35058 #endif
35059
35060 #ifdef SUBTARGET_INSERT_ATTRIBUTES
35061 #undef TARGET_INSERT_ATTRIBUTES
35062 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
35063 #endif
35064
35065 #undef TARGET_MANGLE_TYPE
35066 #define TARGET_MANGLE_TYPE ix86_mangle_type
35067
35068 #ifndef TARGET_MACHO
35069 #undef TARGET_STACK_PROTECT_FAIL
35070 #define TARGET_STACK_PROTECT_FAIL ix86_stack_protect_fail
35071 #endif
35072
35073 #undef TARGET_FUNCTION_VALUE
35074 #define TARGET_FUNCTION_VALUE ix86_function_value
35075
35076 #undef TARGET_FUNCTION_VALUE_REGNO_P
35077 #define TARGET_FUNCTION_VALUE_REGNO_P ix86_function_value_regno_p
35078
35079 #undef TARGET_PROMOTE_FUNCTION_MODE
35080 #define TARGET_PROMOTE_FUNCTION_MODE ix86_promote_function_mode
35081
35082 #undef TARGET_SECONDARY_RELOAD
35083 #define TARGET_SECONDARY_RELOAD ix86_secondary_reload
35084
35085 #undef TARGET_CLASS_MAX_NREGS
35086 #define TARGET_CLASS_MAX_NREGS ix86_class_max_nregs
35087
35088 #undef TARGET_PREFERRED_RELOAD_CLASS
35089 #define TARGET_PREFERRED_RELOAD_CLASS ix86_preferred_reload_class
35090 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
35091 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS ix86_preferred_output_reload_class
35092 #undef TARGET_CLASS_LIKELY_SPILLED_P
35093 #define TARGET_CLASS_LIKELY_SPILLED_P ix86_class_likely_spilled_p
35094
35095 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
35096 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
35097   ix86_builtin_vectorization_cost
35098 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
35099 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM \
35100   ix86_vectorize_builtin_vec_perm
35101 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK
35102 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK \
35103   ix86_vectorize_builtin_vec_perm_ok
35104 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
35105 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
35106   ix86_preferred_simd_mode
35107 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
35108 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
35109   ix86_autovectorize_vector_sizes
35110
35111 #undef TARGET_SET_CURRENT_FUNCTION
35112 #define TARGET_SET_CURRENT_FUNCTION ix86_set_current_function
35113
35114 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
35115 #define TARGET_OPTION_VALID_ATTRIBUTE_P ix86_valid_target_attribute_p
35116
35117 #undef TARGET_OPTION_SAVE
35118 #define TARGET_OPTION_SAVE ix86_function_specific_save
35119
35120 #undef TARGET_OPTION_RESTORE
35121 #define TARGET_OPTION_RESTORE ix86_function_specific_restore
35122
35123 #undef TARGET_OPTION_PRINT
35124 #define TARGET_OPTION_PRINT ix86_function_specific_print
35125
35126 #undef TARGET_CAN_INLINE_P
35127 #define TARGET_CAN_INLINE_P ix86_can_inline_p
35128
35129 #undef TARGET_EXPAND_TO_RTL_HOOK
35130 #define TARGET_EXPAND_TO_RTL_HOOK ix86_maybe_switch_abi
35131
35132 #undef TARGET_LEGITIMATE_ADDRESS_P
35133 #define TARGET_LEGITIMATE_ADDRESS_P ix86_legitimate_address_p
35134
35135 #undef TARGET_LEGITIMATE_CONSTANT_P
35136 #define TARGET_LEGITIMATE_CONSTANT_P ix86_legitimate_constant_p
35137
35138 #undef TARGET_FRAME_POINTER_REQUIRED
35139 #define TARGET_FRAME_POINTER_REQUIRED ix86_frame_pointer_required
35140
35141 #undef TARGET_CAN_ELIMINATE
35142 #define TARGET_CAN_ELIMINATE ix86_can_eliminate
35143
35144 #undef TARGET_EXTRA_LIVE_ON_ENTRY
35145 #define TARGET_EXTRA_LIVE_ON_ENTRY ix86_live_on_entry
35146
35147 #undef TARGET_ASM_CODE_END
35148 #define TARGET_ASM_CODE_END ix86_code_end
35149
35150 #undef TARGET_CONDITIONAL_REGISTER_USAGE
35151 #define TARGET_CONDITIONAL_REGISTER_USAGE ix86_conditional_register_usage
35152
35153 #if TARGET_MACHO
35154 #undef TARGET_INIT_LIBFUNCS
35155 #define TARGET_INIT_LIBFUNCS darwin_rename_builtins
35156 #endif
35157
35158 struct gcc_target targetm = TARGET_INITIALIZER;
35159 \f
35160 #include "gt-i386.h"