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, 2012
   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   4,                                    /* 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   /* X86_TUNE_REASSOC_INT_TO_PARALLEL: Try to produce parallel computations
2174      during reassociation of integer computation.  */
2175   m_ATOM,
2176
2177   /* X86_TUNE_REASSOC_FP_TO_PARALLEL: Try to produce parallel computations
2178      during reassociation of fp computation.  */
2179   m_ATOM
2180 };
2181
2182 /* Feature tests against the various architecture variations.  */
2183 unsigned char ix86_arch_features[X86_ARCH_LAST];
2184
2185 /* Feature tests against the various architecture variations, used to create
2186    ix86_arch_features based on the processor mask.  */
2187 static unsigned int initial_ix86_arch_features[X86_ARCH_LAST] = {
2188   /* X86_ARCH_CMOVE: Conditional move was added for pentiumpro.  */
2189   ~(m_386 | m_486 | m_PENT | m_K6),
2190
2191   /* X86_ARCH_CMPXCHG: Compare and exchange was added for 80486.  */
2192   ~m_386,
2193
2194   /* X86_ARCH_CMPXCHG8B: Compare and exchange 8 bytes was added for pentium. */
2195   ~(m_386 | m_486),
2196
2197   /* X86_ARCH_XADD: Exchange and add was added for 80486.  */
2198   ~m_386,
2199
2200   /* X86_ARCH_BSWAP: Byteswap was added for 80486.  */
2201   ~m_386,
2202 };
2203
2204 static const unsigned int x86_accumulate_outgoing_args
2205   = m_PPRO | m_P4_NOCONA | m_ATOM | m_CORE2I7 | m_AMD_MULTIPLE | m_GENERIC;
2206
2207 static const unsigned int x86_arch_always_fancy_math_387
2208   = m_PENT | m_PPRO | m_P4_NOCONA | m_CORE2I7 | m_ATOM | m_AMD_MULTIPLE | m_GENERIC;
2209
2210 static const unsigned int x86_avx256_split_unaligned_load
2211   = m_COREI7 | m_GENERIC;
2212
2213 static const unsigned int x86_avx256_split_unaligned_store
2214   = m_COREI7 | m_BDVER | m_GENERIC;
2215
2216 /* In case the average insn count for single function invocation is
2217    lower than this constant, emit fast (but longer) prologue and
2218    epilogue code.  */
2219 #define FAST_PROLOGUE_INSN_COUNT 20
2220
2221 /* Names for 8 (low), 8 (high), and 16-bit registers, respectively.  */
2222 static const char *const qi_reg_name[] = QI_REGISTER_NAMES;
2223 static const char *const qi_high_reg_name[] = QI_HIGH_REGISTER_NAMES;
2224 static const char *const hi_reg_name[] = HI_REGISTER_NAMES;
2225
2226 /* Array of the smallest class containing reg number REGNO, indexed by
2227    REGNO.  Used by REGNO_REG_CLASS in i386.h.  */
2228
2229 enum reg_class const regclass_map[FIRST_PSEUDO_REGISTER] =
2230 {
2231   /* ax, dx, cx, bx */
2232   AREG, DREG, CREG, BREG,
2233   /* si, di, bp, sp */
2234   SIREG, DIREG, NON_Q_REGS, NON_Q_REGS,
2235   /* FP registers */
2236   FP_TOP_REG, FP_SECOND_REG, FLOAT_REGS, FLOAT_REGS,
2237   FLOAT_REGS, FLOAT_REGS, FLOAT_REGS, FLOAT_REGS,
2238   /* arg pointer */
2239   NON_Q_REGS,
2240   /* flags, fpsr, fpcr, frame */
2241   NO_REGS, NO_REGS, NO_REGS, NON_Q_REGS,
2242   /* SSE registers */
2243   SSE_FIRST_REG, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2244   SSE_REGS, SSE_REGS,
2245   /* MMX registers */
2246   MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS, MMX_REGS,
2247   MMX_REGS, MMX_REGS,
2248   /* REX registers */
2249   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2250   NON_Q_REGS, NON_Q_REGS, NON_Q_REGS, NON_Q_REGS,
2251   /* SSE REX registers */
2252   SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS, SSE_REGS,
2253   SSE_REGS, SSE_REGS,
2254 };
2255
2256 /* The "default" register map used in 32bit mode.  */
2257
2258 int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
2259 {
2260   0, 2, 1, 3, 6, 7, 4, 5,               /* general regs */
2261   12, 13, 14, 15, 16, 17, 18, 19,       /* fp regs */
2262   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2263   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE */
2264   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX */
2265   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2266   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2267 };
2268
2269 /* The "default" register map used in 64bit mode.  */
2270
2271 int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
2272 {
2273   0, 1, 2, 3, 4, 5, 6, 7,               /* general regs */
2274   33, 34, 35, 36, 37, 38, 39, 40,       /* fp regs */
2275   -1, -1, -1, -1, -1,                   /* arg, flags, fpsr, fpcr, frame */
2276   17, 18, 19, 20, 21, 22, 23, 24,       /* SSE */
2277   41, 42, 43, 44, 45, 46, 47, 48,       /* MMX */
2278   8,9,10,11,12,13,14,15,                /* extended integer registers */
2279   25, 26, 27, 28, 29, 30, 31, 32,       /* extended SSE registers */
2280 };
2281
2282 /* Define the register numbers to be used in Dwarf debugging information.
2283    The SVR4 reference port C compiler uses the following register numbers
2284    in its Dwarf output code:
2285         0 for %eax (gcc regno = 0)
2286         1 for %ecx (gcc regno = 2)
2287         2 for %edx (gcc regno = 1)
2288         3 for %ebx (gcc regno = 3)
2289         4 for %esp (gcc regno = 7)
2290         5 for %ebp (gcc regno = 6)
2291         6 for %esi (gcc regno = 4)
2292         7 for %edi (gcc regno = 5)
2293    The following three DWARF register numbers are never generated by
2294    the SVR4 C compiler or by the GNU compilers, but SDB on x86/svr4
2295    believes these numbers have these meanings.
2296         8  for %eip    (no gcc equivalent)
2297         9  for %eflags (gcc regno = 17)
2298         10 for %trapno (no gcc equivalent)
2299    It is not at all clear how we should number the FP stack registers
2300    for the x86 architecture.  If the version of SDB on x86/svr4 were
2301    a bit less brain dead with respect to floating-point then we would
2302    have a precedent to follow with respect to DWARF register numbers
2303    for x86 FP registers, but the SDB on x86/svr4 is so completely
2304    broken with respect to FP registers that it is hardly worth thinking
2305    of it as something to strive for compatibility with.
2306    The version of x86/svr4 SDB I have at the moment does (partially)
2307    seem to believe that DWARF register number 11 is associated with
2308    the x86 register %st(0), but that's about all.  Higher DWARF
2309    register numbers don't seem to be associated with anything in
2310    particular, and even for DWARF regno 11, SDB only seems to under-
2311    stand that it should say that a variable lives in %st(0) (when
2312    asked via an `=' command) if we said it was in DWARF regno 11,
2313    but SDB still prints garbage when asked for the value of the
2314    variable in question (via a `/' command).
2315    (Also note that the labels SDB prints for various FP stack regs
2316    when doing an `x' command are all wrong.)
2317    Note that these problems generally don't affect the native SVR4
2318    C compiler because it doesn't allow the use of -O with -g and
2319    because when it is *not* optimizing, it allocates a memory
2320    location for each floating-point variable, and the memory
2321    location is what gets described in the DWARF AT_location
2322    attribute for the variable in question.
2323    Regardless of the severe mental illness of the x86/svr4 SDB, we
2324    do something sensible here and we use the following DWARF
2325    register numbers.  Note that these are all stack-top-relative
2326    numbers.
2327         11 for %st(0) (gcc regno = 8)
2328         12 for %st(1) (gcc regno = 9)
2329         13 for %st(2) (gcc regno = 10)
2330         14 for %st(3) (gcc regno = 11)
2331         15 for %st(4) (gcc regno = 12)
2332         16 for %st(5) (gcc regno = 13)
2333         17 for %st(6) (gcc regno = 14)
2334         18 for %st(7) (gcc regno = 15)
2335 */
2336 int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
2337 {
2338   0, 2, 1, 3, 6, 7, 5, 4,               /* general regs */
2339   11, 12, 13, 14, 15, 16, 17, 18,       /* fp regs */
2340   -1, 9, -1, -1, -1,                    /* arg, flags, fpsr, fpcr, frame */
2341   21, 22, 23, 24, 25, 26, 27, 28,       /* SSE registers */
2342   29, 30, 31, 32, 33, 34, 35, 36,       /* MMX registers */
2343   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended integer registers */
2344   -1, -1, -1, -1, -1, -1, -1, -1,       /* extended SSE registers */
2345 };
2346
2347 /* Define parameter passing and return registers.  */
2348
2349 static int const x86_64_int_parameter_registers[6] =
2350 {
2351   DI_REG, SI_REG, DX_REG, CX_REG, R8_REG, R9_REG
2352 };
2353
2354 static int const x86_64_ms_abi_int_parameter_registers[4] =
2355 {
2356   CX_REG, DX_REG, R8_REG, R9_REG
2357 };
2358
2359 static int const x86_64_int_return_registers[4] =
2360 {
2361   AX_REG, DX_REG, DI_REG, SI_REG
2362 };
2363
2364 /* Define the structure for the machine field in struct function.  */
2365
2366 struct GTY(()) stack_local_entry {
2367   unsigned short mode;
2368   unsigned short n;
2369   rtx rtl;
2370   struct stack_local_entry *next;
2371 };
2372
2373 /* Structure describing stack frame layout.
2374    Stack grows downward:
2375
2376    [arguments]
2377                                         <- ARG_POINTER
2378    saved pc
2379
2380    saved static chain                   if ix86_static_chain_on_stack
2381
2382    saved frame pointer                  if frame_pointer_needed
2383                                         <- HARD_FRAME_POINTER
2384    [saved regs]
2385                                         <- regs_save_offset
2386    [padding0]
2387
2388    [saved SSE regs]
2389                                         <- sse_regs_save_offset
2390    [padding1]          |
2391                        |                <- FRAME_POINTER
2392    [va_arg registers]  |
2393                        |
2394    [frame]             |
2395                        |
2396    [padding2]          | = to_allocate
2397                                         <- STACK_POINTER
2398   */
2399 struct ix86_frame
2400 {
2401   int nsseregs;
2402   int nregs;
2403   int va_arg_size;
2404   int red_zone_size;
2405   int outgoing_arguments_size;
2406   HOST_WIDE_INT frame;
2407
2408   /* The offsets relative to ARG_POINTER.  */
2409   HOST_WIDE_INT frame_pointer_offset;
2410   HOST_WIDE_INT hard_frame_pointer_offset;
2411   HOST_WIDE_INT stack_pointer_offset;
2412   HOST_WIDE_INT hfp_save_offset;
2413   HOST_WIDE_INT reg_save_offset;
2414   HOST_WIDE_INT sse_reg_save_offset;
2415
2416   /* When save_regs_using_mov is set, emit prologue using
2417      move instead of push instructions.  */
2418   bool save_regs_using_mov;
2419 };
2420
2421 /* Which cpu are we scheduling for.  */
2422 enum attr_cpu ix86_schedule;
2423
2424 /* Which cpu are we optimizing for.  */
2425 enum processor_type ix86_tune;
2426
2427 /* Which instruction set architecture to use.  */
2428 enum processor_type ix86_arch;
2429
2430 /* true if sse prefetch instruction is not NOOP.  */
2431 int x86_prefetch_sse;
2432
2433 /* -mstackrealign option */
2434 static const char ix86_force_align_arg_pointer_string[]
2435   = "force_align_arg_pointer";
2436
2437 static rtx (*ix86_gen_leave) (void);
2438 static rtx (*ix86_gen_add3) (rtx, rtx, rtx);
2439 static rtx (*ix86_gen_sub3) (rtx, rtx, rtx);
2440 static rtx (*ix86_gen_sub3_carry) (rtx, rtx, rtx, rtx, rtx);
2441 static rtx (*ix86_gen_one_cmpl2) (rtx, rtx);
2442 static rtx (*ix86_gen_monitor) (rtx, rtx, rtx);
2443 static rtx (*ix86_gen_andsp) (rtx, rtx, rtx);
2444 static rtx (*ix86_gen_allocate_stack_worker) (rtx, rtx);
2445 static rtx (*ix86_gen_adjust_stack_and_probe) (rtx, rtx, rtx);
2446 static rtx (*ix86_gen_probe_stack_range) (rtx, rtx, rtx);
2447
2448 /* Preferred alignment for stack boundary in bits.  */
2449 unsigned int ix86_preferred_stack_boundary;
2450
2451 /* Alignment for incoming stack boundary in bits specified at
2452    command line.  */
2453 static unsigned int ix86_user_incoming_stack_boundary;
2454
2455 /* Default alignment for incoming stack boundary in bits.  */
2456 static unsigned int ix86_default_incoming_stack_boundary;
2457
2458 /* Alignment for incoming stack boundary in bits.  */
2459 unsigned int ix86_incoming_stack_boundary;
2460
2461 /* Calling abi specific va_list type nodes.  */
2462 static GTY(()) tree sysv_va_list_type_node;
2463 static GTY(()) tree ms_va_list_type_node;
2464
2465 /* Prefix built by ASM_GENERATE_INTERNAL_LABEL.  */
2466 char internal_label_prefix[16];
2467 int internal_label_prefix_len;
2468
2469 /* Fence to use after loop using movnt.  */
2470 tree x86_mfence;
2471
2472 /* Register class used for passing given 64bit part of the argument.
2473    These represent classes as documented by the PS ABI, with the exception
2474    of SSESF, SSEDF classes, that are basically SSE class, just gcc will
2475    use SF or DFmode move instead of DImode to avoid reformatting penalties.
2476
2477    Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
2478    whenever possible (upper half does contain padding).  */
2479 enum x86_64_reg_class
2480   {
2481     X86_64_NO_CLASS,
2482     X86_64_INTEGER_CLASS,
2483     X86_64_INTEGERSI_CLASS,
2484     X86_64_SSE_CLASS,
2485     X86_64_SSESF_CLASS,
2486     X86_64_SSEDF_CLASS,
2487     X86_64_SSEUP_CLASS,
2488     X86_64_X87_CLASS,
2489     X86_64_X87UP_CLASS,
2490     X86_64_COMPLEX_X87_CLASS,
2491     X86_64_MEMORY_CLASS
2492   };
2493
2494 #define MAX_CLASSES 4
2495
2496 /* Table of constants used by fldpi, fldln2, etc....  */
2497 static REAL_VALUE_TYPE ext_80387_constants_table [5];
2498 static bool ext_80387_constants_init = 0;
2499
2500 \f
2501 static struct machine_function * ix86_init_machine_status (void);
2502 static rtx ix86_function_value (const_tree, const_tree, bool);
2503 static bool ix86_function_value_regno_p (const unsigned int);
2504 static unsigned int ix86_function_arg_boundary (enum machine_mode,
2505                                                 const_tree);
2506 static rtx ix86_static_chain (const_tree, bool);
2507 static int ix86_function_regparm (const_tree, const_tree);
2508 static void ix86_compute_frame_layout (struct ix86_frame *);
2509 static bool ix86_expand_vector_init_one_nonzero (bool, enum machine_mode,
2510                                                  rtx, rtx, int);
2511 static void ix86_add_new_builtins (HOST_WIDE_INT);
2512 static tree ix86_canonical_va_list_type (tree);
2513 static void predict_jump (int);
2514 static unsigned int split_stack_prologue_scratch_regno (void);
2515 static bool i386_asm_output_addr_const_extra (FILE *, rtx);
2516
2517 enum ix86_function_specific_strings
2518 {
2519   IX86_FUNCTION_SPECIFIC_ARCH,
2520   IX86_FUNCTION_SPECIFIC_TUNE,
2521   IX86_FUNCTION_SPECIFIC_MAX
2522 };
2523
2524 static char *ix86_target_string (HOST_WIDE_INT, int, const char *,
2525                                  const char *, enum fpmath_unit, bool);
2526 static void ix86_debug_options (void) ATTRIBUTE_UNUSED;
2527 static void ix86_function_specific_save (struct cl_target_option *);
2528 static void ix86_function_specific_restore (struct cl_target_option *);
2529 static void ix86_function_specific_print (FILE *, int,
2530                                           struct cl_target_option *);
2531 static bool ix86_valid_target_attribute_p (tree, tree, tree, int);
2532 static bool ix86_valid_target_attribute_inner_p (tree, char *[],
2533                                                  struct gcc_options *);
2534 static bool ix86_can_inline_p (tree, tree);
2535 static void ix86_set_current_function (tree);
2536 static unsigned int ix86_minimum_incoming_stack_boundary (bool);
2537
2538 static enum calling_abi ix86_function_abi (const_tree);
2539
2540 \f
2541 #ifndef SUBTARGET32_DEFAULT_CPU
2542 #define SUBTARGET32_DEFAULT_CPU "i386"
2543 #endif
2544
2545 /* The svr4 ABI for the i386 says that records and unions are returned
2546    in memory.  */
2547 #ifndef DEFAULT_PCC_STRUCT_RETURN
2548 #define DEFAULT_PCC_STRUCT_RETURN 1
2549 #endif
2550
2551 /* Whether -mtune= or -march= were specified */
2552 static int ix86_tune_defaulted;
2553 static int ix86_arch_specified;
2554
2555 /* Vectorization library interface and handlers.  */
2556 static tree (*ix86_veclib_handler) (enum built_in_function, tree, tree);
2557
2558 static tree ix86_veclibabi_svml (enum built_in_function, tree, tree);
2559 static tree ix86_veclibabi_acml (enum built_in_function, tree, tree);
2560
2561 /* Processor target table, indexed by processor number */
2562 struct ptt
2563 {
2564   const struct processor_costs *cost;           /* Processor costs */
2565   const int align_loop;                         /* Default alignments.  */
2566   const int align_loop_max_skip;
2567   const int align_jump;
2568   const int align_jump_max_skip;
2569   const int align_func;
2570 };
2571
2572 static const struct ptt processor_target_table[PROCESSOR_max] =
2573 {
2574   {&i386_cost, 4, 3, 4, 3, 4},
2575   {&i486_cost, 16, 15, 16, 15, 16},
2576   {&pentium_cost, 16, 7, 16, 7, 16},
2577   {&pentiumpro_cost, 16, 15, 16, 10, 16},
2578   {&geode_cost, 0, 0, 0, 0, 0},
2579   {&k6_cost, 32, 7, 32, 7, 32},
2580   {&athlon_cost, 16, 7, 16, 7, 16},
2581   {&pentium4_cost, 0, 0, 0, 0, 0},
2582   {&k8_cost, 16, 7, 16, 7, 16},
2583   {&nocona_cost, 0, 0, 0, 0, 0},
2584   /* Core 2 32-bit.  */
2585   {&generic32_cost, 16, 10, 16, 10, 16},
2586   /* Core 2 64-bit.  */
2587   {&generic64_cost, 16, 10, 16, 10, 16},
2588   /* Core i7 32-bit.  */
2589   {&generic32_cost, 16, 10, 16, 10, 16},
2590   /* Core i7 64-bit.  */
2591   {&generic64_cost, 16, 10, 16, 10, 16},
2592   {&generic32_cost, 16, 7, 16, 7, 16},
2593   {&generic64_cost, 16, 10, 16, 10, 16},
2594   {&amdfam10_cost, 32, 24, 32, 7, 32},
2595   {&bdver1_cost, 32, 24, 32, 7, 32},
2596   {&bdver2_cost, 32, 24, 32, 7, 32},
2597   {&btver1_cost, 32, 24, 32, 7, 32},
2598   {&atom_cost, 16, 15, 16, 7, 16}
2599 };
2600
2601 static const char *const cpu_names[TARGET_CPU_DEFAULT_max] =
2602 {
2603   "generic",
2604   "i386",
2605   "i486",
2606   "pentium",
2607   "pentium-mmx",
2608   "pentiumpro",
2609   "pentium2",
2610   "pentium3",
2611   "pentium4",
2612   "pentium-m",
2613   "prescott",
2614   "nocona",
2615   "core2",
2616   "corei7",
2617   "atom",
2618   "geode",
2619   "k6",
2620   "k6-2",
2621   "k6-3",
2622   "athlon",
2623   "athlon-4",
2624   "k8",
2625   "amdfam10",
2626   "bdver1",
2627   "bdver2",
2628   "btver1"
2629 };
2630 \f
2631 /* Return true if a red-zone is in use.  */
2632
2633 static inline bool
2634 ix86_using_red_zone (void)
2635 {
2636   return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;
2637 }
2638 \f
2639 /* Return a string that documents the current -m options.  The caller is
2640    responsible for freeing the string.  */
2641
2642 static char *
2643 ix86_target_string (HOST_WIDE_INT isa, int flags, const char *arch,
2644                     const char *tune, enum fpmath_unit fpmath,
2645                     bool add_nl_p)
2646 {
2647   struct ix86_target_opts
2648   {
2649     const char *option;         /* option string */
2650     HOST_WIDE_INT mask;         /* isa mask options */
2651   };
2652
2653   /* This table is ordered so that options like -msse4.2 that imply
2654      preceding options while match those first.  */
2655   static struct ix86_target_opts isa_opts[] =
2656   {
2657     { "-m64",           OPTION_MASK_ISA_64BIT },
2658     { "-mfma4",         OPTION_MASK_ISA_FMA4 },
2659     { "-mfma",          OPTION_MASK_ISA_FMA },
2660     { "-mxop",          OPTION_MASK_ISA_XOP },
2661     { "-mlwp",          OPTION_MASK_ISA_LWP },
2662     { "-msse4a",        OPTION_MASK_ISA_SSE4A },
2663     { "-msse4.2",       OPTION_MASK_ISA_SSE4_2 },
2664     { "-msse4.1",       OPTION_MASK_ISA_SSE4_1 },
2665     { "-mssse3",        OPTION_MASK_ISA_SSSE3 },
2666     { "-msse3",         OPTION_MASK_ISA_SSE3 },
2667     { "-msse2",         OPTION_MASK_ISA_SSE2 },
2668     { "-msse",          OPTION_MASK_ISA_SSE },
2669     { "-m3dnow",        OPTION_MASK_ISA_3DNOW },
2670     { "-m3dnowa",       OPTION_MASK_ISA_3DNOW_A },
2671     { "-mmmx",          OPTION_MASK_ISA_MMX },
2672     { "-mabm",          OPTION_MASK_ISA_ABM },
2673     { "-mbmi",          OPTION_MASK_ISA_BMI },
2674     { "-mbmi2",         OPTION_MASK_ISA_BMI2 },
2675     { "-mlzcnt",        OPTION_MASK_ISA_LZCNT },
2676     { "-mtbm",          OPTION_MASK_ISA_TBM },
2677     { "-mpopcnt",       OPTION_MASK_ISA_POPCNT },
2678     { "-mmovbe",        OPTION_MASK_ISA_MOVBE },
2679     { "-mcrc32",        OPTION_MASK_ISA_CRC32 },
2680     { "-maes",          OPTION_MASK_ISA_AES },
2681     { "-mpclmul",       OPTION_MASK_ISA_PCLMUL },
2682     { "-mfsgsbase",     OPTION_MASK_ISA_FSGSBASE },
2683     { "-mrdrnd",        OPTION_MASK_ISA_RDRND },
2684     { "-mf16c",         OPTION_MASK_ISA_F16C },
2685   };
2686
2687   /* Flag options.  */
2688   static struct ix86_target_opts flag_opts[] =
2689   {
2690     { "-m128bit-long-double",           MASK_128BIT_LONG_DOUBLE },
2691     { "-m80387",                        MASK_80387 },
2692     { "-maccumulate-outgoing-args",     MASK_ACCUMULATE_OUTGOING_ARGS },
2693     { "-malign-double",                 MASK_ALIGN_DOUBLE },
2694     { "-mcld",                          MASK_CLD },
2695     { "-mfp-ret-in-387",                MASK_FLOAT_RETURNS },
2696     { "-mieee-fp",                      MASK_IEEE_FP },
2697     { "-minline-all-stringops",         MASK_INLINE_ALL_STRINGOPS },
2698     { "-minline-stringops-dynamically", MASK_INLINE_STRINGOPS_DYNAMICALLY },
2699     { "-mms-bitfields",                 MASK_MS_BITFIELD_LAYOUT },
2700     { "-mno-align-stringops",           MASK_NO_ALIGN_STRINGOPS },
2701     { "-mno-fancy-math-387",            MASK_NO_FANCY_MATH_387 },
2702     { "-mno-push-args",                 MASK_NO_PUSH_ARGS },
2703     { "-mno-red-zone",                  MASK_NO_RED_ZONE },
2704     { "-momit-leaf-frame-pointer",      MASK_OMIT_LEAF_FRAME_POINTER },
2705     { "-mrecip",                        MASK_RECIP },
2706     { "-mrtd",                          MASK_RTD },
2707     { "-msseregparm",                   MASK_SSEREGPARM },
2708     { "-mstack-arg-probe",              MASK_STACK_PROBE },
2709     { "-mtls-direct-seg-refs",          MASK_TLS_DIRECT_SEG_REFS },
2710     { "-mvect8-ret-in-mem",             MASK_VECT8_RETURNS },
2711     { "-m8bit-idiv",                    MASK_USE_8BIT_IDIV },
2712     { "-mvzeroupper",                   MASK_VZEROUPPER },
2713     { "-mavx256-split-unaligned-load",  MASK_AVX256_SPLIT_UNALIGNED_LOAD},
2714     { "-mavx256-split-unaligned-store", MASK_AVX256_SPLIT_UNALIGNED_STORE},
2715     { "-mprefer-avx128",                MASK_PREFER_AVX128},
2716   };
2717
2718   const char *opts[ARRAY_SIZE (isa_opts) + ARRAY_SIZE (flag_opts) + 6][2];
2719
2720   char isa_other[40];
2721   char target_other[40];
2722   unsigned num = 0;
2723   unsigned i, j;
2724   char *ret;
2725   char *ptr;
2726   size_t len;
2727   size_t line_len;
2728   size_t sep_len;
2729
2730   memset (opts, '\0', sizeof (opts));
2731
2732   /* Add -march= option.  */
2733   if (arch)
2734     {
2735       opts[num][0] = "-march=";
2736       opts[num++][1] = arch;
2737     }
2738
2739   /* Add -mtune= option.  */
2740   if (tune)
2741     {
2742       opts[num][0] = "-mtune=";
2743       opts[num++][1] = tune;
2744     }
2745
2746   /* Pick out the options in isa options.  */
2747   for (i = 0; i < ARRAY_SIZE (isa_opts); i++)
2748     {
2749       if ((isa & isa_opts[i].mask) != 0)
2750         {
2751           opts[num++][0] = isa_opts[i].option;
2752           isa &= ~ isa_opts[i].mask;
2753         }
2754     }
2755
2756   if (isa && add_nl_p)
2757     {
2758       opts[num++][0] = isa_other;
2759       sprintf (isa_other, "(other isa: %#" HOST_WIDE_INT_PRINT "x)",
2760                isa);
2761     }
2762
2763   /* Add flag options.  */
2764   for (i = 0; i < ARRAY_SIZE (flag_opts); i++)
2765     {
2766       if ((flags & flag_opts[i].mask) != 0)
2767         {
2768           opts[num++][0] = flag_opts[i].option;
2769           flags &= ~ flag_opts[i].mask;
2770         }
2771     }
2772
2773   if (flags && add_nl_p)
2774     {
2775       opts[num++][0] = target_other;
2776       sprintf (target_other, "(other flags: %#x)", flags);
2777     }
2778
2779   /* Add -fpmath= option.  */
2780   if (fpmath)
2781     {
2782       opts[num][0] = "-mfpmath=";
2783       switch ((int) fpmath)
2784         {
2785         case FPMATH_387:
2786           opts[num++][1] = "387";
2787           break;
2788
2789         case FPMATH_SSE:
2790           opts[num++][1] = "sse";
2791           break;
2792
2793         case FPMATH_387 | FPMATH_SSE:
2794           opts[num++][1] = "sse+387";
2795           break;
2796
2797         default:
2798           gcc_unreachable ();
2799         }
2800     }
2801
2802   /* Any options?  */
2803   if (num == 0)
2804     return NULL;
2805
2806   gcc_assert (num < ARRAY_SIZE (opts));
2807
2808   /* Size the string.  */
2809   len = 0;
2810   sep_len = (add_nl_p) ? 3 : 1;
2811   for (i = 0; i < num; i++)
2812     {
2813       len += sep_len;
2814       for (j = 0; j < 2; j++)
2815         if (opts[i][j])
2816           len += strlen (opts[i][j]);
2817     }
2818
2819   /* Build the string.  */
2820   ret = ptr = (char *) xmalloc (len);
2821   line_len = 0;
2822
2823   for (i = 0; i < num; i++)
2824     {
2825       size_t len2[2];
2826
2827       for (j = 0; j < 2; j++)
2828         len2[j] = (opts[i][j]) ? strlen (opts[i][j]) : 0;
2829
2830       if (i != 0)
2831         {
2832           *ptr++ = ' ';
2833           line_len++;
2834
2835           if (add_nl_p && line_len + len2[0] + len2[1] > 70)
2836             {
2837               *ptr++ = '\\';
2838               *ptr++ = '\n';
2839               line_len = 0;
2840             }
2841         }
2842
2843       for (j = 0; j < 2; j++)
2844         if (opts[i][j])
2845           {
2846             memcpy (ptr, opts[i][j], len2[j]);
2847             ptr += len2[j];
2848             line_len += len2[j];
2849           }
2850     }
2851
2852   *ptr = '\0';
2853   gcc_assert (ret + len >= ptr);
2854
2855   return ret;
2856 }
2857
2858 /* Return true, if profiling code should be emitted before
2859    prologue. Otherwise it returns false.
2860    Note: For x86 with "hotfix" it is sorried.  */
2861 static bool
2862 ix86_profile_before_prologue (void)
2863 {
2864   return flag_fentry != 0;
2865 }
2866
2867 /* Function that is callable from the debugger to print the current
2868    options.  */
2869 void
2870 ix86_debug_options (void)
2871 {
2872   char *opts = ix86_target_string (ix86_isa_flags, target_flags,
2873                                    ix86_arch_string, ix86_tune_string,
2874                                    ix86_fpmath, true);
2875
2876   if (opts)
2877     {
2878       fprintf (stderr, "%s\n\n", opts);
2879       free (opts);
2880     }
2881   else
2882     fputs ("<no options>\n\n", stderr);
2883
2884   return;
2885 }
2886 \f
2887 /* Override various settings based on options.  If MAIN_ARGS_P, the
2888    options are from the command line, otherwise they are from
2889    attributes.  */
2890
2891 static void
2892 ix86_option_override_internal (bool main_args_p)
2893 {
2894   int i;
2895   unsigned int ix86_arch_mask, ix86_tune_mask;
2896   const bool ix86_tune_specified = (ix86_tune_string != NULL);
2897   const char *prefix;
2898   const char *suffix;
2899   const char *sw;
2900
2901 #define PTA_3DNOW               (HOST_WIDE_INT_1 << 0)
2902 #define PTA_3DNOW_A             (HOST_WIDE_INT_1 << 1)
2903 #define PTA_64BIT               (HOST_WIDE_INT_1 << 2)
2904 #define PTA_ABM                 (HOST_WIDE_INT_1 << 3)
2905 #define PTA_AES                 (HOST_WIDE_INT_1 << 4)
2906 #define PTA_AVX                 (HOST_WIDE_INT_1 << 5)
2907 #define PTA_BMI                 (HOST_WIDE_INT_1 << 6)
2908 #define PTA_CX16                (HOST_WIDE_INT_1 << 7)
2909 #define PTA_F16C                (HOST_WIDE_INT_1 << 8)
2910 #define PTA_FMA                 (HOST_WIDE_INT_1 << 9)
2911 #define PTA_FMA4                (HOST_WIDE_INT_1 << 10)
2912 #define PTA_FSGSBASE            (HOST_WIDE_INT_1 << 11)
2913 #define PTA_LWP                 (HOST_WIDE_INT_1 << 12)
2914 #define PTA_LZCNT               (HOST_WIDE_INT_1 << 13)
2915 #define PTA_MMX                 (HOST_WIDE_INT_1 << 14)
2916 #define PTA_MOVBE               (HOST_WIDE_INT_1 << 15)
2917 #define PTA_NO_SAHF             (HOST_WIDE_INT_1 << 16)
2918 #define PTA_PCLMUL              (HOST_WIDE_INT_1 << 17)
2919 #define PTA_POPCNT              (HOST_WIDE_INT_1 << 18)
2920 #define PTA_PREFETCH_SSE        (HOST_WIDE_INT_1 << 19)
2921 #define PTA_RDRND               (HOST_WIDE_INT_1 << 20)
2922 #define PTA_SSE                 (HOST_WIDE_INT_1 << 21)
2923 #define PTA_SSE2                (HOST_WIDE_INT_1 << 22)
2924 #define PTA_SSE3                (HOST_WIDE_INT_1 << 23)
2925 #define PTA_SSE4_1              (HOST_WIDE_INT_1 << 24)
2926 #define PTA_SSE4_2              (HOST_WIDE_INT_1 << 25)
2927 #define PTA_SSE4A               (HOST_WIDE_INT_1 << 26)
2928 #define PTA_SSSE3               (HOST_WIDE_INT_1 << 27)
2929 #define PTA_TBM                 (HOST_WIDE_INT_1 << 28)
2930 #define PTA_XOP                 (HOST_WIDE_INT_1 << 29)
2931 #define PTA_AVX2                (HOST_WIDE_INT_1 << 30)
2932 #define PTA_BMI2                (HOST_WIDE_INT_1 << 31)
2933 /* if this reaches 64, need to widen struct pta flags below */
2934
2935   static struct pta
2936     {
2937       const char *const name;           /* processor name or nickname.  */
2938       const enum processor_type processor;
2939       const enum attr_cpu schedule;
2940       const unsigned HOST_WIDE_INT flags;
2941     }
2942   const processor_alias_table[] =
2943     {
2944       {"i386", PROCESSOR_I386, CPU_NONE, 0},
2945       {"i486", PROCESSOR_I486, CPU_NONE, 0},
2946       {"i586", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2947       {"pentium", PROCESSOR_PENTIUM, CPU_PENTIUM, 0},
2948       {"pentium-mmx", PROCESSOR_PENTIUM, CPU_PENTIUM, PTA_MMX},
2949       {"winchip-c6", PROCESSOR_I486, CPU_NONE, PTA_MMX},
2950       {"winchip2", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2951       {"c3", PROCESSOR_I486, CPU_NONE, PTA_MMX | PTA_3DNOW},
2952       {"c3-2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX | PTA_SSE},
2953       {"i686", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2954       {"pentiumpro", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, 0},
2955       {"pentium2", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO, PTA_MMX},
2956       {"pentium3", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2957         PTA_MMX | PTA_SSE},
2958       {"pentium3m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2959         PTA_MMX | PTA_SSE},
2960       {"pentium-m", PROCESSOR_PENTIUMPRO, CPU_PENTIUMPRO,
2961         PTA_MMX | PTA_SSE | PTA_SSE2},
2962       {"pentium4", PROCESSOR_PENTIUM4, CPU_NONE,
2963         PTA_MMX |PTA_SSE | PTA_SSE2},
2964       {"pentium4m", PROCESSOR_PENTIUM4, CPU_NONE,
2965         PTA_MMX | PTA_SSE | PTA_SSE2},
2966       {"prescott", PROCESSOR_NOCONA, CPU_NONE,
2967         PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3},
2968       {"nocona", PROCESSOR_NOCONA, CPU_NONE,
2969         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2970         | PTA_CX16 | PTA_NO_SAHF},
2971       {"core2", PROCESSOR_CORE2_64, CPU_CORE2,
2972         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2973         | PTA_SSSE3 | PTA_CX16},
2974       {"corei7", PROCESSOR_COREI7_64, CPU_COREI7,
2975         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2976         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_CX16},
2977       {"corei7-avx", PROCESSOR_COREI7_64, CPU_COREI7,
2978         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2979         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2980         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL},
2981       {"core-avx-i", PROCESSOR_COREI7_64, CPU_COREI7,
2982         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2983         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX
2984         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2985         | PTA_RDRND | PTA_F16C},
2986       {"core-avx2", PROCESSOR_COREI7_64, CPU_COREI7,
2987         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2988         | PTA_SSSE3 | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AVX | PTA_AVX2
2989         | PTA_CX16 | PTA_POPCNT | PTA_AES | PTA_PCLMUL | PTA_FSGSBASE
2990         | PTA_RDRND | PTA_F16C | PTA_BMI | PTA_BMI2 | PTA_LZCNT
2991         | PTA_FMA | PTA_MOVBE},
2992       {"atom", PROCESSOR_ATOM, CPU_ATOM,
2993         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
2994         | PTA_SSSE3 | PTA_CX16 | PTA_MOVBE},
2995       {"geode", PROCESSOR_GEODE, CPU_GEODE,
2996         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A |PTA_PREFETCH_SSE},
2997       {"k6", PROCESSOR_K6, CPU_K6, PTA_MMX},
2998       {"k6-2", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
2999       {"k6-3", PROCESSOR_K6, CPU_K6, PTA_MMX | PTA_3DNOW},
3000       {"athlon", PROCESSOR_ATHLON, CPU_ATHLON,
3001         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3002       {"athlon-tbird", PROCESSOR_ATHLON, CPU_ATHLON,
3003         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_PREFETCH_SSE},
3004       {"athlon-4", PROCESSOR_ATHLON, CPU_ATHLON,
3005         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3006       {"athlon-xp", PROCESSOR_ATHLON, CPU_ATHLON,
3007         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3008       {"athlon-mp", PROCESSOR_ATHLON, CPU_ATHLON,
3009         PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE},
3010       {"x86-64", PROCESSOR_K8, CPU_K8,
3011         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_NO_SAHF},
3012       {"k8", PROCESSOR_K8, CPU_K8,
3013         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3014         | PTA_SSE2 | PTA_NO_SAHF},
3015       {"k8-sse3", PROCESSOR_K8, CPU_K8,
3016         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3017         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3018       {"opteron", PROCESSOR_K8, CPU_K8,
3019         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3020         | PTA_SSE2 | PTA_NO_SAHF},
3021       {"opteron-sse3", PROCESSOR_K8, CPU_K8,
3022         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3023         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3024       {"athlon64", PROCESSOR_K8, CPU_K8,
3025         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3026         | PTA_SSE2 | PTA_NO_SAHF},
3027       {"athlon64-sse3", PROCESSOR_K8, CPU_K8,
3028         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3029         | PTA_SSE2 | PTA_SSE3 | PTA_NO_SAHF},
3030       {"athlon-fx", PROCESSOR_K8, CPU_K8,
3031         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3032         | PTA_SSE2 | PTA_NO_SAHF},
3033       {"amdfam10", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3034         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3035         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3036       {"barcelona", PROCESSOR_AMDFAM10, CPU_AMDFAM10,
3037         PTA_64BIT | PTA_MMX | PTA_3DNOW | PTA_3DNOW_A | PTA_SSE
3038         | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM},
3039       {"bdver1", PROCESSOR_BDVER1, CPU_BDVER1,
3040         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3041         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3042         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_FMA4
3043         | PTA_XOP | PTA_LWP},
3044       {"bdver2", PROCESSOR_BDVER2, CPU_BDVER2,
3045         PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3
3046         | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3 | PTA_SSE4_1
3047         | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX
3048         | PTA_XOP | PTA_LWP | PTA_BMI | PTA_TBM | PTA_F16C
3049         | PTA_FMA},
3050       {"btver1", PROCESSOR_BTVER1, CPU_GENERIC64,
3051         PTA_64BIT | PTA_MMX |  PTA_SSE  | PTA_SSE2 | PTA_SSE3
3052         | PTA_SSSE3 | PTA_SSE4A |PTA_ABM | PTA_CX16},
3053       {"generic32", PROCESSOR_GENERIC32, CPU_PENTIUMPRO,
3054         0 /* flags are only used for -march switch.  */ },
3055       {"generic64", PROCESSOR_GENERIC64, CPU_GENERIC64,
3056         PTA_64BIT /* flags are only used for -march switch.  */ },
3057     };
3058
3059   /* -mrecip options.  */
3060   static struct
3061     {
3062       const char *string;           /* option name */
3063       unsigned int mask;            /* mask bits to set */
3064     }
3065   const recip_options[] =
3066     {
3067       { "all",       RECIP_MASK_ALL },
3068       { "none",      RECIP_MASK_NONE },
3069       { "div",       RECIP_MASK_DIV },
3070       { "sqrt",      RECIP_MASK_SQRT },
3071       { "vec-div",   RECIP_MASK_VEC_DIV },
3072       { "vec-sqrt",  RECIP_MASK_VEC_SQRT },
3073     };
3074
3075   int const pta_size = ARRAY_SIZE (processor_alias_table);
3076
3077   /* Set up prefix/suffix so the error messages refer to either the command
3078      line argument, or the attribute(target).  */
3079   if (main_args_p)
3080     {
3081       prefix = "-m";
3082       suffix = "";
3083       sw = "switch";
3084     }
3085   else
3086     {
3087       prefix = "option(\"";
3088       suffix = "\")";
3089       sw = "attribute";
3090     }
3091
3092 #ifdef SUBTARGET_OVERRIDE_OPTIONS
3093   SUBTARGET_OVERRIDE_OPTIONS;
3094 #endif
3095
3096 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
3097   SUBSUBTARGET_OVERRIDE_OPTIONS;
3098 #endif
3099
3100   if (TARGET_X32)
3101     ix86_isa_flags |= OPTION_MASK_ISA_64BIT;
3102
3103   /* -fPIC is the default for x86_64.  */
3104   if (TARGET_MACHO && TARGET_64BIT)
3105     flag_pic = 2;
3106
3107   /* Need to check -mtune=generic first.  */
3108   if (ix86_tune_string)
3109     {
3110       if (!strcmp (ix86_tune_string, "generic")
3111           || !strcmp (ix86_tune_string, "i686")
3112           /* As special support for cross compilers we read -mtune=native
3113              as -mtune=generic.  With native compilers we won't see the
3114              -mtune=native, as it was changed by the driver.  */
3115           || !strcmp (ix86_tune_string, "native"))
3116         {
3117           if (TARGET_64BIT)
3118             ix86_tune_string = "generic64";
3119           else
3120             ix86_tune_string = "generic32";
3121         }
3122       /* If this call is for setting the option attribute, allow the
3123          generic32/generic64 that was previously set.  */
3124       else if (!main_args_p
3125                && (!strcmp (ix86_tune_string, "generic32")
3126                    || !strcmp (ix86_tune_string, "generic64")))
3127         ;
3128       else if (!strncmp (ix86_tune_string, "generic", 7))
3129         error ("bad value (%s) for %stune=%s %s",
3130                ix86_tune_string, prefix, suffix, sw);
3131       else if (!strcmp (ix86_tune_string, "x86-64"))
3132         warning (OPT_Wdeprecated, "%stune=x86-64%s is deprecated; use "
3133                  "%stune=k8%s or %stune=generic%s instead as appropriate",
3134                  prefix, suffix, prefix, suffix, prefix, suffix);
3135     }
3136   else
3137     {
3138       if (ix86_arch_string)
3139         ix86_tune_string = ix86_arch_string;
3140       if (!ix86_tune_string)
3141         {
3142           ix86_tune_string = cpu_names[TARGET_CPU_DEFAULT];
3143           ix86_tune_defaulted = 1;
3144         }
3145
3146       /* ix86_tune_string is set to ix86_arch_string or defaulted.  We
3147          need to use a sensible tune option.  */
3148       if (!strcmp (ix86_tune_string, "generic")
3149           || !strcmp (ix86_tune_string, "x86-64")
3150           || !strcmp (ix86_tune_string, "i686"))
3151         {
3152           if (TARGET_64BIT)
3153             ix86_tune_string = "generic64";
3154           else
3155             ix86_tune_string = "generic32";
3156         }
3157     }
3158
3159   if (ix86_stringop_alg == rep_prefix_8_byte && !TARGET_64BIT)
3160     {
3161       /* rep; movq isn't available in 32-bit code.  */
3162       error ("-mstringop-strategy=rep_8byte not supported for 32-bit code");
3163       ix86_stringop_alg = no_stringop;
3164     }
3165
3166   if (!ix86_arch_string)
3167     ix86_arch_string = TARGET_64BIT ? "x86-64" : SUBTARGET32_DEFAULT_CPU;
3168   else
3169     ix86_arch_specified = 1;
3170
3171   if (!global_options_set.x_ix86_abi)
3172     ix86_abi = DEFAULT_ABI;
3173
3174   if (global_options_set.x_ix86_cmodel)
3175     {
3176       switch (ix86_cmodel)
3177         {
3178         case CM_SMALL:
3179         case CM_SMALL_PIC:
3180           if (flag_pic)
3181             ix86_cmodel = CM_SMALL_PIC;
3182           if (!TARGET_64BIT)
3183             error ("code model %qs not supported in the %s bit mode",
3184                    "small", "32");
3185           break;
3186
3187         case CM_MEDIUM:
3188         case CM_MEDIUM_PIC:
3189           if (flag_pic)
3190             ix86_cmodel = CM_MEDIUM_PIC;
3191           if (!TARGET_64BIT)
3192             error ("code model %qs not supported in the %s bit mode",
3193                    "medium", "32");
3194           else if (TARGET_X32)
3195             error ("code model %qs not supported in x32 mode",
3196                    "medium");
3197           break;
3198
3199         case CM_LARGE:
3200         case CM_LARGE_PIC:
3201           if (flag_pic)
3202             ix86_cmodel = CM_LARGE_PIC;
3203           if (!TARGET_64BIT)
3204             error ("code model %qs not supported in the %s bit mode",
3205                    "large", "32");
3206           else if (TARGET_X32)
3207             error ("code model %qs not supported in x32 mode",
3208                    "medium");
3209           break;
3210
3211         case CM_32:
3212           if (flag_pic)
3213             error ("code model %s does not support PIC mode", "32");
3214           if (TARGET_64BIT)
3215             error ("code model %qs not supported in the %s bit mode",
3216                    "32", "64");
3217           break;
3218
3219         case CM_KERNEL:
3220           if (flag_pic)
3221             {
3222               error ("code model %s does not support PIC mode", "kernel");
3223               ix86_cmodel = CM_32;
3224             }
3225           if (!TARGET_64BIT)
3226             error ("code model %qs not supported in the %s bit mode",
3227                    "kernel", "32");
3228           break;
3229
3230         default:
3231           gcc_unreachable ();
3232         }
3233     }
3234   else
3235     {
3236       /* For TARGET_64BIT and MS_ABI, force pic on, in order to enable the
3237          use of rip-relative addressing.  This eliminates fixups that
3238          would otherwise be needed if this object is to be placed in a
3239          DLL, and is essentially just as efficient as direct addressing.  */
3240       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
3241         ix86_cmodel = CM_SMALL_PIC, flag_pic = 1;
3242       else if (TARGET_64BIT)
3243         ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
3244       else
3245         ix86_cmodel = CM_32;
3246     }
3247   if (TARGET_MACHO && ix86_asm_dialect == ASM_INTEL)
3248     {
3249       error ("-masm=intel not supported in this configuration");
3250       ix86_asm_dialect = ASM_ATT;
3251     }
3252   if ((TARGET_64BIT != 0) != ((ix86_isa_flags & OPTION_MASK_ISA_64BIT) != 0))
3253     sorry ("%i-bit mode not compiled in",
3254            (ix86_isa_flags & OPTION_MASK_ISA_64BIT) ? 64 : 32);
3255
3256   for (i = 0; i < pta_size; i++)
3257     if (! strcmp (ix86_arch_string, processor_alias_table[i].name))
3258       {
3259         ix86_schedule = processor_alias_table[i].schedule;
3260         ix86_arch = processor_alias_table[i].processor;
3261         /* Default cpu tuning to the architecture.  */
3262         ix86_tune = ix86_arch;
3263
3264         if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
3265           error ("CPU you selected does not support x86-64 "
3266                  "instruction set");
3267
3268         if (processor_alias_table[i].flags & PTA_MMX
3269             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MMX))
3270           ix86_isa_flags |= OPTION_MASK_ISA_MMX;
3271         if (processor_alias_table[i].flags & PTA_3DNOW
3272             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW))
3273           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW;
3274         if (processor_alias_table[i].flags & PTA_3DNOW_A
3275             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_3DNOW_A))
3276           ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_A;
3277         if (processor_alias_table[i].flags & PTA_SSE
3278             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE))
3279           ix86_isa_flags |= OPTION_MASK_ISA_SSE;
3280         if (processor_alias_table[i].flags & PTA_SSE2
3281             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE2))
3282           ix86_isa_flags |= OPTION_MASK_ISA_SSE2;
3283         if (processor_alias_table[i].flags & PTA_SSE3
3284             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE3))
3285           ix86_isa_flags |= OPTION_MASK_ISA_SSE3;
3286         if (processor_alias_table[i].flags & PTA_SSSE3
3287             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSSE3))
3288           ix86_isa_flags |= OPTION_MASK_ISA_SSSE3;
3289         if (processor_alias_table[i].flags & PTA_SSE4_1
3290             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_1))
3291           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1;
3292         if (processor_alias_table[i].flags & PTA_SSE4_2
3293             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4_2))
3294           ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2;
3295         if (processor_alias_table[i].flags & PTA_AVX
3296             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX))
3297           ix86_isa_flags |= OPTION_MASK_ISA_AVX;
3298         if (processor_alias_table[i].flags & PTA_AVX2
3299             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX2))
3300           ix86_isa_flags |= OPTION_MASK_ISA_AVX2;
3301         if (processor_alias_table[i].flags & PTA_FMA
3302             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA))
3303           ix86_isa_flags |= OPTION_MASK_ISA_FMA;
3304         if (processor_alias_table[i].flags & PTA_SSE4A
3305             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SSE4A))
3306           ix86_isa_flags |= OPTION_MASK_ISA_SSE4A;
3307         if (processor_alias_table[i].flags & PTA_FMA4
3308             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FMA4))
3309           ix86_isa_flags |= OPTION_MASK_ISA_FMA4;
3310         if (processor_alias_table[i].flags & PTA_XOP
3311             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_XOP))
3312           ix86_isa_flags |= OPTION_MASK_ISA_XOP;
3313         if (processor_alias_table[i].flags & PTA_LWP
3314             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LWP))
3315           ix86_isa_flags |= OPTION_MASK_ISA_LWP;
3316         if (processor_alias_table[i].flags & PTA_ABM
3317             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_ABM))
3318           ix86_isa_flags |= OPTION_MASK_ISA_ABM;
3319         if (processor_alias_table[i].flags & PTA_BMI
3320             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI))
3321           ix86_isa_flags |= OPTION_MASK_ISA_BMI;
3322         if (processor_alias_table[i].flags & (PTA_LZCNT | PTA_ABM)
3323             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_LZCNT))
3324           ix86_isa_flags |= OPTION_MASK_ISA_LZCNT;
3325         if (processor_alias_table[i].flags & PTA_TBM
3326             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_TBM))
3327           ix86_isa_flags |= OPTION_MASK_ISA_TBM;
3328         if (processor_alias_table[i].flags & PTA_BMI2
3329             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_BMI2))
3330           ix86_isa_flags |= OPTION_MASK_ISA_BMI2;
3331         if (processor_alias_table[i].flags & PTA_CX16
3332             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_CX16))
3333           ix86_isa_flags |= OPTION_MASK_ISA_CX16;
3334         if (processor_alias_table[i].flags & (PTA_POPCNT | PTA_ABM)
3335             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_POPCNT))
3336           ix86_isa_flags |= OPTION_MASK_ISA_POPCNT;
3337         if (!(TARGET_64BIT && (processor_alias_table[i].flags & PTA_NO_SAHF))
3338             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_SAHF))
3339           ix86_isa_flags |= OPTION_MASK_ISA_SAHF;
3340         if (processor_alias_table[i].flags & PTA_MOVBE
3341             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_MOVBE))
3342           ix86_isa_flags |= OPTION_MASK_ISA_MOVBE;
3343         if (processor_alias_table[i].flags & PTA_AES
3344             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_AES))
3345           ix86_isa_flags |= OPTION_MASK_ISA_AES;
3346         if (processor_alias_table[i].flags & PTA_PCLMUL
3347             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_PCLMUL))
3348           ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL;
3349         if (processor_alias_table[i].flags & PTA_FSGSBASE
3350             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_FSGSBASE))
3351           ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE;
3352         if (processor_alias_table[i].flags & PTA_RDRND
3353             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_RDRND))
3354           ix86_isa_flags |= OPTION_MASK_ISA_RDRND;
3355         if (processor_alias_table[i].flags & PTA_F16C
3356             && !(ix86_isa_flags_explicit & OPTION_MASK_ISA_F16C))
3357           ix86_isa_flags |= OPTION_MASK_ISA_F16C;
3358         if (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE))
3359           x86_prefetch_sse = true;
3360
3361         break;
3362       }
3363
3364   if (!strcmp (ix86_arch_string, "generic"))
3365     error ("generic CPU can be used only for %stune=%s %s",
3366            prefix, suffix, sw);
3367   else if (!strncmp (ix86_arch_string, "generic", 7) || i == pta_size)
3368     error ("bad value (%s) for %sarch=%s %s",
3369            ix86_arch_string, prefix, suffix, sw);
3370
3371   ix86_arch_mask = 1u << ix86_arch;
3372   for (i = 0; i < X86_ARCH_LAST; ++i)
3373     ix86_arch_features[i] = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
3374
3375   for (i = 0; i < pta_size; i++)
3376     if (! strcmp (ix86_tune_string, processor_alias_table[i].name))
3377       {
3378         ix86_schedule = processor_alias_table[i].schedule;
3379         ix86_tune = processor_alias_table[i].processor;
3380         if (TARGET_64BIT)
3381           {
3382             if (!(processor_alias_table[i].flags & PTA_64BIT))
3383               {
3384                 if (ix86_tune_defaulted)
3385                   {
3386                     ix86_tune_string = "x86-64";
3387                     for (i = 0; i < pta_size; i++)
3388                       if (! strcmp (ix86_tune_string,
3389                                     processor_alias_table[i].name))
3390                         break;
3391                     ix86_schedule = processor_alias_table[i].schedule;
3392                     ix86_tune = processor_alias_table[i].processor;
3393                   }
3394                 else
3395                   error ("CPU you selected does not support x86-64 "
3396                          "instruction set");
3397               }
3398           }
3399         else
3400           {
3401             /* Adjust tuning when compiling for 32-bit ABI.  */
3402             switch (ix86_tune)
3403               {
3404               case PROCESSOR_GENERIC64:
3405                 ix86_tune = PROCESSOR_GENERIC32;
3406                 ix86_schedule = CPU_PENTIUMPRO;
3407                 break;
3408
3409               case PROCESSOR_CORE2_64:
3410                 ix86_tune = PROCESSOR_CORE2_32;
3411                 break;
3412
3413               case PROCESSOR_COREI7_64:
3414                 ix86_tune = PROCESSOR_COREI7_32;
3415                 break;
3416
3417               default:
3418                 break;
3419               }
3420           }
3421         /* Intel CPUs have always interpreted SSE prefetch instructions as
3422            NOPs; so, we can enable SSE prefetch instructions even when
3423            -mtune (rather than -march) points us to a processor that has them.
3424            However, the VIA C3 gives a SIGILL, so we only do that for i686 and
3425            higher processors.  */
3426         if (TARGET_CMOVE
3427             && (processor_alias_table[i].flags & (PTA_PREFETCH_SSE | PTA_SSE)))
3428           x86_prefetch_sse = true;
3429         break;
3430       }
3431
3432   if (ix86_tune_specified && i == pta_size)
3433     error ("bad value (%s) for %stune=%s %s",
3434            ix86_tune_string, prefix, suffix, sw);
3435
3436   ix86_tune_mask = 1u << ix86_tune;
3437   for (i = 0; i < X86_TUNE_LAST; ++i)
3438     ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
3439
3440 #ifndef USE_IX86_FRAME_POINTER
3441 #define USE_IX86_FRAME_POINTER 0
3442 #endif
3443
3444 #ifndef USE_X86_64_FRAME_POINTER
3445 #define USE_X86_64_FRAME_POINTER 0
3446 #endif
3447
3448   /* Set the default values for switches whose default depends on TARGET_64BIT
3449      in case they weren't overwritten by command line options.  */
3450   if (TARGET_64BIT)
3451     {
3452       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3453         flag_omit_frame_pointer = !USE_X86_64_FRAME_POINTER;
3454       if (flag_asynchronous_unwind_tables == 2)
3455         flag_unwind_tables = flag_asynchronous_unwind_tables = 1;
3456       if (flag_pcc_struct_return == 2)
3457         flag_pcc_struct_return = 0;
3458     }
3459   else
3460     {
3461       if (optimize >= 1 && !global_options_set.x_flag_omit_frame_pointer)
3462         flag_omit_frame_pointer = !(USE_IX86_FRAME_POINTER || optimize_size);
3463       if (flag_asynchronous_unwind_tables == 2)
3464         flag_asynchronous_unwind_tables = !USE_IX86_FRAME_POINTER;
3465       if (flag_pcc_struct_return == 2)
3466         flag_pcc_struct_return = DEFAULT_PCC_STRUCT_RETURN;
3467     }
3468
3469   if (optimize_size)
3470     ix86_cost = &ix86_size_cost;
3471   else
3472     ix86_cost = processor_target_table[ix86_tune].cost;
3473
3474   /* Arrange to set up i386_stack_locals for all functions.  */
3475   init_machine_status = ix86_init_machine_status;
3476
3477   /* Validate -mregparm= value.  */
3478   if (global_options_set.x_ix86_regparm)
3479     {
3480       if (TARGET_64BIT)
3481         warning (0, "-mregparm is ignored in 64-bit mode");
3482       if (ix86_regparm > REGPARM_MAX)
3483         {
3484           error ("-mregparm=%d is not between 0 and %d",
3485                  ix86_regparm, REGPARM_MAX);
3486           ix86_regparm = 0;
3487         }
3488     }
3489   if (TARGET_64BIT)
3490     ix86_regparm = REGPARM_MAX;
3491
3492   /* Default align_* from the processor table.  */
3493   if (align_loops == 0)
3494     {
3495       align_loops = processor_target_table[ix86_tune].align_loop;
3496       align_loops_max_skip = processor_target_table[ix86_tune].align_loop_max_skip;
3497     }
3498   if (align_jumps == 0)
3499     {
3500       align_jumps = processor_target_table[ix86_tune].align_jump;
3501       align_jumps_max_skip = processor_target_table[ix86_tune].align_jump_max_skip;
3502     }
3503   if (align_functions == 0)
3504     {
3505       align_functions = processor_target_table[ix86_tune].align_func;
3506     }
3507
3508   /* Provide default for -mbranch-cost= value.  */
3509   if (!global_options_set.x_ix86_branch_cost)
3510     ix86_branch_cost = ix86_cost->branch_cost;
3511
3512   if (TARGET_64BIT)
3513     {
3514       target_flags |= TARGET_SUBTARGET64_DEFAULT & ~target_flags_explicit;
3515
3516       /* Enable by default the SSE and MMX builtins.  Do allow the user to
3517          explicitly disable any of these.  In particular, disabling SSE and
3518          MMX for kernel code is extremely useful.  */
3519       if (!ix86_arch_specified)
3520       ix86_isa_flags
3521         |= ((OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_MMX
3522              | TARGET_SUBTARGET64_ISA_DEFAULT) & ~ix86_isa_flags_explicit);
3523
3524       if (TARGET_RTD)
3525         warning (0, "%srtd%s is ignored in 64bit mode", prefix, suffix);
3526     }
3527   else
3528     {
3529       target_flags |= TARGET_SUBTARGET32_DEFAULT & ~target_flags_explicit;
3530
3531       if (!ix86_arch_specified)
3532       ix86_isa_flags
3533         |= TARGET_SUBTARGET32_ISA_DEFAULT & ~ix86_isa_flags_explicit;
3534
3535       /* i386 ABI does not specify red zone.  It still makes sense to use it
3536          when programmer takes care to stack from being destroyed.  */
3537       if (!(target_flags_explicit & MASK_NO_RED_ZONE))
3538         target_flags |= MASK_NO_RED_ZONE;
3539     }
3540
3541   /* Keep nonleaf frame pointers.  */
3542   if (flag_omit_frame_pointer)
3543     target_flags &= ~MASK_OMIT_LEAF_FRAME_POINTER;
3544   else if (TARGET_OMIT_LEAF_FRAME_POINTER)
3545     flag_omit_frame_pointer = 1;
3546
3547   /* If we're doing fast math, we don't care about comparison order
3548      wrt NaNs.  This lets us use a shorter comparison sequence.  */
3549   if (flag_finite_math_only)
3550     target_flags &= ~MASK_IEEE_FP;
3551
3552   /* If the architecture always has an FPU, turn off NO_FANCY_MATH_387,
3553      since the insns won't need emulation.  */
3554   if (x86_arch_always_fancy_math_387 & ix86_arch_mask)
3555     target_flags &= ~MASK_NO_FANCY_MATH_387;
3556
3557   /* Likewise, if the target doesn't have a 387, or we've specified
3558      software floating point, don't use 387 inline intrinsics.  */
3559   if (!TARGET_80387)
3560     target_flags |= MASK_NO_FANCY_MATH_387;
3561
3562   /* Turn on MMX builtins for -msse.  */
3563   if (TARGET_SSE)
3564     {
3565       ix86_isa_flags |= OPTION_MASK_ISA_MMX & ~ix86_isa_flags_explicit;
3566       x86_prefetch_sse = true;
3567     }
3568
3569   /* Turn on popcnt instruction for -msse4.2 or -mabm.  */
3570   if (TARGET_SSE4_2 || TARGET_ABM)
3571     ix86_isa_flags |= OPTION_MASK_ISA_POPCNT & ~ix86_isa_flags_explicit;
3572
3573   /* Turn on lzcnt instruction for -mabm.  */
3574   if (TARGET_ABM)
3575     ix86_isa_flags |= OPTION_MASK_ISA_LZCNT & ~ix86_isa_flags_explicit;
3576
3577   /* Validate -mpreferred-stack-boundary= value or default it to
3578      PREFERRED_STACK_BOUNDARY_DEFAULT.  */
3579   ix86_preferred_stack_boundary = PREFERRED_STACK_BOUNDARY_DEFAULT;
3580   if (global_options_set.x_ix86_preferred_stack_boundary_arg)
3581     {
3582       int min = (TARGET_64BIT ? 4 : 2);
3583       int max = (TARGET_SEH ? 4 : 12);
3584
3585       if (ix86_preferred_stack_boundary_arg < min
3586           || ix86_preferred_stack_boundary_arg > max)
3587         {
3588           if (min == max)
3589             error ("-mpreferred-stack-boundary is not supported "
3590                    "for this target");
3591           else
3592             error ("-mpreferred-stack-boundary=%d is not between %d and %d",
3593                    ix86_preferred_stack_boundary_arg, min, max);
3594         }
3595       else
3596         ix86_preferred_stack_boundary
3597           = (1 << ix86_preferred_stack_boundary_arg) * BITS_PER_UNIT;
3598     }
3599
3600   /* Set the default value for -mstackrealign.  */
3601   if (ix86_force_align_arg_pointer == -1)
3602     ix86_force_align_arg_pointer = STACK_REALIGN_DEFAULT;
3603
3604   ix86_default_incoming_stack_boundary = PREFERRED_STACK_BOUNDARY;
3605
3606   /* Validate -mincoming-stack-boundary= value or default it to
3607      MIN_STACK_BOUNDARY/PREFERRED_STACK_BOUNDARY.  */
3608   ix86_incoming_stack_boundary = ix86_default_incoming_stack_boundary;
3609   if (global_options_set.x_ix86_incoming_stack_boundary_arg)
3610     {
3611       if (ix86_incoming_stack_boundary_arg < (TARGET_64BIT ? 4 : 2)
3612           || ix86_incoming_stack_boundary_arg > 12)
3613         error ("-mincoming-stack-boundary=%d is not between %d and 12",
3614                ix86_incoming_stack_boundary_arg, TARGET_64BIT ? 4 : 2);
3615       else
3616         {
3617           ix86_user_incoming_stack_boundary
3618             = (1 << ix86_incoming_stack_boundary_arg) * BITS_PER_UNIT;
3619           ix86_incoming_stack_boundary
3620             = ix86_user_incoming_stack_boundary;
3621         }
3622     }
3623
3624   /* Accept -msseregparm only if at least SSE support is enabled.  */
3625   if (TARGET_SSEREGPARM
3626       && ! TARGET_SSE)
3627     error ("%ssseregparm%s used without SSE enabled", prefix, suffix);
3628
3629   if (global_options_set.x_ix86_fpmath)
3630     {
3631       if (ix86_fpmath & FPMATH_SSE)
3632         {
3633           if (!TARGET_SSE)
3634             {
3635               warning (0, "SSE instruction set disabled, using 387 arithmetics");
3636               ix86_fpmath = FPMATH_387;
3637             }
3638           else if ((ix86_fpmath & FPMATH_387) && !TARGET_80387)
3639             {
3640               warning (0, "387 instruction set disabled, using SSE arithmetics");
3641               ix86_fpmath = FPMATH_SSE;
3642             }
3643         }
3644     }
3645   else
3646     ix86_fpmath = TARGET_FPMATH_DEFAULT;
3647
3648   /* If the i387 is disabled, then do not return values in it. */
3649   if (!TARGET_80387)
3650     target_flags &= ~MASK_FLOAT_RETURNS;
3651
3652   /* Use external vectorized library in vectorizing intrinsics.  */
3653   if (global_options_set.x_ix86_veclibabi_type)
3654     switch (ix86_veclibabi_type)
3655       {
3656       case ix86_veclibabi_type_svml:
3657         ix86_veclib_handler = ix86_veclibabi_svml;
3658         break;
3659
3660       case ix86_veclibabi_type_acml:
3661         ix86_veclib_handler = ix86_veclibabi_acml;
3662         break;
3663
3664       default:
3665         gcc_unreachable ();
3666       }
3667
3668   if ((!USE_IX86_FRAME_POINTER
3669        || (x86_accumulate_outgoing_args & ix86_tune_mask))
3670       && !(target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3671       && !optimize_size)
3672     target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3673
3674   /* ??? Unwind info is not correct around the CFG unless either a frame
3675      pointer is present or M_A_O_A is set.  Fixing this requires rewriting
3676      unwind info generation to be aware of the CFG and propagating states
3677      around edges.  */
3678   if ((flag_unwind_tables || flag_asynchronous_unwind_tables
3679        || flag_exceptions || flag_non_call_exceptions)
3680       && flag_omit_frame_pointer
3681       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3682     {
3683       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3684         warning (0, "unwind tables currently require either a frame pointer "
3685                  "or %saccumulate-outgoing-args%s for correctness",
3686                  prefix, suffix);
3687       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3688     }
3689
3690   /* If stack probes are required, the space used for large function
3691      arguments on the stack must also be probed, so enable
3692      -maccumulate-outgoing-args so this happens in the prologue.  */
3693   if (TARGET_STACK_PROBE
3694       && !(target_flags & MASK_ACCUMULATE_OUTGOING_ARGS))
3695     {
3696       if (target_flags_explicit & MASK_ACCUMULATE_OUTGOING_ARGS)
3697         warning (0, "stack probing requires %saccumulate-outgoing-args%s "
3698                  "for correctness", prefix, suffix);
3699       target_flags |= MASK_ACCUMULATE_OUTGOING_ARGS;
3700     }
3701
3702   /* For sane SSE instruction set generation we need fcomi instruction.
3703      It is safe to enable all CMOVE instructions.  Also, RDRAND intrinsic
3704      expands to a sequence that includes conditional move. */
3705   if (TARGET_SSE || TARGET_RDRND)
3706     TARGET_CMOVE = 1;
3707
3708   /* Figure out what ASM_GENERATE_INTERNAL_LABEL builds as a prefix.  */
3709   {
3710     char *p;
3711     ASM_GENERATE_INTERNAL_LABEL (internal_label_prefix, "LX", 0);
3712     p = strchr (internal_label_prefix, 'X');
3713     internal_label_prefix_len = p - internal_label_prefix;
3714     *p = '\0';
3715   }
3716
3717   /* When scheduling description is not available, disable scheduler pass
3718      so it won't slow down the compilation and make x87 code slower.  */
3719   if (!TARGET_SCHEDULE)
3720     flag_schedule_insns_after_reload = flag_schedule_insns = 0;
3721
3722   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3723                          ix86_cost->simultaneous_prefetches,
3724                          global_options.x_param_values,
3725                          global_options_set.x_param_values);
3726   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, ix86_cost->prefetch_block,
3727                          global_options.x_param_values,
3728                          global_options_set.x_param_values);
3729   maybe_set_param_value (PARAM_L1_CACHE_SIZE, ix86_cost->l1_cache_size,
3730                          global_options.x_param_values,
3731                          global_options_set.x_param_values);
3732   maybe_set_param_value (PARAM_L2_CACHE_SIZE, ix86_cost->l2_cache_size,
3733                          global_options.x_param_values,
3734                          global_options_set.x_param_values);
3735
3736   /* Enable sw prefetching at -O3 for CPUS that prefetching is helpful.  */
3737   if (flag_prefetch_loop_arrays < 0
3738       && HAVE_prefetch
3739       && optimize >= 3
3740       && TARGET_SOFTWARE_PREFETCHING_BENEFICIAL)
3741     flag_prefetch_loop_arrays = 1;
3742
3743   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
3744      can be optimized to ap = __builtin_next_arg (0).  */
3745   if (!TARGET_64BIT && !flag_split_stack)
3746     targetm.expand_builtin_va_start = NULL;
3747
3748   if (TARGET_64BIT)
3749     {
3750       ix86_gen_leave = gen_leave_rex64;
3751       ix86_gen_add3 = gen_adddi3;
3752       ix86_gen_sub3 = gen_subdi3;
3753       ix86_gen_sub3_carry = gen_subdi3_carry;
3754       ix86_gen_one_cmpl2 = gen_one_cmpldi2;
3755       ix86_gen_monitor = gen_sse3_monitor64;
3756       ix86_gen_andsp = gen_anddi3;
3757       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_di;
3758       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probedi;
3759       ix86_gen_probe_stack_range = gen_probe_stack_rangedi;
3760     }
3761   else
3762     {
3763       ix86_gen_leave = gen_leave;
3764       ix86_gen_add3 = gen_addsi3;
3765       ix86_gen_sub3 = gen_subsi3;
3766       ix86_gen_sub3_carry = gen_subsi3_carry;
3767       ix86_gen_one_cmpl2 = gen_one_cmplsi2;
3768       ix86_gen_monitor = gen_sse3_monitor;
3769       ix86_gen_andsp = gen_andsi3;
3770       ix86_gen_allocate_stack_worker = gen_allocate_stack_worker_probe_si;
3771       ix86_gen_adjust_stack_and_probe = gen_adjust_stack_and_probesi;
3772       ix86_gen_probe_stack_range = gen_probe_stack_rangesi;
3773     }
3774
3775 #ifdef USE_IX86_CLD
3776   /* Use -mcld by default for 32-bit code if configured with --enable-cld.  */
3777   if (!TARGET_64BIT)
3778     target_flags |= MASK_CLD & ~target_flags_explicit;
3779 #endif
3780
3781   if (!TARGET_64BIT && flag_pic)
3782     {
3783       if (flag_fentry > 0)
3784         sorry ("-mfentry isn%'t supported for 32-bit in combination "
3785                "with -fpic");
3786       flag_fentry = 0;
3787     }
3788   else if (TARGET_SEH)
3789     {
3790       if (flag_fentry == 0)
3791         sorry ("-mno-fentry isn%'t compatible with SEH");
3792       flag_fentry = 1;
3793     }
3794   else if (flag_fentry < 0)
3795    {
3796 #if defined(PROFILE_BEFORE_PROLOGUE)
3797      flag_fentry = 1;
3798 #else
3799      flag_fentry = 0;
3800 #endif
3801    }
3802
3803   if (TARGET_AVX)
3804     {
3805       /* When not optimize for size, enable vzeroupper optimization for
3806          TARGET_AVX with -fexpensive-optimizations and split 32-byte
3807          AVX unaligned load/store.  */
3808       if (!optimize_size)
3809         {
3810           if (flag_expensive_optimizations
3811               && !(target_flags_explicit & MASK_VZEROUPPER))
3812             target_flags |= MASK_VZEROUPPER;
3813           if ((x86_avx256_split_unaligned_load & ix86_tune_mask)
3814               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_LOAD))
3815             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_LOAD;
3816           if ((x86_avx256_split_unaligned_store & ix86_tune_mask)
3817               && !(target_flags_explicit & MASK_AVX256_SPLIT_UNALIGNED_STORE))
3818             target_flags |= MASK_AVX256_SPLIT_UNALIGNED_STORE;
3819           /* Enable 128-bit AVX instruction generation for the auto-vectorizer.  */
3820           if (TARGET_AVX128_OPTIMAL && !(target_flags_explicit & MASK_PREFER_AVX128))
3821             target_flags |= MASK_PREFER_AVX128;
3822         }
3823     }
3824   else
3825     {
3826       /* Disable vzeroupper pass if TARGET_AVX is disabled.  */
3827       target_flags &= ~MASK_VZEROUPPER;
3828     }
3829
3830   if (ix86_recip_name)
3831     {
3832       char *p = ASTRDUP (ix86_recip_name);
3833       char *q;
3834       unsigned int mask, i;
3835       bool invert;
3836
3837       while ((q = strtok (p, ",")) != NULL)
3838         {
3839           p = NULL;
3840           if (*q == '!')
3841             {
3842               invert = true;
3843               q++;
3844             }
3845           else
3846             invert = false;
3847
3848           if (!strcmp (q, "default"))
3849             mask = RECIP_MASK_ALL;
3850           else
3851             {
3852               for (i = 0; i < ARRAY_SIZE (recip_options); i++)
3853                 if (!strcmp (q, recip_options[i].string))
3854                   {
3855                     mask = recip_options[i].mask;
3856                     break;
3857                   }
3858
3859               if (i == ARRAY_SIZE (recip_options))
3860                 {
3861                   error ("unknown option for -mrecip=%s", q);
3862                   invert = false;
3863                   mask = RECIP_MASK_NONE;
3864                 }
3865             }
3866
3867           recip_mask_explicit |= mask;
3868           if (invert)
3869             recip_mask &= ~mask;
3870           else
3871             recip_mask |= mask;
3872         }
3873     }
3874
3875   if (TARGET_RECIP)
3876     recip_mask |= RECIP_MASK_ALL & ~recip_mask_explicit;
3877   else if (target_flags_explicit & MASK_RECIP)
3878     recip_mask &= ~(RECIP_MASK_ALL & ~recip_mask_explicit);
3879
3880   /* Save the initial options in case the user does function specific
3881      options.  */
3882   if (main_args_p)
3883     target_option_default_node = target_option_current_node
3884       = build_target_option_node ();
3885 }
3886
3887 /* Return TRUE if VAL is passed in register with 256bit AVX modes.  */
3888
3889 static bool
3890 function_pass_avx256_p (const_rtx val)
3891 {
3892   if (!val)
3893     return false;
3894
3895   if (REG_P (val) && VALID_AVX256_REG_MODE (GET_MODE (val)))
3896     return true;
3897
3898   if (GET_CODE (val) == PARALLEL)
3899     {
3900       int i;
3901       rtx r;
3902
3903       for (i = XVECLEN (val, 0) - 1; i >= 0; i--)
3904         {
3905           r = XVECEXP (val, 0, i);
3906           if (GET_CODE (r) == EXPR_LIST
3907               && XEXP (r, 0)
3908               && REG_P (XEXP (r, 0))
3909               && (GET_MODE (XEXP (r, 0)) == OImode
3910                   || VALID_AVX256_REG_MODE (GET_MODE (XEXP (r, 0)))))
3911             return true;
3912         }
3913     }
3914
3915   return false;
3916 }
3917
3918 /* Implement the TARGET_OPTION_OVERRIDE hook.  */
3919
3920 static void
3921 ix86_option_override (void)
3922 {
3923   ix86_option_override_internal (true);
3924 }
3925
3926 /* Update register usage after having seen the compiler flags.  */
3927
3928 static void
3929 ix86_conditional_register_usage (void)
3930 {
3931   int i;
3932   unsigned int j;
3933
3934   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3935     {
3936       if (fixed_regs[i] > 1)
3937         fixed_regs[i] = (fixed_regs[i] == (TARGET_64BIT ? 3 : 2));
3938       if (call_used_regs[i] > 1)
3939         call_used_regs[i] = (call_used_regs[i] == (TARGET_64BIT ? 3 : 2));
3940     }
3941
3942   /* The PIC register, if it exists, is fixed.  */
3943   j = PIC_OFFSET_TABLE_REGNUM;
3944   if (j != INVALID_REGNUM)
3945     fixed_regs[j] = call_used_regs[j] = 1;
3946
3947   /* The 64-bit MS_ABI changes the set of call-used registers.  */
3948   if (TARGET_64BIT_MS_ABI)
3949     {
3950       call_used_regs[SI_REG] = 0;
3951       call_used_regs[DI_REG] = 0;
3952       call_used_regs[XMM6_REG] = 0;
3953       call_used_regs[XMM7_REG] = 0;
3954       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3955         call_used_regs[i] = 0;
3956     }
3957
3958   /* The default setting of CLOBBERED_REGS is for 32-bit; add in the
3959      other call-clobbered regs for 64-bit.  */
3960   if (TARGET_64BIT)
3961     {
3962       CLEAR_HARD_REG_SET (reg_class_contents[(int)CLOBBERED_REGS]);
3963
3964       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3965         if (TEST_HARD_REG_BIT (reg_class_contents[(int)GENERAL_REGS], i)
3966             && call_used_regs[i])
3967           SET_HARD_REG_BIT (reg_class_contents[(int)CLOBBERED_REGS], i);
3968     }
3969
3970   /* If MMX is disabled, squash the registers.  */
3971   if (! TARGET_MMX)
3972     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3973       if (TEST_HARD_REG_BIT (reg_class_contents[(int)MMX_REGS], i))
3974         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3975
3976   /* If SSE is disabled, squash the registers.  */
3977   if (! TARGET_SSE)
3978     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3979       if (TEST_HARD_REG_BIT (reg_class_contents[(int)SSE_REGS], i))
3980         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3981
3982   /* If the FPU is disabled, squash the registers.  */
3983   if (! (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387))
3984     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3985       if (TEST_HARD_REG_BIT (reg_class_contents[(int)FLOAT_REGS], i))
3986         fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = "";
3987
3988   /* If 32-bit, squash the 64-bit registers.  */
3989   if (! TARGET_64BIT)
3990     {
3991       for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++)
3992         reg_names[i] = "";
3993       for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
3994         reg_names[i] = "";
3995     }
3996 }
3997
3998 \f
3999 /* Save the current options */
4000
4001 static void
4002 ix86_function_specific_save (struct cl_target_option *ptr)
4003 {
4004   ptr->arch = ix86_arch;
4005   ptr->schedule = ix86_schedule;
4006   ptr->tune = ix86_tune;
4007   ptr->branch_cost = ix86_branch_cost;
4008   ptr->tune_defaulted = ix86_tune_defaulted;
4009   ptr->arch_specified = ix86_arch_specified;
4010   ptr->x_ix86_isa_flags_explicit = ix86_isa_flags_explicit;
4011   ptr->ix86_target_flags_explicit = target_flags_explicit;
4012   ptr->x_recip_mask_explicit = recip_mask_explicit;
4013
4014   /* The fields are char but the variables are not; make sure the
4015      values fit in the fields.  */
4016   gcc_assert (ptr->arch == ix86_arch);
4017   gcc_assert (ptr->schedule == ix86_schedule);
4018   gcc_assert (ptr->tune == ix86_tune);
4019   gcc_assert (ptr->branch_cost == ix86_branch_cost);
4020 }
4021
4022 /* Restore the current options */
4023
4024 static void
4025 ix86_function_specific_restore (struct cl_target_option *ptr)
4026 {
4027   enum processor_type old_tune = ix86_tune;
4028   enum processor_type old_arch = ix86_arch;
4029   unsigned int ix86_arch_mask, ix86_tune_mask;
4030   int i;
4031
4032   ix86_arch = (enum processor_type) ptr->arch;
4033   ix86_schedule = (enum attr_cpu) ptr->schedule;
4034   ix86_tune = (enum processor_type) ptr->tune;
4035   ix86_branch_cost = ptr->branch_cost;
4036   ix86_tune_defaulted = ptr->tune_defaulted;
4037   ix86_arch_specified = ptr->arch_specified;
4038   ix86_isa_flags_explicit = ptr->x_ix86_isa_flags_explicit;
4039   target_flags_explicit = ptr->ix86_target_flags_explicit;
4040   recip_mask_explicit = ptr->x_recip_mask_explicit;
4041
4042   /* Recreate the arch feature tests if the arch changed */
4043   if (old_arch != ix86_arch)
4044     {
4045       ix86_arch_mask = 1u << ix86_arch;
4046       for (i = 0; i < X86_ARCH_LAST; ++i)
4047         ix86_arch_features[i]
4048           = !!(initial_ix86_arch_features[i] & ix86_arch_mask);
4049     }
4050
4051   /* Recreate the tune optimization tests */
4052   if (old_tune != ix86_tune)
4053     {
4054       ix86_tune_mask = 1u << ix86_tune;
4055       for (i = 0; i < X86_TUNE_LAST; ++i)
4056         ix86_tune_features[i]
4057           = !!(initial_ix86_tune_features[i] & ix86_tune_mask);
4058     }
4059 }
4060
4061 /* Print the current options */
4062
4063 static void
4064 ix86_function_specific_print (FILE *file, int indent,
4065                               struct cl_target_option *ptr)
4066 {
4067   char *target_string
4068     = ix86_target_string (ptr->x_ix86_isa_flags, ptr->x_target_flags,
4069                           NULL, NULL, ptr->x_ix86_fpmath, false);
4070
4071   fprintf (file, "%*sarch = %d (%s)\n",
4072            indent, "",
4073            ptr->arch,
4074            ((ptr->arch < TARGET_CPU_DEFAULT_max)
4075             ? cpu_names[ptr->arch]
4076             : "<unknown>"));
4077
4078   fprintf (file, "%*stune = %d (%s)\n",
4079            indent, "",
4080            ptr->tune,
4081            ((ptr->tune < TARGET_CPU_DEFAULT_max)
4082             ? cpu_names[ptr->tune]
4083             : "<unknown>"));
4084
4085   fprintf (file, "%*sbranch_cost = %d\n", indent, "", ptr->branch_cost);
4086
4087   if (target_string)
4088     {
4089       fprintf (file, "%*s%s\n", indent, "", target_string);
4090       free (target_string);
4091     }
4092 }
4093
4094 \f
4095 /* Inner function to process the attribute((target(...))), take an argument and
4096    set the current options from the argument. If we have a list, recursively go
4097    over the list.  */
4098
4099 static bool
4100 ix86_valid_target_attribute_inner_p (tree args, char *p_strings[],
4101                                      struct gcc_options *enum_opts_set)
4102 {
4103   char *next_optstr;
4104   bool ret = true;
4105
4106 #define IX86_ATTR_ISA(S,O)   { S, sizeof (S)-1, ix86_opt_isa, O, 0 }
4107 #define IX86_ATTR_STR(S,O)   { S, sizeof (S)-1, ix86_opt_str, O, 0 }
4108 #define IX86_ATTR_ENUM(S,O)  { S, sizeof (S)-1, ix86_opt_enum, O, 0 }
4109 #define IX86_ATTR_YES(S,O,M) { S, sizeof (S)-1, ix86_opt_yes, O, M }
4110 #define IX86_ATTR_NO(S,O,M)  { S, sizeof (S)-1, ix86_opt_no,  O, M }
4111
4112   enum ix86_opt_type
4113   {
4114     ix86_opt_unknown,
4115     ix86_opt_yes,
4116     ix86_opt_no,
4117     ix86_opt_str,
4118     ix86_opt_enum,
4119     ix86_opt_isa
4120   };
4121
4122   static const struct
4123   {
4124     const char *string;
4125     size_t len;
4126     enum ix86_opt_type type;
4127     int opt;
4128     int mask;
4129   } attrs[] = {
4130     /* isa options */
4131     IX86_ATTR_ISA ("3dnow",     OPT_m3dnow),
4132     IX86_ATTR_ISA ("abm",       OPT_mabm),
4133     IX86_ATTR_ISA ("bmi",       OPT_mbmi),
4134     IX86_ATTR_ISA ("bmi2",      OPT_mbmi2),
4135     IX86_ATTR_ISA ("lzcnt",     OPT_mlzcnt),
4136     IX86_ATTR_ISA ("tbm",       OPT_mtbm),
4137     IX86_ATTR_ISA ("aes",       OPT_maes),
4138     IX86_ATTR_ISA ("avx",       OPT_mavx),
4139     IX86_ATTR_ISA ("avx2",      OPT_mavx2),
4140     IX86_ATTR_ISA ("mmx",       OPT_mmmx),
4141     IX86_ATTR_ISA ("pclmul",    OPT_mpclmul),
4142     IX86_ATTR_ISA ("popcnt",    OPT_mpopcnt),
4143     IX86_ATTR_ISA ("sse",       OPT_msse),
4144     IX86_ATTR_ISA ("sse2",      OPT_msse2),
4145     IX86_ATTR_ISA ("sse3",      OPT_msse3),
4146     IX86_ATTR_ISA ("sse4",      OPT_msse4),
4147     IX86_ATTR_ISA ("sse4.1",    OPT_msse4_1),
4148     IX86_ATTR_ISA ("sse4.2",    OPT_msse4_2),
4149     IX86_ATTR_ISA ("sse4a",     OPT_msse4a),
4150     IX86_ATTR_ISA ("ssse3",     OPT_mssse3),
4151     IX86_ATTR_ISA ("fma4",      OPT_mfma4),
4152     IX86_ATTR_ISA ("fma",       OPT_mfma),
4153     IX86_ATTR_ISA ("xop",       OPT_mxop),
4154     IX86_ATTR_ISA ("lwp",       OPT_mlwp),
4155     IX86_ATTR_ISA ("fsgsbase",  OPT_mfsgsbase),
4156     IX86_ATTR_ISA ("rdrnd",     OPT_mrdrnd),
4157     IX86_ATTR_ISA ("f16c",      OPT_mf16c),
4158
4159     /* enum options */
4160     IX86_ATTR_ENUM ("fpmath=",  OPT_mfpmath_),
4161
4162     /* string options */
4163     IX86_ATTR_STR ("arch=",     IX86_FUNCTION_SPECIFIC_ARCH),
4164     IX86_ATTR_STR ("tune=",     IX86_FUNCTION_SPECIFIC_TUNE),
4165
4166     /* flag options */
4167     IX86_ATTR_YES ("cld",
4168                    OPT_mcld,
4169                    MASK_CLD),
4170
4171     IX86_ATTR_NO ("fancy-math-387",
4172                   OPT_mfancy_math_387,
4173                   MASK_NO_FANCY_MATH_387),
4174
4175     IX86_ATTR_YES ("ieee-fp",
4176                    OPT_mieee_fp,
4177                    MASK_IEEE_FP),
4178
4179     IX86_ATTR_YES ("inline-all-stringops",
4180                    OPT_minline_all_stringops,
4181                    MASK_INLINE_ALL_STRINGOPS),
4182
4183     IX86_ATTR_YES ("inline-stringops-dynamically",
4184                    OPT_minline_stringops_dynamically,
4185                    MASK_INLINE_STRINGOPS_DYNAMICALLY),
4186
4187     IX86_ATTR_NO ("align-stringops",
4188                   OPT_mno_align_stringops,
4189                   MASK_NO_ALIGN_STRINGOPS),
4190
4191     IX86_ATTR_YES ("recip",
4192                    OPT_mrecip,
4193                    MASK_RECIP),
4194
4195   };
4196
4197   /* If this is a list, recurse to get the options.  */
4198   if (TREE_CODE (args) == TREE_LIST)
4199     {
4200       bool ret = true;
4201
4202       for (; args; args = TREE_CHAIN (args))
4203         if (TREE_VALUE (args)
4204             && !ix86_valid_target_attribute_inner_p (TREE_VALUE (args),
4205                                                      p_strings, enum_opts_set))
4206           ret = false;
4207
4208       return ret;
4209     }
4210
4211   else if (TREE_CODE (args) != STRING_CST)
4212     gcc_unreachable ();
4213
4214   /* Handle multiple arguments separated by commas.  */
4215   next_optstr = ASTRDUP (TREE_STRING_POINTER (args));
4216
4217   while (next_optstr && *next_optstr != '\0')
4218     {
4219       char *p = next_optstr;
4220       char *orig_p = p;
4221       char *comma = strchr (next_optstr, ',');
4222       const char *opt_string;
4223       size_t len, opt_len;
4224       int opt;
4225       bool opt_set_p;
4226       char ch;
4227       unsigned i;
4228       enum ix86_opt_type type = ix86_opt_unknown;
4229       int mask = 0;
4230
4231       if (comma)
4232         {
4233           *comma = '\0';
4234           len = comma - next_optstr;
4235           next_optstr = comma + 1;
4236         }
4237       else
4238         {
4239           len = strlen (p);
4240           next_optstr = NULL;
4241         }
4242
4243       /* Recognize no-xxx.  */
4244       if (len > 3 && p[0] == 'n' && p[1] == 'o' && p[2] == '-')
4245         {
4246           opt_set_p = false;
4247           p += 3;
4248           len -= 3;
4249         }
4250       else
4251         opt_set_p = true;
4252
4253       /* Find the option.  */
4254       ch = *p;
4255       opt = N_OPTS;
4256       for (i = 0; i < ARRAY_SIZE (attrs); i++)
4257         {
4258           type = attrs[i].type;
4259           opt_len = attrs[i].len;
4260           if (ch == attrs[i].string[0]
4261               && ((type != ix86_opt_str && type != ix86_opt_enum)
4262                   ? len == opt_len
4263                   : len > opt_len)
4264               && memcmp (p, attrs[i].string, opt_len) == 0)
4265             {
4266               opt = attrs[i].opt;
4267               mask = attrs[i].mask;
4268               opt_string = attrs[i].string;
4269               break;
4270             }
4271         }
4272
4273       /* Process the option.  */
4274       if (opt == N_OPTS)
4275         {
4276           error ("attribute(target(\"%s\")) is unknown", orig_p);
4277           ret = false;
4278         }
4279
4280       else if (type == ix86_opt_isa)
4281         {
4282           struct cl_decoded_option decoded;
4283
4284           generate_option (opt, NULL, opt_set_p, CL_TARGET, &decoded);
4285           ix86_handle_option (&global_options, &global_options_set,
4286                               &decoded, input_location);
4287         }
4288
4289       else if (type == ix86_opt_yes || type == ix86_opt_no)
4290         {
4291           if (type == ix86_opt_no)
4292             opt_set_p = !opt_set_p;
4293
4294           if (opt_set_p)
4295             target_flags |= mask;
4296           else
4297             target_flags &= ~mask;
4298         }
4299
4300       else if (type == ix86_opt_str)
4301         {
4302           if (p_strings[opt])
4303             {
4304               error ("option(\"%s\") was already specified", opt_string);
4305               ret = false;
4306             }
4307           else
4308             p_strings[opt] = xstrdup (p + opt_len);
4309         }
4310
4311       else if (type == ix86_opt_enum)
4312         {
4313           bool arg_ok;
4314           int value;
4315
4316           arg_ok = opt_enum_arg_to_value (opt, p + opt_len, &value, CL_TARGET);
4317           if (arg_ok)
4318             set_option (&global_options, enum_opts_set, opt, value,
4319                         p + opt_len, DK_UNSPECIFIED, input_location,
4320                         global_dc);
4321           else
4322             {
4323               error ("attribute(target(\"%s\")) is unknown", orig_p);
4324               ret = false;
4325             }
4326         }
4327
4328       else
4329         gcc_unreachable ();
4330     }
4331
4332   return ret;
4333 }
4334
4335 /* Return a TARGET_OPTION_NODE tree of the target options listed or NULL.  */
4336
4337 tree
4338 ix86_valid_target_attribute_tree (tree args)
4339 {
4340   const char *orig_arch_string = ix86_arch_string;
4341   const char *orig_tune_string = ix86_tune_string;
4342   enum fpmath_unit orig_fpmath_set = global_options_set.x_ix86_fpmath;
4343   int orig_tune_defaulted = ix86_tune_defaulted;
4344   int orig_arch_specified = ix86_arch_specified;
4345   char *option_strings[IX86_FUNCTION_SPECIFIC_MAX] = { NULL, NULL };
4346   tree t = NULL_TREE;
4347   int i;
4348   struct cl_target_option *def
4349     = TREE_TARGET_OPTION (target_option_default_node);
4350   struct gcc_options enum_opts_set;
4351
4352   memset (&enum_opts_set, 0, sizeof (enum_opts_set));
4353
4354   /* Process each of the options on the chain.  */
4355   if (! ix86_valid_target_attribute_inner_p (args, option_strings,
4356                                              &enum_opts_set))
4357     return NULL_TREE;
4358
4359   /* If the changed options are different from the default, rerun
4360      ix86_option_override_internal, and then save the options away.
4361      The string options are are attribute options, and will be undone
4362      when we copy the save structure.  */
4363   if (ix86_isa_flags != def->x_ix86_isa_flags
4364       || target_flags != def->x_target_flags
4365       || option_strings[IX86_FUNCTION_SPECIFIC_ARCH]
4366       || option_strings[IX86_FUNCTION_SPECIFIC_TUNE]
4367       || enum_opts_set.x_ix86_fpmath)
4368     {
4369       /* If we are using the default tune= or arch=, undo the string assigned,
4370          and use the default.  */
4371       if (option_strings[IX86_FUNCTION_SPECIFIC_ARCH])
4372         ix86_arch_string = option_strings[IX86_FUNCTION_SPECIFIC_ARCH];
4373       else if (!orig_arch_specified)
4374         ix86_arch_string = NULL;
4375
4376       if (option_strings[IX86_FUNCTION_SPECIFIC_TUNE])
4377         ix86_tune_string = option_strings[IX86_FUNCTION_SPECIFIC_TUNE];
4378       else if (orig_tune_defaulted)
4379         ix86_tune_string = NULL;
4380
4381       /* If fpmath= is not set, and we now have sse2 on 32-bit, use it.  */
4382       if (enum_opts_set.x_ix86_fpmath)
4383         global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4384       else if (!TARGET_64BIT && TARGET_SSE)
4385         {
4386           ix86_fpmath = (enum fpmath_unit) (FPMATH_SSE | FPMATH_387);
4387           global_options_set.x_ix86_fpmath = (enum fpmath_unit) 1;
4388         }
4389
4390       /* Do any overrides, such as arch=xxx, or tune=xxx support.  */
4391       ix86_option_override_internal (false);
4392
4393       /* Add any builtin functions with the new isa if any.  */
4394       ix86_add_new_builtins (ix86_isa_flags);
4395
4396       /* Save the current options unless we are validating options for
4397          #pragma.  */
4398       t = build_target_option_node ();
4399
4400       ix86_arch_string = orig_arch_string;
4401       ix86_tune_string = orig_tune_string;
4402       global_options_set.x_ix86_fpmath = orig_fpmath_set;
4403
4404       /* Free up memory allocated to hold the strings */
4405       for (i = 0; i < IX86_FUNCTION_SPECIFIC_MAX; i++)
4406         free (option_strings[i]);
4407     }
4408
4409   return t;
4410 }
4411
4412 /* Hook to validate attribute((target("string"))).  */
4413
4414 static bool
4415 ix86_valid_target_attribute_p (tree fndecl,
4416                                tree ARG_UNUSED (name),
4417                                tree args,
4418                                int ARG_UNUSED (flags))
4419 {
4420   struct cl_target_option cur_target;
4421   bool ret = true;
4422   tree old_optimize = build_optimization_node ();
4423   tree new_target, new_optimize;
4424   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
4425
4426   /* If the function changed the optimization levels as well as setting target
4427      options, start with the optimizations specified.  */
4428   if (func_optimize && func_optimize != old_optimize)
4429     cl_optimization_restore (&global_options,
4430                              TREE_OPTIMIZATION (func_optimize));
4431
4432   /* The target attributes may also change some optimization flags, so update
4433      the optimization options if necessary.  */
4434   cl_target_option_save (&cur_target, &global_options);
4435   new_target = ix86_valid_target_attribute_tree (args);
4436   new_optimize = build_optimization_node ();
4437
4438   if (!new_target)
4439     ret = false;
4440
4441   else if (fndecl)
4442     {
4443       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
4444
4445       if (old_optimize != new_optimize)
4446         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
4447     }
4448
4449   cl_target_option_restore (&global_options, &cur_target);
4450
4451   if (old_optimize != new_optimize)
4452     cl_optimization_restore (&global_options,
4453                              TREE_OPTIMIZATION (old_optimize));
4454
4455   return ret;
4456 }
4457
4458 \f
4459 /* Hook to determine if one function can safely inline another.  */
4460
4461 static bool
4462 ix86_can_inline_p (tree caller, tree callee)
4463 {
4464   bool ret = false;
4465   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
4466   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
4467
4468   /* If callee has no option attributes, then it is ok to inline.  */
4469   if (!callee_tree)
4470     ret = true;
4471
4472   /* If caller has no option attributes, but callee does then it is not ok to
4473      inline.  */
4474   else if (!caller_tree)
4475     ret = false;
4476
4477   else
4478     {
4479       struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
4480       struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
4481
4482       /* Callee's isa options should a subset of the caller's, i.e. a SSE4 function
4483          can inline a SSE2 function but a SSE2 function can't inline a SSE4
4484          function.  */
4485       if ((caller_opts->x_ix86_isa_flags & callee_opts->x_ix86_isa_flags)
4486           != callee_opts->x_ix86_isa_flags)
4487         ret = false;
4488
4489       /* See if we have the same non-isa options.  */
4490       else if (caller_opts->x_target_flags != callee_opts->x_target_flags)
4491         ret = false;
4492
4493       /* See if arch, tune, etc. are the same.  */
4494       else if (caller_opts->arch != callee_opts->arch)
4495         ret = false;
4496
4497       else if (caller_opts->tune != callee_opts->tune)
4498         ret = false;
4499
4500       else if (caller_opts->x_ix86_fpmath != callee_opts->x_ix86_fpmath)
4501         ret = false;
4502
4503       else if (caller_opts->branch_cost != callee_opts->branch_cost)
4504         ret = false;
4505
4506       else
4507         ret = true;
4508     }
4509
4510   return ret;
4511 }
4512
4513 \f
4514 /* Remember the last target of ix86_set_current_function.  */
4515 static GTY(()) tree ix86_previous_fndecl;
4516
4517 /* Establish appropriate back-end context for processing the function
4518    FNDECL.  The argument might be NULL to indicate processing at top
4519    level, outside of any function scope.  */
4520 static void
4521 ix86_set_current_function (tree fndecl)
4522 {
4523   /* Only change the context if the function changes.  This hook is called
4524      several times in the course of compiling a function, and we don't want to
4525      slow things down too much or call target_reinit when it isn't safe.  */
4526   if (fndecl && fndecl != ix86_previous_fndecl)
4527     {
4528       tree old_tree = (ix86_previous_fndecl
4529                        ? DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl)
4530                        : NULL_TREE);
4531
4532       tree new_tree = (fndecl
4533                        ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl)
4534                        : NULL_TREE);
4535
4536       ix86_previous_fndecl = fndecl;
4537       if (old_tree == new_tree)
4538         ;
4539
4540       else if (new_tree)
4541         {
4542           cl_target_option_restore (&global_options,
4543                                     TREE_TARGET_OPTION (new_tree));
4544           target_reinit ();
4545         }
4546
4547       else if (old_tree)
4548         {
4549           struct cl_target_option *def
4550             = TREE_TARGET_OPTION (target_option_current_node);
4551
4552           cl_target_option_restore (&global_options, def);
4553           target_reinit ();
4554         }
4555     }
4556 }
4557
4558 \f
4559 /* Return true if this goes in large data/bss.  */
4560
4561 static bool
4562 ix86_in_large_data_p (tree exp)
4563 {
4564   if (ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC)
4565     return false;
4566
4567   /* Functions are never large data.  */
4568   if (TREE_CODE (exp) == FUNCTION_DECL)
4569     return false;
4570
4571   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
4572     {
4573       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
4574       if (strcmp (section, ".ldata") == 0
4575           || strcmp (section, ".lbss") == 0)
4576         return true;
4577       return false;
4578     }
4579   else
4580     {
4581       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
4582
4583       /* If this is an incomplete type with size 0, then we can't put it
4584          in data because it might be too big when completed.  */
4585       if (!size || size > ix86_section_threshold)
4586         return true;
4587     }
4588
4589   return false;
4590 }
4591
4592 /* Switch to the appropriate section for output of DECL.
4593    DECL is either a `VAR_DECL' node or a constant of some sort.
4594    RELOC indicates whether forming the initial value of DECL requires
4595    link-time relocations.  */
4596
4597 static section * x86_64_elf_select_section (tree, int, unsigned HOST_WIDE_INT)
4598         ATTRIBUTE_UNUSED;
4599
4600 static section *
4601 x86_64_elf_select_section (tree decl, int reloc,
4602                            unsigned HOST_WIDE_INT align)
4603 {
4604   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4605       && ix86_in_large_data_p (decl))
4606     {
4607       const char *sname = NULL;
4608       unsigned int flags = SECTION_WRITE;
4609       switch (categorize_decl_for_section (decl, reloc))
4610         {
4611         case SECCAT_DATA:
4612           sname = ".ldata";
4613           break;
4614         case SECCAT_DATA_REL:
4615           sname = ".ldata.rel";
4616           break;
4617         case SECCAT_DATA_REL_LOCAL:
4618           sname = ".ldata.rel.local";
4619           break;
4620         case SECCAT_DATA_REL_RO:
4621           sname = ".ldata.rel.ro";
4622           break;
4623         case SECCAT_DATA_REL_RO_LOCAL:
4624           sname = ".ldata.rel.ro.local";
4625           break;
4626         case SECCAT_BSS:
4627           sname = ".lbss";
4628           flags |= SECTION_BSS;
4629           break;
4630         case SECCAT_RODATA:
4631         case SECCAT_RODATA_MERGE_STR:
4632         case SECCAT_RODATA_MERGE_STR_INIT:
4633         case SECCAT_RODATA_MERGE_CONST:
4634           sname = ".lrodata";
4635           flags = 0;
4636           break;
4637         case SECCAT_SRODATA:
4638         case SECCAT_SDATA:
4639         case SECCAT_SBSS:
4640           gcc_unreachable ();
4641         case SECCAT_TEXT:
4642         case SECCAT_TDATA:
4643         case SECCAT_TBSS:
4644           /* We don't split these for medium model.  Place them into
4645              default sections and hope for best.  */
4646           break;
4647         }
4648       if (sname)
4649         {
4650           /* We might get called with string constants, but get_named_section
4651              doesn't like them as they are not DECLs.  Also, we need to set
4652              flags in that case.  */
4653           if (!DECL_P (decl))
4654             return get_section (sname, flags, NULL);
4655           return get_named_section (decl, sname, reloc);
4656         }
4657     }
4658   return default_elf_select_section (decl, reloc, align);
4659 }
4660
4661 /* Build up a unique section name, expressed as a
4662    STRING_CST node, and assign it to DECL_SECTION_NAME (decl).
4663    RELOC indicates whether the initial value of EXP requires
4664    link-time relocations.  */
4665
4666 static void ATTRIBUTE_UNUSED
4667 x86_64_elf_unique_section (tree decl, int reloc)
4668 {
4669   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4670       && ix86_in_large_data_p (decl))
4671     {
4672       const char *prefix = NULL;
4673       /* We only need to use .gnu.linkonce if we don't have COMDAT groups.  */
4674       bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
4675
4676       switch (categorize_decl_for_section (decl, reloc))
4677         {
4678         case SECCAT_DATA:
4679         case SECCAT_DATA_REL:
4680         case SECCAT_DATA_REL_LOCAL:
4681         case SECCAT_DATA_REL_RO:
4682         case SECCAT_DATA_REL_RO_LOCAL:
4683           prefix = one_only ? ".ld" : ".ldata";
4684           break;
4685         case SECCAT_BSS:
4686           prefix = one_only ? ".lb" : ".lbss";
4687           break;
4688         case SECCAT_RODATA:
4689         case SECCAT_RODATA_MERGE_STR:
4690         case SECCAT_RODATA_MERGE_STR_INIT:
4691         case SECCAT_RODATA_MERGE_CONST:
4692           prefix = one_only ? ".lr" : ".lrodata";
4693           break;
4694         case SECCAT_SRODATA:
4695         case SECCAT_SDATA:
4696         case SECCAT_SBSS:
4697           gcc_unreachable ();
4698         case SECCAT_TEXT:
4699         case SECCAT_TDATA:
4700         case SECCAT_TBSS:
4701           /* We don't split these for medium model.  Place them into
4702              default sections and hope for best.  */
4703           break;
4704         }
4705       if (prefix)
4706         {
4707           const char *name, *linkonce;
4708           char *string;
4709
4710           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4711           name = targetm.strip_name_encoding (name);
4712
4713           /* If we're using one_only, then there needs to be a .gnu.linkonce
4714              prefix to the section name.  */
4715           linkonce = one_only ? ".gnu.linkonce" : "";
4716
4717           string = ACONCAT ((linkonce, prefix, ".", name, NULL));
4718
4719           DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
4720           return;
4721         }
4722     }
4723   default_unique_section (decl, reloc);
4724 }
4725
4726 #ifdef COMMON_ASM_OP
4727 /* This says how to output assembler code to declare an
4728    uninitialized external linkage data object.
4729
4730    For medium model x86-64 we need to use .largecomm opcode for
4731    large objects.  */
4732 void
4733 x86_elf_aligned_common (FILE *file,
4734                         const char *name, unsigned HOST_WIDE_INT size,
4735                         int align)
4736 {
4737   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4738       && size > (unsigned int)ix86_section_threshold)
4739     fputs (".largecomm\t", file);
4740   else
4741     fputs (COMMON_ASM_OP, file);
4742   assemble_name (file, name);
4743   fprintf (file, "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
4744            size, align / BITS_PER_UNIT);
4745 }
4746 #endif
4747
4748 /* Utility function for targets to use in implementing
4749    ASM_OUTPUT_ALIGNED_BSS.  */
4750
4751 void
4752 x86_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
4753                         const char *name, unsigned HOST_WIDE_INT size,
4754                         int align)
4755 {
4756   if ((ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC)
4757       && size > (unsigned int)ix86_section_threshold)
4758     switch_to_section (get_named_section (decl, ".lbss", 0));
4759   else
4760     switch_to_section (bss_section);
4761   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
4762 #ifdef ASM_DECLARE_OBJECT_NAME
4763   last_assemble_variable_decl = decl;
4764   ASM_DECLARE_OBJECT_NAME (file, name, decl);
4765 #else
4766   /* Standard thing is just output label for the object.  */
4767   ASM_OUTPUT_LABEL (file, name);
4768 #endif /* ASM_DECLARE_OBJECT_NAME */
4769   ASM_OUTPUT_SKIP (file, size ? size : 1);
4770 }
4771 \f
4772 /* Decide whether we must probe the stack before any space allocation
4773    on this target.  It's essentially TARGET_STACK_PROBE except when
4774    -fstack-check causes the stack to be already probed differently.  */
4775
4776 bool
4777 ix86_target_stack_probe (void)
4778 {
4779   /* Do not probe the stack twice if static stack checking is enabled.  */
4780   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
4781     return false;
4782
4783   return TARGET_STACK_PROBE;
4784 }
4785 \f
4786 /* Decide whether we can make a sibling call to a function.  DECL is the
4787    declaration of the function being targeted by the call and EXP is the
4788    CALL_EXPR representing the call.  */
4789
4790 static bool
4791 ix86_function_ok_for_sibcall (tree decl, tree exp)
4792 {
4793   tree type, decl_or_type;
4794   rtx a, b;
4795
4796   /* If we are generating position-independent code, we cannot sibcall
4797      optimize any indirect call, or a direct call to a global function,
4798      as the PLT requires %ebx be live. (Darwin does not have a PLT.)  */
4799   if (!TARGET_MACHO
4800       && !TARGET_64BIT
4801       && flag_pic
4802       && (!decl || !targetm.binds_local_p (decl)))
4803     return false;
4804
4805   /* If we need to align the outgoing stack, then sibcalling would
4806      unalign the stack, which may break the called function.  */
4807   if (ix86_minimum_incoming_stack_boundary (true)
4808       < PREFERRED_STACK_BOUNDARY)
4809     return false;
4810
4811   if (decl)
4812     {
4813       decl_or_type = decl;
4814       type = TREE_TYPE (decl);
4815     }
4816   else
4817     {
4818       /* We're looking at the CALL_EXPR, we need the type of the function.  */
4819       type = CALL_EXPR_FN (exp);                /* pointer expression */
4820       type = TREE_TYPE (type);                  /* pointer type */
4821       type = TREE_TYPE (type);                  /* function type */
4822       decl_or_type = type;
4823     }
4824
4825   /* Check that the return value locations are the same.  Like
4826      if we are returning floats on the 80387 register stack, we cannot
4827      make a sibcall from a function that doesn't return a float to a
4828      function that does or, conversely, from a function that does return
4829      a float to a function that doesn't; the necessary stack adjustment
4830      would not be executed.  This is also the place we notice
4831      differences in the return value ABI.  Note that it is ok for one
4832      of the functions to have void return type as long as the return
4833      value of the other is passed in a register.  */
4834   a = ix86_function_value (TREE_TYPE (exp), decl_or_type, false);
4835   b = ix86_function_value (TREE_TYPE (DECL_RESULT (cfun->decl)),
4836                            cfun->decl, false);
4837   if (STACK_REG_P (a) || STACK_REG_P (b))
4838     {
4839       if (!rtx_equal_p (a, b))
4840         return false;
4841     }
4842   else if (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (cfun->decl))))
4843     {
4844       /* Disable sibcall if we need to generate vzeroupper after
4845          callee returns.  */
4846       if (TARGET_VZEROUPPER
4847           && cfun->machine->callee_return_avx256_p
4848           && !cfun->machine->caller_return_avx256_p)
4849         return false;
4850     }
4851   else if (!rtx_equal_p (a, b))
4852     return false;
4853
4854   if (TARGET_64BIT)
4855     {
4856       /* The SYSV ABI has more call-clobbered registers;
4857          disallow sibcalls from MS to SYSV.  */
4858       if (cfun->machine->call_abi == MS_ABI
4859           && ix86_function_type_abi (type) == SYSV_ABI)
4860         return false;
4861     }
4862   else
4863     {
4864       /* If this call is indirect, we'll need to be able to use a
4865          call-clobbered register for the address of the target function.
4866          Make sure that all such registers are not used for passing
4867          parameters.  Note that DLLIMPORT functions are indirect.  */
4868       if (!decl
4869           || (TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P (decl)))
4870         {
4871           if (ix86_function_regparm (type, NULL) >= 3)
4872             {
4873               /* ??? Need to count the actual number of registers to be used,
4874                  not the possible number of registers.  Fix later.  */
4875               return false;
4876             }
4877         }
4878     }
4879
4880   /* Otherwise okay.  That also includes certain types of indirect calls.  */
4881   return true;
4882 }
4883
4884 /* Handle "cdecl", "stdcall", "fastcall", "regparm", "thiscall",
4885    and "sseregparm" calling convention attributes;
4886    arguments as in struct attribute_spec.handler.  */
4887
4888 static tree
4889 ix86_handle_cconv_attribute (tree *node, tree name,
4890                                    tree args,
4891                                    int flags ATTRIBUTE_UNUSED,
4892                                    bool *no_add_attrs)
4893 {
4894   if (TREE_CODE (*node) != FUNCTION_TYPE
4895       && TREE_CODE (*node) != METHOD_TYPE
4896       && TREE_CODE (*node) != FIELD_DECL
4897       && TREE_CODE (*node) != TYPE_DECL)
4898     {
4899       warning (OPT_Wattributes, "%qE attribute only applies to functions",
4900                name);
4901       *no_add_attrs = true;
4902       return NULL_TREE;
4903     }
4904
4905   /* Can combine regparm with all attributes but fastcall, and thiscall.  */
4906   if (is_attribute_p ("regparm", name))
4907     {
4908       tree cst;
4909
4910       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4911         {
4912           error ("fastcall and regparm attributes are not compatible");
4913         }
4914
4915       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4916         {
4917           error ("regparam and thiscall attributes are not compatible");
4918         }
4919
4920       cst = TREE_VALUE (args);
4921       if (TREE_CODE (cst) != INTEGER_CST)
4922         {
4923           warning (OPT_Wattributes,
4924                    "%qE attribute requires an integer constant argument",
4925                    name);
4926           *no_add_attrs = true;
4927         }
4928       else if (compare_tree_int (cst, REGPARM_MAX) > 0)
4929         {
4930           warning (OPT_Wattributes, "argument to %qE attribute larger than %d",
4931                    name, REGPARM_MAX);
4932           *no_add_attrs = true;
4933         }
4934
4935       return NULL_TREE;
4936     }
4937
4938   if (TARGET_64BIT)
4939     {
4940       /* Do not warn when emulating the MS ABI.  */
4941       if ((TREE_CODE (*node) != FUNCTION_TYPE
4942            && TREE_CODE (*node) != METHOD_TYPE)
4943           || ix86_function_type_abi (*node) != MS_ABI)
4944         warning (OPT_Wattributes, "%qE attribute ignored",
4945                  name);
4946       *no_add_attrs = true;
4947       return NULL_TREE;
4948     }
4949
4950   /* Can combine fastcall with stdcall (redundant) and sseregparm.  */
4951   if (is_attribute_p ("fastcall", name))
4952     {
4953       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4954         {
4955           error ("fastcall and cdecl attributes are not compatible");
4956         }
4957       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4958         {
4959           error ("fastcall and stdcall attributes are not compatible");
4960         }
4961       if (lookup_attribute ("regparm", TYPE_ATTRIBUTES (*node)))
4962         {
4963           error ("fastcall and regparm attributes are not compatible");
4964         }
4965       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4966         {
4967           error ("fastcall and thiscall attributes are not compatible");
4968         }
4969     }
4970
4971   /* Can combine stdcall with fastcall (redundant), regparm and
4972      sseregparm.  */
4973   else if (is_attribute_p ("stdcall", name))
4974     {
4975       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
4976         {
4977           error ("stdcall and cdecl attributes are not compatible");
4978         }
4979       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4980         {
4981           error ("stdcall and fastcall attributes are not compatible");
4982         }
4983       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
4984         {
4985           error ("stdcall and thiscall attributes are not compatible");
4986         }
4987     }
4988
4989   /* Can combine cdecl with regparm and sseregparm.  */
4990   else if (is_attribute_p ("cdecl", name))
4991     {
4992       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
4993         {
4994           error ("stdcall and cdecl attributes are not compatible");
4995         }
4996       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
4997         {
4998           error ("fastcall and cdecl attributes are not compatible");
4999         }
5000       if (lookup_attribute ("thiscall", TYPE_ATTRIBUTES (*node)))
5001         {
5002           error ("cdecl and thiscall attributes are not compatible");
5003         }
5004     }
5005   else if (is_attribute_p ("thiscall", name))
5006     {
5007       if (TREE_CODE (*node) != METHOD_TYPE && pedantic)
5008         warning (OPT_Wattributes, "%qE attribute is used for none class-method",
5009                  name);
5010       if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (*node)))
5011         {
5012           error ("stdcall and thiscall attributes are not compatible");
5013         }
5014       if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (*node)))
5015         {
5016           error ("fastcall and thiscall attributes are not compatible");
5017         }
5018       if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (*node)))
5019         {
5020           error ("cdecl and thiscall attributes are not compatible");
5021         }
5022     }
5023
5024   /* Can combine sseregparm with all attributes.  */
5025
5026   return NULL_TREE;
5027 }
5028
5029 /* The transactional memory builtins are implicitly regparm or fastcall
5030    depending on the ABI.  Override the generic do-nothing attribute that
5031    these builtins were declared with, and replace it with one of the two
5032    attributes that we expect elsewhere.  */
5033
5034 static tree
5035 ix86_handle_tm_regparm_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5036                                   tree args ATTRIBUTE_UNUSED,
5037                                   int flags ATTRIBUTE_UNUSED,
5038                                   bool *no_add_attrs)
5039 {
5040   tree alt;
5041
5042   /* In no case do we want to add the placeholder attribute.  */
5043   *no_add_attrs = true;
5044
5045   /* The 64-bit ABI is unchanged for transactional memory.  */
5046   if (TARGET_64BIT)
5047     return NULL_TREE;
5048
5049   /* ??? Is there a better way to validate 32-bit windows?  We have
5050      cfun->machine->call_abi, but that seems to be set only for 64-bit.  */
5051   if (CHECK_STACK_LIMIT > 0)
5052     alt = tree_cons (get_identifier ("fastcall"), NULL, NULL);
5053   else
5054     {
5055       alt = tree_cons (NULL, build_int_cst (NULL, 2), NULL);
5056       alt = tree_cons (get_identifier ("regparm"), alt, NULL);
5057     }
5058   decl_attributes (node, alt, flags);
5059
5060   return NULL_TREE;
5061 }
5062
5063 /* This function determines from TYPE the calling-convention.  */
5064
5065 unsigned int
5066 ix86_get_callcvt (const_tree type)
5067 {
5068   unsigned int ret = 0;
5069   bool is_stdarg;
5070   tree attrs;
5071
5072   if (TARGET_64BIT)
5073     return IX86_CALLCVT_CDECL;
5074
5075   attrs = TYPE_ATTRIBUTES (type);
5076   if (attrs != NULL_TREE)
5077     {
5078       if (lookup_attribute ("cdecl", attrs))
5079         ret |= IX86_CALLCVT_CDECL;
5080       else if (lookup_attribute ("stdcall", attrs))
5081         ret |= IX86_CALLCVT_STDCALL;
5082       else if (lookup_attribute ("fastcall", attrs))
5083         ret |= IX86_CALLCVT_FASTCALL;
5084       else if (lookup_attribute ("thiscall", attrs))
5085         ret |= IX86_CALLCVT_THISCALL;
5086
5087       /* Regparam isn't allowed for thiscall and fastcall.  */
5088       if ((ret & (IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL)) == 0)
5089         {
5090           if (lookup_attribute ("regparm", attrs))
5091             ret |= IX86_CALLCVT_REGPARM;
5092           if (lookup_attribute ("sseregparm", attrs))
5093             ret |= IX86_CALLCVT_SSEREGPARM;
5094         }
5095
5096       if (IX86_BASE_CALLCVT(ret) != 0)
5097         return ret;
5098     }
5099
5100   is_stdarg = stdarg_p (type);
5101   if (TARGET_RTD && !is_stdarg)
5102     return IX86_CALLCVT_STDCALL | ret;
5103
5104   if (ret != 0
5105       || is_stdarg
5106       || TREE_CODE (type) != METHOD_TYPE
5107       || ix86_function_type_abi (type) != MS_ABI)
5108     return IX86_CALLCVT_CDECL | ret;
5109
5110   return IX86_CALLCVT_THISCALL;
5111 }
5112
5113 /* Return 0 if the attributes for two types are incompatible, 1 if they
5114    are compatible, and 2 if they are nearly compatible (which causes a
5115    warning to be generated).  */
5116
5117 static int
5118 ix86_comp_type_attributes (const_tree type1, const_tree type2)
5119 {
5120   unsigned int ccvt1, ccvt2;
5121
5122   if (TREE_CODE (type1) != FUNCTION_TYPE
5123       && TREE_CODE (type1) != METHOD_TYPE)
5124     return 1;
5125
5126   ccvt1 = ix86_get_callcvt (type1);
5127   ccvt2 = ix86_get_callcvt (type2);
5128   if (ccvt1 != ccvt2)
5129     return 0;
5130   if (ix86_function_regparm (type1, NULL)
5131       != ix86_function_regparm (type2, NULL))
5132     return 0;
5133
5134   return 1;
5135 }
5136 \f
5137 /* Return the regparm value for a function with the indicated TYPE and DECL.
5138    DECL may be NULL when calling function indirectly
5139    or considering a libcall.  */
5140
5141 static int
5142 ix86_function_regparm (const_tree type, const_tree decl)
5143 {
5144   tree attr;
5145   int regparm;
5146   unsigned int ccvt;
5147
5148   if (TARGET_64BIT)
5149     return (ix86_function_type_abi (type) == SYSV_ABI
5150             ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX);
5151   ccvt = ix86_get_callcvt (type);
5152   regparm = ix86_regparm;
5153
5154   if ((ccvt & IX86_CALLCVT_REGPARM) != 0)
5155     {
5156       attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
5157       if (attr)
5158         {
5159           regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
5160           return regparm;
5161         }
5162     }
5163   else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5164     return 2;
5165   else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5166     return 1;
5167
5168   /* Use register calling convention for local functions when possible.  */
5169   if (decl
5170       && TREE_CODE (decl) == FUNCTION_DECL
5171       && optimize
5172       && !(profile_flag && !flag_fentry))
5173     {
5174       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5175       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE (decl));
5176       if (i && i->local && i->can_change_signature)
5177         {
5178           int local_regparm, globals = 0, regno;
5179
5180           /* Make sure no regparm register is taken by a
5181              fixed register variable.  */
5182           for (local_regparm = 0; local_regparm < REGPARM_MAX; local_regparm++)
5183             if (fixed_regs[local_regparm])
5184               break;
5185
5186           /* We don't want to use regparm(3) for nested functions as
5187              these use a static chain pointer in the third argument.  */
5188           if (local_regparm == 3 && DECL_STATIC_CHAIN (decl))
5189             local_regparm = 2;
5190
5191           /* In 32-bit mode save a register for the split stack.  */
5192           if (!TARGET_64BIT && local_regparm == 3 && flag_split_stack)
5193             local_regparm = 2;
5194
5195           /* Each fixed register usage increases register pressure,
5196              so less registers should be used for argument passing.
5197              This functionality can be overriden by an explicit
5198              regparm value.  */
5199           for (regno = 0; regno <= DI_REG; regno++)
5200             if (fixed_regs[regno])
5201               globals++;
5202
5203           local_regparm
5204             = globals < local_regparm ? local_regparm - globals : 0;
5205
5206           if (local_regparm > regparm)
5207             regparm = local_regparm;
5208         }
5209     }
5210
5211   return regparm;
5212 }
5213
5214 /* Return 1 or 2, if we can pass up to SSE_REGPARM_MAX SFmode (1) and
5215    DFmode (2) arguments in SSE registers for a function with the
5216    indicated TYPE and DECL.  DECL may be NULL when calling function
5217    indirectly or considering a libcall.  Otherwise return 0.  */
5218
5219 static int
5220 ix86_function_sseregparm (const_tree type, const_tree decl, bool warn)
5221 {
5222   gcc_assert (!TARGET_64BIT);
5223
5224   /* Use SSE registers to pass SFmode and DFmode arguments if requested
5225      by the sseregparm attribute.  */
5226   if (TARGET_SSEREGPARM
5227       || (type && lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type))))
5228     {
5229       if (!TARGET_SSE)
5230         {
5231           if (warn)
5232             {
5233               if (decl)
5234                 error ("calling %qD with attribute sseregparm without "
5235                        "SSE/SSE2 enabled", decl);
5236               else
5237                 error ("calling %qT with attribute sseregparm without "
5238                        "SSE/SSE2 enabled", type);
5239             }
5240           return 0;
5241         }
5242
5243       return 2;
5244     }
5245
5246   /* For local functions, pass up to SSE_REGPARM_MAX SFmode
5247      (and DFmode for SSE2) arguments in SSE registers.  */
5248   if (decl && TARGET_SSE_MATH && optimize
5249       && !(profile_flag && !flag_fentry))
5250     {
5251       /* FIXME: remove this CONST_CAST when cgraph.[ch] is constified.  */
5252       struct cgraph_local_info *i = cgraph_local_info (CONST_CAST_TREE(decl));
5253       if (i && i->local && i->can_change_signature)
5254         return TARGET_SSE2 ? 2 : 1;
5255     }
5256
5257   return 0;
5258 }
5259
5260 /* Return true if EAX is live at the start of the function.  Used by
5261    ix86_expand_prologue to determine if we need special help before
5262    calling allocate_stack_worker.  */
5263
5264 static bool
5265 ix86_eax_live_at_start_p (void)
5266 {
5267   /* Cheat.  Don't bother working forward from ix86_function_regparm
5268      to the function type to whether an actual argument is located in
5269      eax.  Instead just look at cfg info, which is still close enough
5270      to correct at this point.  This gives false positives for broken
5271      functions that might use uninitialized data that happens to be
5272      allocated in eax, but who cares?  */
5273   return REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), 0);
5274 }
5275
5276 static bool
5277 ix86_keep_aggregate_return_pointer (tree fntype)
5278 {
5279   tree attr;
5280
5281   if (!TARGET_64BIT)
5282     {
5283       attr = lookup_attribute ("callee_pop_aggregate_return",
5284                                TYPE_ATTRIBUTES (fntype));
5285       if (attr)
5286         return (TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr))) == 0);
5287
5288       /* For 32-bit MS-ABI the default is to keep aggregate
5289          return pointer.  */
5290       if (ix86_function_type_abi (fntype) == MS_ABI)
5291         return true;
5292     }
5293   return KEEP_AGGREGATE_RETURN_POINTER != 0;
5294 }
5295
5296 /* Value is the number of bytes of arguments automatically
5297    popped when returning from a subroutine call.
5298    FUNDECL is the declaration node of the function (as a tree),
5299    FUNTYPE is the data type of the function (as a tree),
5300    or for a library call it is an identifier node for the subroutine name.
5301    SIZE is the number of bytes of arguments passed on the stack.
5302
5303    On the 80386, the RTD insn may be used to pop them if the number
5304      of args is fixed, but if the number is variable then the caller
5305      must pop them all.  RTD can't be used for library calls now
5306      because the library is compiled with the Unix compiler.
5307    Use of RTD is a selectable option, since it is incompatible with
5308    standard Unix calling sequences.  If the option is not selected,
5309    the caller must always pop the args.
5310
5311    The attribute stdcall is equivalent to RTD on a per module basis.  */
5312
5313 static int
5314 ix86_return_pops_args (tree fundecl, tree funtype, int size)
5315 {
5316   unsigned int ccvt;
5317
5318   /* None of the 64-bit ABIs pop arguments.  */
5319   if (TARGET_64BIT)
5320     return 0;
5321
5322   ccvt = ix86_get_callcvt (funtype);
5323
5324   if ((ccvt & (IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL
5325                | IX86_CALLCVT_THISCALL)) != 0
5326       && ! stdarg_p (funtype))
5327     return size;
5328
5329   /* Lose any fake structure return argument if it is passed on the stack.  */
5330   if (aggregate_value_p (TREE_TYPE (funtype), fundecl)
5331       && !ix86_keep_aggregate_return_pointer (funtype))
5332     {
5333       int nregs = ix86_function_regparm (funtype, fundecl);
5334       if (nregs == 0)
5335         return GET_MODE_SIZE (Pmode);
5336     }
5337
5338   return 0;
5339 }
5340 \f
5341 /* Argument support functions.  */
5342
5343 /* Return true when register may be used to pass function parameters.  */
5344 bool
5345 ix86_function_arg_regno_p (int regno)
5346 {
5347   int i;
5348   const int *parm_regs;
5349
5350   if (!TARGET_64BIT)
5351     {
5352       if (TARGET_MACHO)
5353         return (regno < REGPARM_MAX
5354                 || (TARGET_SSE && SSE_REGNO_P (regno) && !fixed_regs[regno]));
5355       else
5356         return (regno < REGPARM_MAX
5357                 || (TARGET_MMX && MMX_REGNO_P (regno)
5358                     && (regno < FIRST_MMX_REG + MMX_REGPARM_MAX))
5359                 || (TARGET_SSE && SSE_REGNO_P (regno)
5360                     && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX)));
5361     }
5362
5363   if (TARGET_MACHO)
5364     {
5365       if (SSE_REGNO_P (regno) && TARGET_SSE)
5366         return true;
5367     }
5368   else
5369     {
5370       if (TARGET_SSE && SSE_REGNO_P (regno)
5371           && (regno < FIRST_SSE_REG + SSE_REGPARM_MAX))
5372         return true;
5373     }
5374
5375   /* TODO: The function should depend on current function ABI but
5376      builtins.c would need updating then. Therefore we use the
5377      default ABI.  */
5378
5379   /* RAX is used as hidden argument to va_arg functions.  */
5380   if (ix86_abi == SYSV_ABI && regno == AX_REG)
5381     return true;
5382
5383   if (ix86_abi == MS_ABI)
5384     parm_regs = x86_64_ms_abi_int_parameter_registers;
5385   else
5386     parm_regs = x86_64_int_parameter_registers;
5387   for (i = 0; i < (ix86_abi == MS_ABI
5388                    ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX); i++)
5389     if (regno == parm_regs[i])
5390       return true;
5391   return false;
5392 }
5393
5394 /* Return if we do not know how to pass TYPE solely in registers.  */
5395
5396 static bool
5397 ix86_must_pass_in_stack (enum machine_mode mode, const_tree type)
5398 {
5399   if (must_pass_in_stack_var_size_or_pad (mode, type))
5400     return true;
5401
5402   /* For 32-bit, we want TImode aggregates to go on the stack.  But watch out!
5403      The layout_type routine is crafty and tries to trick us into passing
5404      currently unsupported vector types on the stack by using TImode.  */
5405   return (!TARGET_64BIT && mode == TImode
5406           && type && TREE_CODE (type) != VECTOR_TYPE);
5407 }
5408
5409 /* It returns the size, in bytes, of the area reserved for arguments passed
5410    in registers for the function represented by fndecl dependent to the used
5411    abi format.  */
5412 int
5413 ix86_reg_parm_stack_space (const_tree fndecl)
5414 {
5415   enum calling_abi call_abi = SYSV_ABI;
5416   if (fndecl != NULL_TREE && TREE_CODE (fndecl) == FUNCTION_DECL)
5417     call_abi = ix86_function_abi (fndecl);
5418   else
5419     call_abi = ix86_function_type_abi (fndecl);
5420   if (TARGET_64BIT && call_abi == MS_ABI)
5421     return 32;
5422   return 0;
5423 }
5424
5425 /* Returns value SYSV_ABI, MS_ABI dependent on fntype, specifying the
5426    call abi used.  */
5427 enum calling_abi
5428 ix86_function_type_abi (const_tree fntype)
5429 {
5430   if (fntype != NULL_TREE && TYPE_ATTRIBUTES (fntype) != NULL_TREE)
5431     {
5432       enum calling_abi abi = ix86_abi;
5433       if (abi == SYSV_ABI)
5434         {
5435           if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (fntype)))
5436             abi = MS_ABI;
5437         }
5438       else if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (fntype)))
5439         abi = SYSV_ABI;
5440       return abi;
5441     }
5442   return ix86_abi;
5443 }
5444
5445 static bool
5446 ix86_function_ms_hook_prologue (const_tree fn)
5447 {
5448   if (fn && lookup_attribute ("ms_hook_prologue", DECL_ATTRIBUTES (fn)))
5449     {
5450       if (decl_function_context (fn) != NULL_TREE)
5451         error_at (DECL_SOURCE_LOCATION (fn),
5452                   "ms_hook_prologue is not compatible with nested function");
5453       else
5454         return true;
5455     }
5456   return false;
5457 }
5458
5459 static enum calling_abi
5460 ix86_function_abi (const_tree fndecl)
5461 {
5462   if (! fndecl)
5463     return ix86_abi;
5464   return ix86_function_type_abi (TREE_TYPE (fndecl));
5465 }
5466
5467 /* Returns value SYSV_ABI, MS_ABI dependent on cfun, specifying the
5468    call abi used.  */
5469 enum calling_abi
5470 ix86_cfun_abi (void)
5471 {
5472   if (! cfun)
5473     return ix86_abi;
5474   return cfun->machine->call_abi;
5475 }
5476
5477 /* Write the extra assembler code needed to declare a function properly.  */
5478
5479 void
5480 ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
5481                                 tree decl)
5482 {
5483   bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
5484
5485   if (is_ms_hook)
5486     {
5487       int i, filler_count = (TARGET_64BIT ? 32 : 16);
5488       unsigned int filler_cc = 0xcccccccc;
5489
5490       for (i = 0; i < filler_count; i += 4)
5491         fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
5492     }
5493
5494 #ifdef SUBTARGET_ASM_UNWIND_INIT
5495   SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
5496 #endif
5497
5498   ASM_OUTPUT_LABEL (asm_out_file, fname);
5499
5500   /* Output magic byte marker, if hot-patch attribute is set.  */
5501   if (is_ms_hook)
5502     {
5503       if (TARGET_64BIT)
5504         {
5505           /* leaq [%rsp + 0], %rsp  */
5506           asm_fprintf (asm_out_file, ASM_BYTE
5507                        "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n");
5508         }
5509       else
5510         {
5511           /* movl.s %edi, %edi
5512              push   %ebp
5513              movl.s %esp, %ebp */
5514           asm_fprintf (asm_out_file, ASM_BYTE
5515                        "0x8b, 0xff, 0x55, 0x8b, 0xec\n");
5516         }
5517     }
5518 }
5519
5520 /* regclass.c  */
5521 extern void init_regs (void);
5522
5523 /* Implementation of call abi switching target hook. Specific to FNDECL
5524    the specific call register sets are set.  See also
5525    ix86_conditional_register_usage for more details.  */
5526 void
5527 ix86_call_abi_override (const_tree fndecl)
5528 {
5529   if (fndecl == NULL_TREE)
5530     cfun->machine->call_abi = ix86_abi;
5531   else
5532     cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
5533 }
5534
5535 /* 64-bit MS and SYSV ABI have different set of call used registers.  Avoid
5536    expensive re-initialization of init_regs each time we switch function context
5537    since this is needed only during RTL expansion.  */
5538 static void
5539 ix86_maybe_switch_abi (void)
5540 {
5541   if (TARGET_64BIT &&
5542       call_used_regs[SI_REG] == (cfun->machine->call_abi == MS_ABI))
5543     reinit_regs ();
5544 }
5545
5546 /* Initialize a variable CUM of type CUMULATIVE_ARGS
5547    for a call to a function whose data type is FNTYPE.
5548    For a library call, FNTYPE is 0.  */
5549
5550 void
5551 init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
5552                       tree fntype,      /* tree ptr for function decl */
5553                       rtx libname,      /* SYMBOL_REF of library name or 0 */
5554                       tree fndecl,
5555                       int caller)
5556 {
5557   struct cgraph_local_info *i;
5558   tree fnret_type;
5559
5560   memset (cum, 0, sizeof (*cum));
5561
5562   /* Initialize for the current callee.  */
5563   if (caller)
5564     {
5565       cfun->machine->callee_pass_avx256_p = false;
5566       cfun->machine->callee_return_avx256_p = false;
5567     }
5568
5569   if (fndecl)
5570     {
5571       i = cgraph_local_info (fndecl);
5572       cum->call_abi = ix86_function_abi (fndecl);
5573       fnret_type = TREE_TYPE (TREE_TYPE (fndecl));
5574     }
5575   else
5576     {
5577       i = NULL;
5578       cum->call_abi = ix86_function_type_abi (fntype);
5579       if (fntype)
5580         fnret_type = TREE_TYPE (fntype);
5581       else
5582         fnret_type = NULL;
5583     }
5584
5585   if (TARGET_VZEROUPPER && fnret_type)
5586     {
5587       rtx fnret_value = ix86_function_value (fnret_type, fntype,
5588                                              false);
5589       if (function_pass_avx256_p (fnret_value))
5590         {
5591           /* The return value of this function uses 256bit AVX modes.  */
5592           if (caller)
5593             cfun->machine->callee_return_avx256_p = true;
5594           else
5595             cfun->machine->caller_return_avx256_p = true;
5596         }
5597     }
5598
5599   cum->caller = caller;
5600
5601   /* Set up the number of registers to use for passing arguments.  */
5602
5603   if (TARGET_64BIT && cum->call_abi == MS_ABI && !ACCUMULATE_OUTGOING_ARGS)
5604     sorry ("ms_abi attribute requires -maccumulate-outgoing-args "
5605            "or subtarget optimization implying it");
5606   cum->nregs = ix86_regparm;
5607   if (TARGET_64BIT)
5608     {
5609       cum->nregs = (cum->call_abi == SYSV_ABI
5610                    ? X86_64_REGPARM_MAX
5611                    : X86_64_MS_REGPARM_MAX);
5612     }
5613   if (TARGET_SSE)
5614     {
5615       cum->sse_nregs = SSE_REGPARM_MAX;
5616       if (TARGET_64BIT)
5617         {
5618           cum->sse_nregs = (cum->call_abi == SYSV_ABI
5619                            ? X86_64_SSE_REGPARM_MAX
5620                            : X86_64_MS_SSE_REGPARM_MAX);
5621         }
5622     }
5623   if (TARGET_MMX)
5624     cum->mmx_nregs = MMX_REGPARM_MAX;
5625   cum->warn_avx = true;
5626   cum->warn_sse = true;
5627   cum->warn_mmx = true;
5628
5629   /* Because type might mismatch in between caller and callee, we need to
5630      use actual type of function for local calls.
5631      FIXME: cgraph_analyze can be told to actually record if function uses
5632      va_start so for local functions maybe_vaarg can be made aggressive
5633      helping K&R code.
5634      FIXME: once typesytem is fixed, we won't need this code anymore.  */
5635   if (i && i->local && i->can_change_signature)
5636     fntype = TREE_TYPE (fndecl);
5637   cum->maybe_vaarg = (fntype
5638                       ? (!prototype_p (fntype) || stdarg_p (fntype))
5639                       : !libname);
5640
5641   if (!TARGET_64BIT)
5642     {
5643       /* If there are variable arguments, then we won't pass anything
5644          in registers in 32-bit mode. */
5645       if (stdarg_p (fntype))
5646         {
5647           cum->nregs = 0;
5648           cum->sse_nregs = 0;
5649           cum->mmx_nregs = 0;
5650           cum->warn_avx = 0;
5651           cum->warn_sse = 0;
5652           cum->warn_mmx = 0;
5653           return;
5654         }
5655
5656       /* Use ecx and edx registers if function has fastcall attribute,
5657          else look for regparm information.  */
5658       if (fntype)
5659         {
5660           unsigned int ccvt = ix86_get_callcvt (fntype);
5661           if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
5662             {
5663               cum->nregs = 1;
5664               cum->fastcall = 1; /* Same first register as in fastcall.  */
5665             }
5666           else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
5667             {
5668               cum->nregs = 2;
5669               cum->fastcall = 1;
5670             }
5671           else
5672             cum->nregs = ix86_function_regparm (fntype, fndecl);
5673         }
5674
5675       /* Set up the number of SSE registers used for passing SFmode
5676          and DFmode arguments.  Warn for mismatching ABI.  */
5677       cum->float_in_sse = ix86_function_sseregparm (fntype, fndecl, true);
5678     }
5679 }
5680
5681 /* Return the "natural" mode for TYPE.  In most cases, this is just TYPE_MODE.
5682    But in the case of vector types, it is some vector mode.
5683
5684    When we have only some of our vector isa extensions enabled, then there
5685    are some modes for which vector_mode_supported_p is false.  For these
5686    modes, the generic vector support in gcc will choose some non-vector mode
5687    in order to implement the type.  By computing the natural mode, we'll
5688    select the proper ABI location for the operand and not depend on whatever
5689    the middle-end decides to do with these vector types.
5690
5691    The midde-end can't deal with the vector types > 16 bytes.  In this
5692    case, we return the original mode and warn ABI change if CUM isn't
5693    NULL.  */
5694
5695 static enum machine_mode
5696 type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum)
5697 {
5698   enum machine_mode mode = TYPE_MODE (type);
5699
5700   if (TREE_CODE (type) == VECTOR_TYPE && !VECTOR_MODE_P (mode))
5701     {
5702       HOST_WIDE_INT size = int_size_in_bytes (type);
5703       if ((size == 8 || size == 16 || size == 32)
5704           /* ??? Generic code allows us to create width 1 vectors.  Ignore.  */
5705           && TYPE_VECTOR_SUBPARTS (type) > 1)
5706         {
5707           enum machine_mode innermode = TYPE_MODE (TREE_TYPE (type));
5708
5709           if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5710             mode = MIN_MODE_VECTOR_FLOAT;
5711           else
5712             mode = MIN_MODE_VECTOR_INT;
5713
5714           /* Get the mode which has this inner mode and number of units.  */
5715           for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
5716             if (GET_MODE_NUNITS (mode) == TYPE_VECTOR_SUBPARTS (type)
5717                 && GET_MODE_INNER (mode) == innermode)
5718               {
5719                 if (size == 32 && !TARGET_AVX)
5720                   {
5721                     static bool warnedavx;
5722
5723                     if (cum
5724                         && !warnedavx
5725                         && cum->warn_avx)
5726                       {
5727                         warnedavx = true;
5728                         warning (0, "AVX vector argument without AVX "
5729                                  "enabled changes the ABI");
5730                       }
5731                     return TYPE_MODE (type);
5732                   }
5733                 else
5734                   return mode;
5735               }
5736
5737           gcc_unreachable ();
5738         }
5739     }
5740
5741   return mode;
5742 }
5743
5744 /* We want to pass a value in REGNO whose "natural" mode is MODE.  However,
5745    this may not agree with the mode that the type system has chosen for the
5746    register, which is ORIG_MODE.  If ORIG_MODE is not BLKmode, then we can
5747    go ahead and use it.  Otherwise we have to build a PARALLEL instead.  */
5748
5749 static rtx
5750 gen_reg_or_parallel (enum machine_mode mode, enum machine_mode orig_mode,
5751                      unsigned int regno)
5752 {
5753   rtx tmp;
5754
5755   if (orig_mode != BLKmode)
5756     tmp = gen_rtx_REG (orig_mode, regno);
5757   else
5758     {
5759       tmp = gen_rtx_REG (mode, regno);
5760       tmp = gen_rtx_EXPR_LIST (VOIDmode, tmp, const0_rtx);
5761       tmp = gen_rtx_PARALLEL (orig_mode, gen_rtvec (1, tmp));
5762     }
5763
5764   return tmp;
5765 }
5766
5767 /* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
5768    of this code is to classify each 8bytes of incoming argument by the register
5769    class and assign registers accordingly.  */
5770
5771 /* Return the union class of CLASS1 and CLASS2.
5772    See the x86-64 PS ABI for details.  */
5773
5774 static enum x86_64_reg_class
5775 merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
5776 {
5777   /* Rule #1: If both classes are equal, this is the resulting class.  */
5778   if (class1 == class2)
5779     return class1;
5780
5781   /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
5782      the other class.  */
5783   if (class1 == X86_64_NO_CLASS)
5784     return class2;
5785   if (class2 == X86_64_NO_CLASS)
5786     return class1;
5787
5788   /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
5789   if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
5790     return X86_64_MEMORY_CLASS;
5791
5792   /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
5793   if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
5794       || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
5795     return X86_64_INTEGERSI_CLASS;
5796   if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
5797       || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
5798     return X86_64_INTEGER_CLASS;
5799
5800   /* Rule #5: If one of the classes is X87, X87UP, or COMPLEX_X87 class,
5801      MEMORY is used.  */
5802   if (class1 == X86_64_X87_CLASS
5803       || class1 == X86_64_X87UP_CLASS
5804       || class1 == X86_64_COMPLEX_X87_CLASS
5805       || class2 == X86_64_X87_CLASS
5806       || class2 == X86_64_X87UP_CLASS
5807       || class2 == X86_64_COMPLEX_X87_CLASS)
5808     return X86_64_MEMORY_CLASS;
5809
5810   /* Rule #6: Otherwise class SSE is used.  */
5811   return X86_64_SSE_CLASS;
5812 }
5813
5814 /* Classify the argument of type TYPE and mode MODE.
5815    CLASSES will be filled by the register class used to pass each word
5816    of the operand.  The number of words is returned.  In case the parameter
5817    should be passed in memory, 0 is returned. As a special case for zero
5818    sized containers, classes[0] will be NO_CLASS and 1 is returned.
5819
5820    BIT_OFFSET is used internally for handling records and specifies offset
5821    of the offset in bits modulo 256 to avoid overflow cases.
5822
5823    See the x86-64 PS ABI for details.
5824 */
5825
5826 static int
5827 classify_argument (enum machine_mode mode, const_tree type,
5828                    enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
5829 {
5830   HOST_WIDE_INT bytes =
5831     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
5832   int words = (bytes + (bit_offset % 64) / 8 + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5833
5834   /* Variable sized entities are always passed/returned in memory.  */
5835   if (bytes < 0)
5836     return 0;
5837
5838   if (mode != VOIDmode
5839       && targetm.calls.must_pass_in_stack (mode, type))
5840     return 0;
5841
5842   if (type && AGGREGATE_TYPE_P (type))
5843     {
5844       int i;
5845       tree field;
5846       enum x86_64_reg_class subclasses[MAX_CLASSES];
5847
5848       /* On x86-64 we pass structures larger than 32 bytes on the stack.  */
5849       if (bytes > 32)
5850         return 0;
5851
5852       for (i = 0; i < words; i++)
5853         classes[i] = X86_64_NO_CLASS;
5854
5855       /* Zero sized arrays or structures are NO_CLASS.  We return 0 to
5856          signalize memory class, so handle it as special case.  */
5857       if (!words)
5858         {
5859           classes[0] = X86_64_NO_CLASS;
5860           return 1;
5861         }
5862
5863       /* Classify each field of record and merge classes.  */
5864       switch (TREE_CODE (type))
5865         {
5866         case RECORD_TYPE:
5867           /* And now merge the fields of structure.  */
5868           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5869             {
5870               if (TREE_CODE (field) == FIELD_DECL)
5871                 {
5872                   int num;
5873
5874                   if (TREE_TYPE (field) == error_mark_node)
5875                     continue;
5876
5877                   /* Bitfields are always classified as integer.  Handle them
5878                      early, since later code would consider them to be
5879                      misaligned integers.  */
5880                   if (DECL_BIT_FIELD (field))
5881                     {
5882                       for (i = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5883                            i < ((int_bit_position (field) + (bit_offset % 64))
5884                                 + tree_low_cst (DECL_SIZE (field), 0)
5885                                 + 63) / 8 / 8; i++)
5886                         classes[i] =
5887                           merge_classes (X86_64_INTEGER_CLASS,
5888                                          classes[i]);
5889                     }
5890                   else
5891                     {
5892                       int pos;
5893
5894                       type = TREE_TYPE (field);
5895
5896                       /* Flexible array member is ignored.  */
5897                       if (TYPE_MODE (type) == BLKmode
5898                           && TREE_CODE (type) == ARRAY_TYPE
5899                           && TYPE_SIZE (type) == NULL_TREE
5900                           && TYPE_DOMAIN (type) != NULL_TREE
5901                           && (TYPE_MAX_VALUE (TYPE_DOMAIN (type))
5902                               == NULL_TREE))
5903                         {
5904                           static bool warned;
5905
5906                           if (!warned && warn_psabi)
5907                             {
5908                               warned = true;
5909                               inform (input_location,
5910                                       "the ABI of passing struct with"
5911                                       " a flexible array member has"
5912                                       " changed in GCC 4.4");
5913                             }
5914                           continue;
5915                         }
5916                       num = classify_argument (TYPE_MODE (type), type,
5917                                                subclasses,
5918                                                (int_bit_position (field)
5919                                                 + bit_offset) % 256);
5920                       if (!num)
5921                         return 0;
5922                       pos = (int_bit_position (field) + (bit_offset % 64)) / 8 / 8;
5923                       for (i = 0; i < num && (i + pos) < words; i++)
5924                         classes[i + pos] =
5925                           merge_classes (subclasses[i], classes[i + pos]);
5926                     }
5927                 }
5928             }
5929           break;
5930
5931         case ARRAY_TYPE:
5932           /* Arrays are handled as small records.  */
5933           {
5934             int num;
5935             num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
5936                                      TREE_TYPE (type), subclasses, bit_offset);
5937             if (!num)
5938               return 0;
5939
5940             /* The partial classes are now full classes.  */
5941             if (subclasses[0] == X86_64_SSESF_CLASS && bytes != 4)
5942               subclasses[0] = X86_64_SSE_CLASS;
5943             if (subclasses[0] == X86_64_INTEGERSI_CLASS
5944                 && !((bit_offset % 64) == 0 && bytes == 4))
5945               subclasses[0] = X86_64_INTEGER_CLASS;
5946
5947             for (i = 0; i < words; i++)
5948               classes[i] = subclasses[i % num];
5949
5950             break;
5951           }
5952         case UNION_TYPE:
5953         case QUAL_UNION_TYPE:
5954           /* Unions are similar to RECORD_TYPE but offset is always 0.
5955              */
5956           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5957             {
5958               if (TREE_CODE (field) == FIELD_DECL)
5959                 {
5960                   int num;
5961
5962                   if (TREE_TYPE (field) == error_mark_node)
5963                     continue;
5964
5965                   num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
5966                                            TREE_TYPE (field), subclasses,
5967                                            bit_offset);
5968                   if (!num)
5969                     return 0;
5970                   for (i = 0; i < num; i++)
5971                     classes[i] = merge_classes (subclasses[i], classes[i]);
5972                 }
5973             }
5974           break;
5975
5976         default:
5977           gcc_unreachable ();
5978         }
5979
5980       if (words > 2)
5981         {
5982           /* When size > 16 bytes, if the first one isn't
5983              X86_64_SSE_CLASS or any other ones aren't
5984              X86_64_SSEUP_CLASS, everything should be passed in
5985              memory.  */
5986           if (classes[0] != X86_64_SSE_CLASS)
5987               return 0;
5988
5989           for (i = 1; i < words; i++)
5990             if (classes[i] != X86_64_SSEUP_CLASS)
5991               return 0;
5992         }
5993
5994       /* Final merger cleanup.  */
5995       for (i = 0; i < words; i++)
5996         {
5997           /* If one class is MEMORY, everything should be passed in
5998              memory.  */
5999           if (classes[i] == X86_64_MEMORY_CLASS)
6000             return 0;
6001
6002           /* The X86_64_SSEUP_CLASS should be always preceded by
6003              X86_64_SSE_CLASS or X86_64_SSEUP_CLASS.  */
6004           if (classes[i] == X86_64_SSEUP_CLASS
6005               && classes[i - 1] != X86_64_SSE_CLASS
6006               && classes[i - 1] != X86_64_SSEUP_CLASS)
6007             {
6008               /* The first one should never be X86_64_SSEUP_CLASS.  */
6009               gcc_assert (i != 0);
6010               classes[i] = X86_64_SSE_CLASS;
6011             }
6012
6013           /*  If X86_64_X87UP_CLASS isn't preceded by X86_64_X87_CLASS,
6014                everything should be passed in memory.  */
6015           if (classes[i] == X86_64_X87UP_CLASS
6016               && (classes[i - 1] != X86_64_X87_CLASS))
6017             {
6018               static bool warned;
6019
6020               /* The first one should never be X86_64_X87UP_CLASS.  */
6021               gcc_assert (i != 0);
6022               if (!warned && warn_psabi)
6023                 {
6024                   warned = true;
6025                   inform (input_location,
6026                           "the ABI of passing union with long double"
6027                           " has changed in GCC 4.4");
6028                 }
6029               return 0;
6030             }
6031         }
6032       return words;
6033     }
6034
6035   /* Compute alignment needed.  We align all types to natural boundaries with
6036      exception of XFmode that is aligned to 64bits.  */
6037   if (mode != VOIDmode && mode != BLKmode)
6038     {
6039       int mode_alignment = GET_MODE_BITSIZE (mode);
6040
6041       if (mode == XFmode)
6042         mode_alignment = 128;
6043       else if (mode == XCmode)
6044         mode_alignment = 256;
6045       if (COMPLEX_MODE_P (mode))
6046         mode_alignment /= 2;
6047       /* Misaligned fields are always returned in memory.  */
6048       if (bit_offset % mode_alignment)
6049         return 0;
6050     }
6051
6052   /* for V1xx modes, just use the base mode */
6053   if (VECTOR_MODE_P (mode) && mode != V1DImode && mode != V1TImode
6054       && GET_MODE_SIZE (GET_MODE_INNER (mode)) == bytes)
6055     mode = GET_MODE_INNER (mode);
6056
6057   /* Classification of atomic types.  */
6058   switch (mode)
6059     {
6060     case SDmode:
6061     case DDmode:
6062       classes[0] = X86_64_SSE_CLASS;
6063       return 1;
6064     case TDmode:
6065       classes[0] = X86_64_SSE_CLASS;
6066       classes[1] = X86_64_SSEUP_CLASS;
6067       return 2;
6068     case DImode:
6069     case SImode:
6070     case HImode:
6071     case QImode:
6072     case CSImode:
6073     case CHImode:
6074     case CQImode:
6075       {
6076         int size = (bit_offset % 64)+ (int) GET_MODE_BITSIZE (mode);
6077
6078         if (size <= 32)
6079           {
6080             classes[0] = X86_64_INTEGERSI_CLASS;
6081             return 1;
6082           }
6083         else if (size <= 64)
6084           {
6085             classes[0] = X86_64_INTEGER_CLASS;
6086             return 1;
6087           }
6088         else if (size <= 64+32)
6089           {
6090             classes[0] = X86_64_INTEGER_CLASS;
6091             classes[1] = X86_64_INTEGERSI_CLASS;
6092             return 2;
6093           }
6094         else if (size <= 64+64)
6095           {
6096             classes[0] = classes[1] = X86_64_INTEGER_CLASS;
6097             return 2;
6098           }
6099         else
6100           gcc_unreachable ();
6101       }
6102     case CDImode:
6103     case TImode:
6104       classes[0] = classes[1] = X86_64_INTEGER_CLASS;
6105       return 2;
6106     case COImode:
6107     case OImode:
6108       /* OImode shouldn't be used directly.  */
6109       gcc_unreachable ();
6110     case CTImode:
6111       return 0;
6112     case SFmode:
6113       if (!(bit_offset % 64))
6114         classes[0] = X86_64_SSESF_CLASS;
6115       else
6116         classes[0] = X86_64_SSE_CLASS;
6117       return 1;
6118     case DFmode:
6119       classes[0] = X86_64_SSEDF_CLASS;
6120       return 1;
6121     case XFmode:
6122       classes[0] = X86_64_X87_CLASS;
6123       classes[1] = X86_64_X87UP_CLASS;
6124       return 2;
6125     case TFmode:
6126       classes[0] = X86_64_SSE_CLASS;
6127       classes[1] = X86_64_SSEUP_CLASS;
6128       return 2;
6129     case SCmode:
6130       classes[0] = X86_64_SSE_CLASS;
6131       if (!(bit_offset % 64))
6132         return 1;
6133       else
6134         {
6135           static bool warned;
6136
6137           if (!warned && warn_psabi)
6138             {
6139               warned = true;
6140               inform (input_location,
6141                       "the ABI of passing structure with complex float"
6142                       " member has changed in GCC 4.4");
6143             }
6144           classes[1] = X86_64_SSESF_CLASS;
6145           return 2;
6146         }
6147     case DCmode:
6148       classes[0] = X86_64_SSEDF_CLASS;
6149       classes[1] = X86_64_SSEDF_CLASS;
6150       return 2;
6151     case XCmode:
6152       classes[0] = X86_64_COMPLEX_X87_CLASS;
6153       return 1;
6154     case TCmode:
6155       /* This modes is larger than 16 bytes.  */
6156       return 0;
6157     case V8SFmode:
6158     case V8SImode:
6159     case V32QImode:
6160     case V16HImode:
6161     case V4DFmode:
6162     case V4DImode:
6163       classes[0] = X86_64_SSE_CLASS;
6164       classes[1] = X86_64_SSEUP_CLASS;
6165       classes[2] = X86_64_SSEUP_CLASS;
6166       classes[3] = X86_64_SSEUP_CLASS;
6167       return 4;
6168     case V4SFmode:
6169     case V4SImode:
6170     case V16QImode:
6171     case V8HImode:
6172     case V2DFmode:
6173     case V2DImode:
6174       classes[0] = X86_64_SSE_CLASS;
6175       classes[1] = X86_64_SSEUP_CLASS;
6176       return 2;
6177     case V1TImode:
6178     case V1DImode:
6179     case V2SFmode:
6180     case V2SImode:
6181     case V4HImode:
6182     case V8QImode:
6183       classes[0] = X86_64_SSE_CLASS;
6184       return 1;
6185     case BLKmode:
6186     case VOIDmode:
6187       return 0;
6188     default:
6189       gcc_assert (VECTOR_MODE_P (mode));
6190
6191       if (bytes > 16)
6192         return 0;
6193
6194       gcc_assert (GET_MODE_CLASS (GET_MODE_INNER (mode)) == MODE_INT);
6195
6196       if (bit_offset + GET_MODE_BITSIZE (mode) <= 32)
6197         classes[0] = X86_64_INTEGERSI_CLASS;
6198       else
6199         classes[0] = X86_64_INTEGER_CLASS;
6200       classes[1] = X86_64_INTEGER_CLASS;
6201       return 1 + (bytes > 8);
6202     }
6203 }
6204
6205 /* Examine the argument and return set number of register required in each
6206    class.  Return 0 iff parameter should be passed in memory.  */
6207 static int
6208 examine_argument (enum machine_mode mode, const_tree type, int in_return,
6209                   int *int_nregs, int *sse_nregs)
6210 {
6211   enum x86_64_reg_class regclass[MAX_CLASSES];
6212   int n = classify_argument (mode, type, regclass, 0);
6213
6214   *int_nregs = 0;
6215   *sse_nregs = 0;
6216   if (!n)
6217     return 0;
6218   for (n--; n >= 0; n--)
6219     switch (regclass[n])
6220       {
6221       case X86_64_INTEGER_CLASS:
6222       case X86_64_INTEGERSI_CLASS:
6223         (*int_nregs)++;
6224         break;
6225       case X86_64_SSE_CLASS:
6226       case X86_64_SSESF_CLASS:
6227       case X86_64_SSEDF_CLASS:
6228         (*sse_nregs)++;
6229         break;
6230       case X86_64_NO_CLASS:
6231       case X86_64_SSEUP_CLASS:
6232         break;
6233       case X86_64_X87_CLASS:
6234       case X86_64_X87UP_CLASS:
6235         if (!in_return)
6236           return 0;
6237         break;
6238       case X86_64_COMPLEX_X87_CLASS:
6239         return in_return ? 2 : 0;
6240       case X86_64_MEMORY_CLASS:
6241         gcc_unreachable ();
6242       }
6243   return 1;
6244 }
6245
6246 /* Construct container for the argument used by GCC interface.  See
6247    FUNCTION_ARG for the detailed description.  */
6248
6249 static rtx
6250 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
6251                      const_tree type, int in_return, int nintregs, int nsseregs,
6252                      const int *intreg, int sse_regno)
6253 {
6254   /* The following variables hold the static issued_error state.  */
6255   static bool issued_sse_arg_error;
6256   static bool issued_sse_ret_error;
6257   static bool issued_x87_ret_error;
6258
6259   enum machine_mode tmpmode;
6260   int bytes =
6261     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
6262   enum x86_64_reg_class regclass[MAX_CLASSES];
6263   int n;
6264   int i;
6265   int nexps = 0;
6266   int needed_sseregs, needed_intregs;
6267   rtx exp[MAX_CLASSES];
6268   rtx ret;
6269
6270   n = classify_argument (mode, type, regclass, 0);
6271   if (!n)
6272     return NULL;
6273   if (!examine_argument (mode, type, in_return, &needed_intregs,
6274                          &needed_sseregs))
6275     return NULL;
6276   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
6277     return NULL;
6278
6279   /* We allowed the user to turn off SSE for kernel mode.  Don't crash if
6280      some less clueful developer tries to use floating-point anyway.  */
6281   if (needed_sseregs && !TARGET_SSE)
6282     {
6283       if (in_return)
6284         {
6285           if (!issued_sse_ret_error)
6286             {
6287               error ("SSE register return with SSE disabled");
6288               issued_sse_ret_error = true;
6289             }
6290         }
6291       else if (!issued_sse_arg_error)
6292         {
6293           error ("SSE register argument with SSE disabled");
6294           issued_sse_arg_error = true;
6295         }
6296       return NULL;
6297     }
6298
6299   /* Likewise, error if the ABI requires us to return values in the
6300      x87 registers and the user specified -mno-80387.  */
6301   if (!TARGET_80387 && in_return)
6302     for (i = 0; i < n; i++)
6303       if (regclass[i] == X86_64_X87_CLASS
6304           || regclass[i] == X86_64_X87UP_CLASS
6305           || regclass[i] == X86_64_COMPLEX_X87_CLASS)
6306         {
6307           if (!issued_x87_ret_error)
6308             {
6309               error ("x87 register return with x87 disabled");
6310               issued_x87_ret_error = true;
6311             }
6312           return NULL;
6313         }
6314
6315   /* First construct simple cases.  Avoid SCmode, since we want to use
6316      single register to pass this type.  */
6317   if (n == 1 && mode != SCmode)
6318     switch (regclass[0])
6319       {
6320       case X86_64_INTEGER_CLASS:
6321       case X86_64_INTEGERSI_CLASS:
6322         return gen_rtx_REG (mode, intreg[0]);
6323       case X86_64_SSE_CLASS:
6324       case X86_64_SSESF_CLASS:
6325       case X86_64_SSEDF_CLASS:
6326         if (mode != BLKmode)
6327           return gen_reg_or_parallel (mode, orig_mode,
6328                                       SSE_REGNO (sse_regno));
6329         break;
6330       case X86_64_X87_CLASS:
6331       case X86_64_COMPLEX_X87_CLASS:
6332         return gen_rtx_REG (mode, FIRST_STACK_REG);
6333       case X86_64_NO_CLASS:
6334         /* Zero sized array, struct or class.  */
6335         return NULL;
6336       default:
6337         gcc_unreachable ();
6338       }
6339   if (n == 2 && regclass[0] == X86_64_SSE_CLASS
6340       && regclass[1] == X86_64_SSEUP_CLASS && mode != BLKmode)
6341     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6342   if (n == 4
6343       && regclass[0] == X86_64_SSE_CLASS
6344       && regclass[1] == X86_64_SSEUP_CLASS
6345       && regclass[2] == X86_64_SSEUP_CLASS
6346       && regclass[3] == X86_64_SSEUP_CLASS
6347       && mode != BLKmode)
6348     return gen_rtx_REG (mode, SSE_REGNO (sse_regno));
6349
6350   if (n == 2
6351       && regclass[0] == X86_64_X87_CLASS && regclass[1] == X86_64_X87UP_CLASS)
6352     return gen_rtx_REG (XFmode, FIRST_STACK_REG);
6353   if (n == 2 && regclass[0] == X86_64_INTEGER_CLASS
6354       && regclass[1] == X86_64_INTEGER_CLASS
6355       && (mode == CDImode || mode == TImode || mode == TFmode)
6356       && intreg[0] + 1 == intreg[1])
6357     return gen_rtx_REG (mode, intreg[0]);
6358
6359   /* Otherwise figure out the entries of the PARALLEL.  */
6360   for (i = 0; i < n; i++)
6361     {
6362       int pos;
6363
6364       switch (regclass[i])
6365         {
6366           case X86_64_NO_CLASS:
6367             break;
6368           case X86_64_INTEGER_CLASS:
6369           case X86_64_INTEGERSI_CLASS:
6370             /* Merge TImodes on aligned occasions here too.  */
6371             if (i * 8 + 8 > bytes)
6372               tmpmode = mode_for_size ((bytes - i * 8) * BITS_PER_UNIT, MODE_INT, 0);
6373             else if (regclass[i] == X86_64_INTEGERSI_CLASS)
6374               tmpmode = SImode;
6375             else
6376               tmpmode = DImode;
6377             /* We've requested 24 bytes we don't have mode for.  Use DImode.  */
6378             if (tmpmode == BLKmode)
6379               tmpmode = DImode;
6380             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6381                                                gen_rtx_REG (tmpmode, *intreg),
6382                                                GEN_INT (i*8));
6383             intreg++;
6384             break;
6385           case X86_64_SSESF_CLASS:
6386             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6387                                                gen_rtx_REG (SFmode,
6388                                                             SSE_REGNO (sse_regno)),
6389                                                GEN_INT (i*8));
6390             sse_regno++;
6391             break;
6392           case X86_64_SSEDF_CLASS:
6393             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6394                                                gen_rtx_REG (DFmode,
6395                                                             SSE_REGNO (sse_regno)),
6396                                                GEN_INT (i*8));
6397             sse_regno++;
6398             break;
6399           case X86_64_SSE_CLASS:
6400             pos = i;
6401             switch (n)
6402               {
6403               case 1:
6404                 tmpmode = DImode;
6405                 break;
6406               case 2:
6407                 if (i == 0 && regclass[1] == X86_64_SSEUP_CLASS)
6408                   {
6409                     tmpmode = TImode;
6410                     i++;
6411                   }
6412                 else
6413                   tmpmode = DImode;
6414                 break;
6415               case 4:
6416                 gcc_assert (i == 0
6417                             && regclass[1] == X86_64_SSEUP_CLASS
6418                             && regclass[2] == X86_64_SSEUP_CLASS
6419                             && regclass[3] == X86_64_SSEUP_CLASS);
6420                 tmpmode = OImode;
6421                 i += 3;
6422                 break;
6423               default:
6424                 gcc_unreachable ();
6425               }
6426             exp [nexps++] = gen_rtx_EXPR_LIST (VOIDmode,
6427                                                gen_rtx_REG (tmpmode,
6428                                                             SSE_REGNO (sse_regno)),
6429                                                GEN_INT (pos*8));
6430             sse_regno++;
6431             break;
6432           default:
6433             gcc_unreachable ();
6434         }
6435     }
6436
6437   /* Empty aligned struct, union or class.  */
6438   if (nexps == 0)
6439     return NULL;
6440
6441   ret =  gen_rtx_PARALLEL (mode, rtvec_alloc (nexps));
6442   for (i = 0; i < nexps; i++)
6443     XVECEXP (ret, 0, i) = exp [i];
6444   return ret;
6445 }
6446
6447 /* Update the data in CUM to advance over an argument of mode MODE
6448    and data type TYPE.  (TYPE is null for libcalls where that information
6449    may not be available.)  */
6450
6451 static void
6452 function_arg_advance_32 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6453                          const_tree type, HOST_WIDE_INT bytes,
6454                          HOST_WIDE_INT words)
6455 {
6456   switch (mode)
6457     {
6458     default:
6459       break;
6460
6461     case BLKmode:
6462       if (bytes < 0)
6463         break;
6464       /* FALLTHRU */
6465
6466     case DImode:
6467     case SImode:
6468     case HImode:
6469     case QImode:
6470       cum->words += words;
6471       cum->nregs -= words;
6472       cum->regno += words;
6473
6474       if (cum->nregs <= 0)
6475         {
6476           cum->nregs = 0;
6477           cum->regno = 0;
6478         }
6479       break;
6480
6481     case OImode:
6482       /* OImode shouldn't be used directly.  */
6483       gcc_unreachable ();
6484
6485     case DFmode:
6486       if (cum->float_in_sse < 2)
6487         break;
6488     case SFmode:
6489       if (cum->float_in_sse < 1)
6490         break;
6491       /* FALLTHRU */
6492
6493     case V8SFmode:
6494     case V8SImode:
6495     case V32QImode:
6496     case V16HImode:
6497     case V4DFmode:
6498     case V4DImode:
6499     case TImode:
6500     case V16QImode:
6501     case V8HImode:
6502     case V4SImode:
6503     case V2DImode:
6504     case V4SFmode:
6505     case V2DFmode:
6506       if (!type || !AGGREGATE_TYPE_P (type))
6507         {
6508           cum->sse_words += words;
6509           cum->sse_nregs -= 1;
6510           cum->sse_regno += 1;
6511           if (cum->sse_nregs <= 0)
6512             {
6513               cum->sse_nregs = 0;
6514               cum->sse_regno = 0;
6515             }
6516         }
6517       break;
6518
6519     case V8QImode:
6520     case V4HImode:
6521     case V2SImode:
6522     case V2SFmode:
6523     case V1TImode:
6524     case V1DImode:
6525       if (!type || !AGGREGATE_TYPE_P (type))
6526         {
6527           cum->mmx_words += words;
6528           cum->mmx_nregs -= 1;
6529           cum->mmx_regno += 1;
6530           if (cum->mmx_nregs <= 0)
6531             {
6532               cum->mmx_nregs = 0;
6533               cum->mmx_regno = 0;
6534             }
6535         }
6536       break;
6537     }
6538 }
6539
6540 static void
6541 function_arg_advance_64 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6542                          const_tree type, HOST_WIDE_INT words, bool named)
6543 {
6544   int int_nregs, sse_nregs;
6545
6546   /* Unnamed 256bit vector mode parameters are passed on stack.  */
6547   if (!named && VALID_AVX256_REG_MODE (mode))
6548     return;
6549
6550   if (examine_argument (mode, type, 0, &int_nregs, &sse_nregs)
6551       && sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
6552     {
6553       cum->nregs -= int_nregs;
6554       cum->sse_nregs -= sse_nregs;
6555       cum->regno += int_nregs;
6556       cum->sse_regno += sse_nregs;
6557     }
6558   else
6559     {
6560       int align = ix86_function_arg_boundary (mode, type) / BITS_PER_WORD;
6561       cum->words = (cum->words + align - 1) & ~(align - 1);
6562       cum->words += words;
6563     }
6564 }
6565
6566 static void
6567 function_arg_advance_ms_64 (CUMULATIVE_ARGS *cum, HOST_WIDE_INT bytes,
6568                             HOST_WIDE_INT words)
6569 {
6570   /* Otherwise, this should be passed indirect.  */
6571   gcc_assert (bytes == 1 || bytes == 2 || bytes == 4 || bytes == 8);
6572
6573   cum->words += words;
6574   if (cum->nregs > 0)
6575     {
6576       cum->nregs -= 1;
6577       cum->regno += 1;
6578     }
6579 }
6580
6581 /* Update the data in CUM to advance over an argument of mode MODE and
6582    data type TYPE.  (TYPE is null for libcalls where that information
6583    may not be available.)  */
6584
6585 static void
6586 ix86_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6587                            const_tree type, bool named)
6588 {
6589   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6590   HOST_WIDE_INT bytes, words;
6591
6592   if (mode == BLKmode)
6593     bytes = int_size_in_bytes (type);
6594   else
6595     bytes = GET_MODE_SIZE (mode);
6596   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6597
6598   if (type)
6599     mode = type_natural_mode (type, NULL);
6600
6601   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6602     function_arg_advance_ms_64 (cum, bytes, words);
6603   else if (TARGET_64BIT)
6604     function_arg_advance_64 (cum, mode, type, words, named);
6605   else
6606     function_arg_advance_32 (cum, mode, type, bytes, words);
6607 }
6608
6609 /* Define where to put the arguments to a function.
6610    Value is zero to push the argument on the stack,
6611    or a hard register in which to store the argument.
6612
6613    MODE is the argument's machine mode.
6614    TYPE is the data type of the argument (as a tree).
6615     This is null for libcalls where that information may
6616     not be available.
6617    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6618     the preceding args and about the function being called.
6619    NAMED is nonzero if this argument is a named parameter
6620     (otherwise it is an extra parameter matching an ellipsis).  */
6621
6622 static rtx
6623 function_arg_32 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6624                  enum machine_mode orig_mode, const_tree type,
6625                  HOST_WIDE_INT bytes, HOST_WIDE_INT words)
6626 {
6627   static bool warnedsse, warnedmmx;
6628
6629   /* Avoid the AL settings for the Unix64 ABI.  */
6630   if (mode == VOIDmode)
6631     return constm1_rtx;
6632
6633   switch (mode)
6634     {
6635     default:
6636       break;
6637
6638     case BLKmode:
6639       if (bytes < 0)
6640         break;
6641       /* FALLTHRU */
6642     case DImode:
6643     case SImode:
6644     case HImode:
6645     case QImode:
6646       if (words <= cum->nregs)
6647         {
6648           int regno = cum->regno;
6649
6650           /* Fastcall allocates the first two DWORD (SImode) or
6651             smaller arguments to ECX and EDX if it isn't an
6652             aggregate type .  */
6653           if (cum->fastcall)
6654             {
6655               if (mode == BLKmode
6656                   || mode == DImode
6657                   || (type && AGGREGATE_TYPE_P (type)))
6658                 break;
6659
6660               /* ECX not EAX is the first allocated register.  */
6661               if (regno == AX_REG)
6662                 regno = CX_REG;
6663             }
6664           return gen_rtx_REG (mode, regno);
6665         }
6666       break;
6667
6668     case DFmode:
6669       if (cum->float_in_sse < 2)
6670         break;
6671     case SFmode:
6672       if (cum->float_in_sse < 1)
6673         break;
6674       /* FALLTHRU */
6675     case TImode:
6676       /* In 32bit, we pass TImode in xmm registers.  */
6677     case V16QImode:
6678     case V8HImode:
6679     case V4SImode:
6680     case V2DImode:
6681     case V4SFmode:
6682     case V2DFmode:
6683       if (!type || !AGGREGATE_TYPE_P (type))
6684         {
6685           if (!TARGET_SSE && !warnedsse && cum->warn_sse)
6686             {
6687               warnedsse = true;
6688               warning (0, "SSE vector argument without SSE enabled "
6689                        "changes the ABI");
6690             }
6691           if (cum->sse_nregs)
6692             return gen_reg_or_parallel (mode, orig_mode,
6693                                         cum->sse_regno + FIRST_SSE_REG);
6694         }
6695       break;
6696
6697     case OImode:
6698       /* OImode shouldn't be used directly.  */
6699       gcc_unreachable ();
6700
6701     case V8SFmode:
6702     case V8SImode:
6703     case V32QImode:
6704     case V16HImode:
6705     case V4DFmode:
6706     case V4DImode:
6707       if (!type || !AGGREGATE_TYPE_P (type))
6708         {
6709           if (cum->sse_nregs)
6710             return gen_reg_or_parallel (mode, orig_mode,
6711                                         cum->sse_regno + FIRST_SSE_REG);
6712         }
6713       break;
6714
6715     case V8QImode:
6716     case V4HImode:
6717     case V2SImode:
6718     case V2SFmode:
6719     case V1TImode:
6720     case V1DImode:
6721       if (!type || !AGGREGATE_TYPE_P (type))
6722         {
6723           if (!TARGET_MMX && !warnedmmx && cum->warn_mmx)
6724             {
6725               warnedmmx = true;
6726               warning (0, "MMX vector argument without MMX enabled "
6727                        "changes the ABI");
6728             }
6729           if (cum->mmx_nregs)
6730             return gen_reg_or_parallel (mode, orig_mode,
6731                                         cum->mmx_regno + FIRST_MMX_REG);
6732         }
6733       break;
6734     }
6735
6736   return NULL_RTX;
6737 }
6738
6739 static rtx
6740 function_arg_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6741                  enum machine_mode orig_mode, const_tree type, bool named)
6742 {
6743   /* Handle a hidden AL argument containing number of registers
6744      for varargs x86-64 functions.  */
6745   if (mode == VOIDmode)
6746     return GEN_INT (cum->maybe_vaarg
6747                     ? (cum->sse_nregs < 0
6748                        ? X86_64_SSE_REGPARM_MAX
6749                        : cum->sse_regno)
6750                     : -1);
6751
6752   switch (mode)
6753     {
6754     default:
6755       break;
6756
6757     case V8SFmode:
6758     case V8SImode:
6759     case V32QImode:
6760     case V16HImode:
6761     case V4DFmode:
6762     case V4DImode:
6763       /* Unnamed 256bit vector mode parameters are passed on stack.  */
6764       if (!named)
6765         return NULL;
6766       break;
6767     }
6768
6769   return construct_container (mode, orig_mode, type, 0, cum->nregs,
6770                               cum->sse_nregs,
6771                               &x86_64_int_parameter_registers [cum->regno],
6772                               cum->sse_regno);
6773 }
6774
6775 static rtx
6776 function_arg_ms_64 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
6777                     enum machine_mode orig_mode, bool named,
6778                     HOST_WIDE_INT bytes)
6779 {
6780   unsigned int regno;
6781
6782   /* We need to add clobber for MS_ABI->SYSV ABI calls in expand_call.
6783      We use value of -2 to specify that current function call is MSABI.  */
6784   if (mode == VOIDmode)
6785     return GEN_INT (-2);
6786
6787   /* If we've run out of registers, it goes on the stack.  */
6788   if (cum->nregs == 0)
6789     return NULL_RTX;
6790
6791   regno = x86_64_ms_abi_int_parameter_registers[cum->regno];
6792
6793   /* Only floating point modes are passed in anything but integer regs.  */
6794   if (TARGET_SSE && (mode == SFmode || mode == DFmode))
6795     {
6796       if (named)
6797         regno = cum->regno + FIRST_SSE_REG;
6798       else
6799         {
6800           rtx t1, t2;
6801
6802           /* Unnamed floating parameters are passed in both the
6803              SSE and integer registers.  */
6804           t1 = gen_rtx_REG (mode, cum->regno + FIRST_SSE_REG);
6805           t2 = gen_rtx_REG (mode, regno);
6806           t1 = gen_rtx_EXPR_LIST (VOIDmode, t1, const0_rtx);
6807           t2 = gen_rtx_EXPR_LIST (VOIDmode, t2, const0_rtx);
6808           return gen_rtx_PARALLEL (mode, gen_rtvec (2, t1, t2));
6809         }
6810     }
6811   /* Handle aggregated types passed in register.  */
6812   if (orig_mode == BLKmode)
6813     {
6814       if (bytes > 0 && bytes <= 8)
6815         mode = (bytes > 4 ? DImode : SImode);
6816       if (mode == BLKmode)
6817         mode = DImode;
6818     }
6819
6820   return gen_reg_or_parallel (mode, orig_mode, regno);
6821 }
6822
6823 /* Return where to put the arguments to a function.
6824    Return zero to push the argument on the stack, or a hard register in which to store the argument.
6825
6826    MODE is the argument's machine mode.  TYPE is the data type of the
6827    argument.  It is null for libcalls where that information may not be
6828    available.  CUM gives information about the preceding args and about
6829    the function being called.  NAMED is nonzero if this argument is a
6830    named parameter (otherwise it is an extra parameter matching an
6831    ellipsis).  */
6832
6833 static rtx
6834 ix86_function_arg (cumulative_args_t cum_v, enum machine_mode omode,
6835                    const_tree type, bool named)
6836 {
6837   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6838   enum machine_mode mode = omode;
6839   HOST_WIDE_INT bytes, words;
6840   rtx arg;
6841
6842   if (mode == BLKmode)
6843     bytes = int_size_in_bytes (type);
6844   else
6845     bytes = GET_MODE_SIZE (mode);
6846   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6847
6848   /* To simplify the code below, represent vector types with a vector mode
6849      even if MMX/SSE are not active.  */
6850   if (type && TREE_CODE (type) == VECTOR_TYPE)
6851     mode = type_natural_mode (type, cum);
6852
6853   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6854     arg = function_arg_ms_64 (cum, mode, omode, named, bytes);
6855   else if (TARGET_64BIT)
6856     arg = function_arg_64 (cum, mode, omode, type, named);
6857   else
6858     arg = function_arg_32 (cum, mode, omode, type, bytes, words);
6859
6860   if (TARGET_VZEROUPPER && function_pass_avx256_p (arg))
6861     {
6862       /* This argument uses 256bit AVX modes.  */
6863       if (cum->caller)
6864         cfun->machine->callee_pass_avx256_p = true;
6865       else
6866         cfun->machine->caller_pass_avx256_p = true;
6867     }
6868
6869   return arg;
6870 }
6871
6872 /* A C expression that indicates when an argument must be passed by
6873    reference.  If nonzero for an argument, a copy of that argument is
6874    made in memory and a pointer to the argument is passed instead of
6875    the argument itself.  The pointer is passed in whatever way is
6876    appropriate for passing a pointer to that type.  */
6877
6878 static bool
6879 ix86_pass_by_reference (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
6880                         enum machine_mode mode ATTRIBUTE_UNUSED,
6881                         const_tree type, bool named ATTRIBUTE_UNUSED)
6882 {
6883   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6884
6885   /* See Windows x64 Software Convention.  */
6886   if (TARGET_64BIT && (cum ? cum->call_abi : ix86_abi) == MS_ABI)
6887     {
6888       int msize = (int) GET_MODE_SIZE (mode);
6889       if (type)
6890         {
6891           /* Arrays are passed by reference.  */
6892           if (TREE_CODE (type) == ARRAY_TYPE)
6893             return true;
6894
6895           if (AGGREGATE_TYPE_P (type))
6896             {
6897               /* Structs/unions of sizes other than 8, 16, 32, or 64 bits
6898                  are passed by reference.  */
6899               msize = int_size_in_bytes (type);
6900             }
6901         }
6902
6903       /* __m128 is passed by reference.  */
6904       switch (msize) {
6905       case 1: case 2: case 4: case 8:
6906         break;
6907       default:
6908         return true;
6909       }
6910     }
6911   else if (TARGET_64BIT && type && int_size_in_bytes (type) == -1)
6912     return 1;
6913
6914   return 0;
6915 }
6916
6917 /* Return true when TYPE should be 128bit aligned for 32bit argument
6918    passing ABI.  XXX: This function is obsolete and is only used for
6919    checking psABI compatibility with previous versions of GCC.  */
6920
6921 static bool
6922 ix86_compat_aligned_value_p (const_tree type)
6923 {
6924   enum machine_mode mode = TYPE_MODE (type);
6925   if (((TARGET_SSE && SSE_REG_MODE_P (mode))
6926        || mode == TDmode
6927        || mode == TFmode
6928        || mode == TCmode)
6929       && (!TYPE_USER_ALIGN (type) || TYPE_ALIGN (type) > 128))
6930     return true;
6931   if (TYPE_ALIGN (type) < 128)
6932     return false;
6933
6934   if (AGGREGATE_TYPE_P (type))
6935     {
6936       /* Walk the aggregates recursively.  */
6937       switch (TREE_CODE (type))
6938         {
6939         case RECORD_TYPE:
6940         case UNION_TYPE:
6941         case QUAL_UNION_TYPE:
6942           {
6943             tree field;
6944
6945             /* Walk all the structure fields.  */
6946             for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6947               {
6948                 if (TREE_CODE (field) == FIELD_DECL
6949                     && ix86_compat_aligned_value_p (TREE_TYPE (field)))
6950                   return true;
6951               }
6952             break;
6953           }
6954
6955         case ARRAY_TYPE:
6956           /* Just for use if some languages passes arrays by value.  */
6957           if (ix86_compat_aligned_value_p (TREE_TYPE (type)))
6958             return true;
6959           break;
6960
6961         default:
6962           gcc_unreachable ();
6963         }
6964     }
6965   return false;
6966 }
6967
6968 /* Return the alignment boundary for MODE and TYPE with alignment ALIGN.
6969    XXX: This function is obsolete and is only used for checking psABI
6970    compatibility with previous versions of GCC.  */
6971
6972 static unsigned int
6973 ix86_compat_function_arg_boundary (enum machine_mode mode,
6974                                    const_tree type, unsigned int align)
6975 {
6976   /* In 32bit, only _Decimal128 and __float128 are aligned to their
6977      natural boundaries.  */
6978   if (!TARGET_64BIT && mode != TDmode && mode != TFmode)
6979     {
6980       /* i386 ABI defines all arguments to be 4 byte aligned.  We have to
6981          make an exception for SSE modes since these require 128bit
6982          alignment.
6983
6984          The handling here differs from field_alignment.  ICC aligns MMX
6985          arguments to 4 byte boundaries, while structure fields are aligned
6986          to 8 byte boundaries.  */
6987       if (!type)
6988         {
6989           if (!(TARGET_SSE && SSE_REG_MODE_P (mode)))
6990             align = PARM_BOUNDARY;
6991         }
6992       else
6993         {
6994           if (!ix86_compat_aligned_value_p (type))
6995             align = PARM_BOUNDARY;
6996         }
6997     }
6998   if (align > BIGGEST_ALIGNMENT)
6999     align = BIGGEST_ALIGNMENT;
7000   return align;
7001 }
7002
7003 /* Return true when TYPE should be 128bit aligned for 32bit argument
7004    passing ABI.  */
7005
7006 static bool
7007 ix86_contains_aligned_value_p (const_tree type)
7008 {
7009   enum machine_mode mode = TYPE_MODE (type);
7010
7011   if (mode == XFmode || mode == XCmode)
7012     return false;
7013
7014   if (TYPE_ALIGN (type) < 128)
7015     return false;
7016
7017   if (AGGREGATE_TYPE_P (type))
7018     {
7019       /* Walk the aggregates recursively.  */
7020       switch (TREE_CODE (type))
7021         {
7022         case RECORD_TYPE:
7023         case UNION_TYPE:
7024         case QUAL_UNION_TYPE:
7025           {
7026             tree field;
7027
7028             /* Walk all the structure fields.  */
7029             for (field = TYPE_FIELDS (type);
7030                  field;
7031                  field = DECL_CHAIN (field))
7032               {
7033                 if (TREE_CODE (field) == FIELD_DECL
7034                     && ix86_contains_aligned_value_p (TREE_TYPE (field)))
7035                   return true;
7036               }
7037             break;
7038           }
7039
7040         case ARRAY_TYPE:
7041           /* Just for use if some languages passes arrays by value.  */
7042           if (ix86_contains_aligned_value_p (TREE_TYPE (type)))
7043             return true;
7044           break;
7045
7046         default:
7047           gcc_unreachable ();
7048         }
7049     }
7050   else
7051     return TYPE_ALIGN (type) >= 128;
7052
7053   return false;
7054 }
7055
7056 /* Gives the alignment boundary, in bits, of an argument with the
7057    specified mode and type.  */
7058
7059 static unsigned int
7060 ix86_function_arg_boundary (enum machine_mode mode, const_tree type)
7061 {
7062   unsigned int align;
7063   if (type)
7064     {
7065       /* Since the main variant type is used for call, we convert it to
7066          the main variant type.  */
7067       type = TYPE_MAIN_VARIANT (type);
7068       align = TYPE_ALIGN (type);
7069     }
7070   else
7071     align = GET_MODE_ALIGNMENT (mode);
7072   if (align < PARM_BOUNDARY)
7073     align = PARM_BOUNDARY;
7074   else
7075     {
7076       static bool warned;
7077       unsigned int saved_align = align;
7078
7079       if (!TARGET_64BIT)
7080         {
7081           /* i386 ABI defines XFmode arguments to be 4 byte aligned.  */
7082           if (!type)
7083             {
7084               if (mode == XFmode || mode == XCmode)
7085                 align = PARM_BOUNDARY;
7086             }
7087           else if (!ix86_contains_aligned_value_p (type))
7088             align = PARM_BOUNDARY;
7089
7090           if (align < 128)
7091             align = PARM_BOUNDARY;
7092         }
7093
7094       if (warn_psabi
7095           && !warned
7096           && align != ix86_compat_function_arg_boundary (mode, type,
7097                                                          saved_align))
7098         {
7099           warned = true;
7100           inform (input_location,
7101                   "The ABI for passing parameters with %d-byte"
7102                   " alignment has changed in GCC 4.6",
7103                   align / BITS_PER_UNIT);
7104         }
7105     }
7106
7107   return align;
7108 }
7109
7110 /* Return true if N is a possible register number of function value.  */
7111
7112 static bool
7113 ix86_function_value_regno_p (const unsigned int regno)
7114 {
7115   switch (regno)
7116     {
7117     case AX_REG:
7118       return true;
7119
7120     case FIRST_FLOAT_REG:
7121       /* TODO: The function should depend on current function ABI but
7122        builtins.c would need updating then. Therefore we use the
7123        default ABI.  */
7124       if (TARGET_64BIT && ix86_abi == MS_ABI)
7125         return false;
7126       return TARGET_FLOAT_RETURNS_IN_80387;
7127
7128     case FIRST_SSE_REG:
7129       return TARGET_SSE;
7130
7131     case FIRST_MMX_REG:
7132       if (TARGET_MACHO || TARGET_64BIT)
7133         return false;
7134       return TARGET_MMX;
7135     }
7136
7137   return false;
7138 }
7139
7140 /* Define how to find the value returned by a function.
7141    VALTYPE is the data type of the value (as a tree).
7142    If the precise function being called is known, FUNC is its FUNCTION_DECL;
7143    otherwise, FUNC is 0.  */
7144
7145 static rtx
7146 function_value_32 (enum machine_mode orig_mode, enum machine_mode mode,
7147                    const_tree fntype, const_tree fn)
7148 {
7149   unsigned int regno;
7150
7151   /* 8-byte vector modes in %mm0. See ix86_return_in_memory for where
7152      we normally prevent this case when mmx is not available.  However
7153      some ABIs may require the result to be returned like DImode.  */
7154   if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7155     regno = FIRST_MMX_REG;
7156
7157   /* 16-byte vector modes in %xmm0.  See ix86_return_in_memory for where
7158      we prevent this case when sse is not available.  However some ABIs
7159      may require the result to be returned like integer TImode.  */
7160   else if (mode == TImode
7161            || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7162     regno = FIRST_SSE_REG;
7163
7164   /* 32-byte vector modes in %ymm0.   */
7165   else if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 32)
7166     regno = FIRST_SSE_REG;
7167
7168   /* Floating point return values in %st(0) (unless -mno-fp-ret-in-387).  */
7169   else if (X87_FLOAT_MODE_P (mode) && TARGET_FLOAT_RETURNS_IN_80387)
7170     regno = FIRST_FLOAT_REG;
7171   else
7172     /* Most things go in %eax.  */
7173     regno = AX_REG;
7174
7175   /* Override FP return register with %xmm0 for local functions when
7176      SSE math is enabled or for functions with sseregparm attribute.  */
7177   if ((fn || fntype) && (mode == SFmode || mode == DFmode))
7178     {
7179       int sse_level = ix86_function_sseregparm (fntype, fn, false);
7180       if ((sse_level >= 1 && mode == SFmode)
7181           || (sse_level == 2 && mode == DFmode))
7182         regno = FIRST_SSE_REG;
7183     }
7184
7185   /* OImode shouldn't be used directly.  */
7186   gcc_assert (mode != OImode);
7187
7188   return gen_rtx_REG (orig_mode, regno);
7189 }
7190
7191 static rtx
7192 function_value_64 (enum machine_mode orig_mode, enum machine_mode mode,
7193                    const_tree valtype)
7194 {
7195   rtx ret;
7196
7197   /* Handle libcalls, which don't provide a type node.  */
7198   if (valtype == NULL)
7199     {
7200       unsigned int regno;
7201
7202       switch (mode)
7203         {
7204         case SFmode:
7205         case SCmode:
7206         case DFmode:
7207         case DCmode:
7208         case TFmode:
7209         case SDmode:
7210         case DDmode:
7211         case TDmode:
7212           regno = FIRST_SSE_REG;
7213           break;
7214         case XFmode:
7215         case XCmode:
7216           regno = FIRST_FLOAT_REG;
7217           break;
7218         case TCmode:
7219           return NULL;
7220         default:
7221           regno = AX_REG;
7222         }
7223
7224       return gen_rtx_REG (mode, regno);
7225     }
7226   else if (POINTER_TYPE_P (valtype))
7227     {
7228       /* Pointers are always returned in Pmode. */
7229       mode = Pmode;
7230     }
7231
7232   ret = construct_container (mode, orig_mode, valtype, 1,
7233                              X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
7234                              x86_64_int_return_registers, 0);
7235
7236   /* For zero sized structures, construct_container returns NULL, but we
7237      need to keep rest of compiler happy by returning meaningful value.  */
7238   if (!ret)
7239     ret = gen_rtx_REG (orig_mode, AX_REG);
7240
7241   return ret;
7242 }
7243
7244 static rtx
7245 function_value_ms_64 (enum machine_mode orig_mode, enum machine_mode mode)
7246 {
7247   unsigned int regno = AX_REG;
7248
7249   if (TARGET_SSE)
7250     {
7251       switch (GET_MODE_SIZE (mode))
7252         {
7253         case 16:
7254           if((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7255              && !COMPLEX_MODE_P (mode))
7256             regno = FIRST_SSE_REG;
7257           break;
7258         case 8:
7259         case 4:
7260           if (mode == SFmode || mode == DFmode)
7261             regno = FIRST_SSE_REG;
7262           break;
7263         default:
7264           break;
7265         }
7266     }
7267   return gen_rtx_REG (orig_mode, regno);
7268 }
7269
7270 static rtx
7271 ix86_function_value_1 (const_tree valtype, const_tree fntype_or_decl,
7272                        enum machine_mode orig_mode, enum machine_mode mode)
7273 {
7274   const_tree fn, fntype;
7275
7276   fn = NULL_TREE;
7277   if (fntype_or_decl && DECL_P (fntype_or_decl))
7278     fn = fntype_or_decl;
7279   fntype = fn ? TREE_TYPE (fn) : fntype_or_decl;
7280
7281   if (TARGET_64BIT && ix86_function_type_abi (fntype) == MS_ABI)
7282     return function_value_ms_64 (orig_mode, mode);
7283   else if (TARGET_64BIT)
7284     return function_value_64 (orig_mode, mode, valtype);
7285   else
7286     return function_value_32 (orig_mode, mode, fntype, fn);
7287 }
7288
7289 static rtx
7290 ix86_function_value (const_tree valtype, const_tree fntype_or_decl,
7291                      bool outgoing ATTRIBUTE_UNUSED)
7292 {
7293   enum machine_mode mode, orig_mode;
7294
7295   orig_mode = TYPE_MODE (valtype);
7296   mode = type_natural_mode (valtype, NULL);
7297   return ix86_function_value_1 (valtype, fntype_or_decl, orig_mode, mode);
7298 }
7299
7300 /* Pointer function arguments and return values are promoted to Pmode.  */
7301
7302 static enum machine_mode
7303 ix86_promote_function_mode (const_tree type, enum machine_mode mode,
7304                             int *punsignedp, const_tree fntype,
7305                             int for_return)
7306 {
7307   if (type != NULL_TREE && POINTER_TYPE_P (type))
7308     {
7309       *punsignedp = POINTERS_EXTEND_UNSIGNED;
7310       return Pmode;
7311     }
7312   return default_promote_function_mode (type, mode, punsignedp, fntype,
7313                                         for_return);
7314 }
7315
7316 rtx
7317 ix86_libcall_value (enum machine_mode mode)
7318 {
7319   return ix86_function_value_1 (NULL, NULL, mode, mode);
7320 }
7321
7322 /* Return true iff type is returned in memory.  */
7323
7324 static bool ATTRIBUTE_UNUSED
7325 return_in_memory_32 (const_tree type, enum machine_mode mode)
7326 {
7327   HOST_WIDE_INT size;
7328
7329   if (mode == BLKmode)
7330     return true;
7331
7332   size = int_size_in_bytes (type);
7333
7334   if (MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P (type) && size <= 8)
7335     return false;
7336
7337   if (VECTOR_MODE_P (mode) || mode == TImode)
7338     {
7339       /* User-created vectors small enough to fit in EAX.  */
7340       if (size < 8)
7341         return false;
7342
7343       /* MMX/3dNow values are returned in MM0,
7344          except when it doesn't exits or the ABI prescribes otherwise.  */
7345       if (size == 8)
7346         return !TARGET_MMX || TARGET_VECT8_RETURNS;
7347
7348       /* SSE values are returned in XMM0, except when it doesn't exist.  */
7349       if (size == 16)
7350         return !TARGET_SSE;
7351
7352       /* AVX values are returned in YMM0, except when it doesn't exist.  */
7353       if (size == 32)
7354         return !TARGET_AVX;
7355     }
7356
7357   if (mode == XFmode)
7358     return false;
7359
7360   if (size > 12)
7361     return true;
7362
7363   /* OImode shouldn't be used directly.  */
7364   gcc_assert (mode != OImode);
7365
7366   return false;
7367 }
7368
7369 static bool ATTRIBUTE_UNUSED
7370 return_in_memory_64 (const_tree type, enum machine_mode mode)
7371 {
7372   int needed_intregs, needed_sseregs;
7373   return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs);
7374 }
7375
7376 static bool ATTRIBUTE_UNUSED
7377 return_in_memory_ms_64 (const_tree type, enum machine_mode mode)
7378 {
7379   HOST_WIDE_INT size = int_size_in_bytes (type);
7380
7381   /* __m128 is returned in xmm0.  */
7382   if ((SCALAR_INT_MODE_P (mode) || VECTOR_MODE_P (mode))
7383       && !COMPLEX_MODE_P (mode) && (GET_MODE_SIZE (mode) == 16 || size == 16))
7384     return false;
7385
7386   /* Otherwise, the size must be exactly in [1248]. */
7387   return size != 1 && size != 2 && size != 4 && size != 8;
7388 }
7389
7390 static bool
7391 ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
7392 {
7393 #ifdef SUBTARGET_RETURN_IN_MEMORY
7394   return SUBTARGET_RETURN_IN_MEMORY (type, fntype);
7395 #else
7396   const enum machine_mode mode = type_natural_mode (type, NULL);
7397
7398   if (TARGET_64BIT)
7399     {
7400       if (ix86_function_type_abi (fntype) == MS_ABI)
7401         return return_in_memory_ms_64 (type, mode);
7402       else
7403         return return_in_memory_64 (type, mode);
7404     }
7405   else
7406     return return_in_memory_32 (type, mode);
7407 #endif
7408 }
7409
7410 /* When returning SSE vector types, we have a choice of either
7411      (1) being abi incompatible with a -march switch, or
7412      (2) generating an error.
7413    Given no good solution, I think the safest thing is one warning.
7414    The user won't be able to use -Werror, but....
7415
7416    Choose the STRUCT_VALUE_RTX hook because that's (at present) only
7417    called in response to actually generating a caller or callee that
7418    uses such a type.  As opposed to TARGET_RETURN_IN_MEMORY, which is called
7419    via aggregate_value_p for general type probing from tree-ssa.  */
7420
7421 static rtx
7422 ix86_struct_value_rtx (tree type, int incoming ATTRIBUTE_UNUSED)
7423 {
7424   static bool warnedsse, warnedmmx;
7425
7426   if (!TARGET_64BIT && type)
7427     {
7428       /* Look at the return type of the function, not the function type.  */
7429       enum machine_mode mode = TYPE_MODE (TREE_TYPE (type));
7430
7431       if (!TARGET_SSE && !warnedsse)
7432         {
7433           if (mode == TImode
7434               || (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 16))
7435             {
7436               warnedsse = true;
7437               warning (0, "SSE vector return without SSE enabled "
7438                        "changes the ABI");
7439             }
7440         }
7441
7442       if (!TARGET_MMX && !warnedmmx)
7443         {
7444           if (VECTOR_MODE_P (mode) && GET_MODE_SIZE (mode) == 8)
7445             {
7446               warnedmmx = true;
7447               warning (0, "MMX vector return without MMX enabled "
7448                        "changes the ABI");
7449             }
7450         }
7451     }
7452
7453   return NULL;
7454 }
7455
7456 \f
7457 /* Create the va_list data type.  */
7458
7459 /* Returns the calling convention specific va_list date type.
7460    The argument ABI can be DEFAULT_ABI, MS_ABI, or SYSV_ABI.  */
7461
7462 static tree
7463 ix86_build_builtin_va_list_abi (enum calling_abi abi)
7464 {
7465   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
7466
7467   /* For i386 we use plain pointer to argument area.  */
7468   if (!TARGET_64BIT || abi == MS_ABI)
7469     return build_pointer_type (char_type_node);
7470
7471   record = lang_hooks.types.make_type (RECORD_TYPE);
7472   type_decl = build_decl (BUILTINS_LOCATION,
7473                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
7474
7475   f_gpr = build_decl (BUILTINS_LOCATION,
7476                       FIELD_DECL, get_identifier ("gp_offset"),
7477                       unsigned_type_node);
7478   f_fpr = build_decl (BUILTINS_LOCATION,
7479                       FIELD_DECL, get_identifier ("fp_offset"),
7480                       unsigned_type_node);
7481   f_ovf = build_decl (BUILTINS_LOCATION,
7482                       FIELD_DECL, get_identifier ("overflow_arg_area"),
7483                       ptr_type_node);
7484   f_sav = build_decl (BUILTINS_LOCATION,
7485                       FIELD_DECL, get_identifier ("reg_save_area"),
7486                       ptr_type_node);
7487
7488   va_list_gpr_counter_field = f_gpr;
7489   va_list_fpr_counter_field = f_fpr;
7490
7491   DECL_FIELD_CONTEXT (f_gpr) = record;
7492   DECL_FIELD_CONTEXT (f_fpr) = record;
7493   DECL_FIELD_CONTEXT (f_ovf) = record;
7494   DECL_FIELD_CONTEXT (f_sav) = record;
7495
7496   TYPE_STUB_DECL (record) = type_decl;
7497   TYPE_NAME (record) = type_decl;
7498   TYPE_FIELDS (record) = f_gpr;
7499   DECL_CHAIN (f_gpr) = f_fpr;
7500   DECL_CHAIN (f_fpr) = f_ovf;
7501   DECL_CHAIN (f_ovf) = f_sav;
7502
7503   layout_type (record);
7504
7505   /* The correct type is an array type of one element.  */
7506   return build_array_type (record, build_index_type (size_zero_node));
7507 }
7508
7509 /* Setup the builtin va_list data type and for 64-bit the additional
7510    calling convention specific va_list data types.  */
7511
7512 static tree
7513 ix86_build_builtin_va_list (void)
7514 {
7515   tree ret = ix86_build_builtin_va_list_abi (ix86_abi);
7516
7517   /* Initialize abi specific va_list builtin types.  */
7518   if (TARGET_64BIT)
7519     {
7520       tree t;
7521       if (ix86_abi == MS_ABI)
7522         {
7523           t = ix86_build_builtin_va_list_abi (SYSV_ABI);
7524           if (TREE_CODE (t) != RECORD_TYPE)
7525             t = build_variant_type_copy (t);
7526           sysv_va_list_type_node = t;
7527         }
7528       else
7529         {
7530           t = ret;
7531           if (TREE_CODE (t) != RECORD_TYPE)
7532             t = build_variant_type_copy (t);
7533           sysv_va_list_type_node = t;
7534         }
7535       if (ix86_abi != MS_ABI)
7536         {
7537           t = ix86_build_builtin_va_list_abi (MS_ABI);
7538           if (TREE_CODE (t) != RECORD_TYPE)
7539             t = build_variant_type_copy (t);
7540           ms_va_list_type_node = t;
7541         }
7542       else
7543         {
7544           t = ret;
7545           if (TREE_CODE (t) != RECORD_TYPE)
7546             t = build_variant_type_copy (t);
7547           ms_va_list_type_node = t;
7548         }
7549     }
7550
7551   return ret;
7552 }
7553
7554 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
7555
7556 static void
7557 setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum)
7558 {
7559   rtx save_area, mem;
7560   alias_set_type set;
7561   int i, max;
7562
7563   /* GPR size of varargs save area.  */
7564   if (cfun->va_list_gpr_size)
7565     ix86_varargs_gpr_size = X86_64_REGPARM_MAX * UNITS_PER_WORD;
7566   else
7567     ix86_varargs_gpr_size = 0;
7568
7569   /* FPR size of varargs save area.  We don't need it if we don't pass
7570      anything in SSE registers.  */
7571   if (TARGET_SSE && cfun->va_list_fpr_size)
7572     ix86_varargs_fpr_size = X86_64_SSE_REGPARM_MAX * 16;
7573   else
7574     ix86_varargs_fpr_size = 0;
7575
7576   if (! ix86_varargs_gpr_size && ! ix86_varargs_fpr_size)
7577     return;
7578
7579   save_area = frame_pointer_rtx;
7580   set = get_varargs_alias_set ();
7581
7582   max = cum->regno + cfun->va_list_gpr_size / UNITS_PER_WORD;
7583   if (max > X86_64_REGPARM_MAX)
7584     max = X86_64_REGPARM_MAX;
7585
7586   for (i = cum->regno; i < max; i++)
7587     {
7588       mem = gen_rtx_MEM (Pmode,
7589                          plus_constant (save_area, i * UNITS_PER_WORD));
7590       MEM_NOTRAP_P (mem) = 1;
7591       set_mem_alias_set (mem, set);
7592       emit_move_insn (mem, gen_rtx_REG (Pmode,
7593                                         x86_64_int_parameter_registers[i]));
7594     }
7595
7596   if (ix86_varargs_fpr_size)
7597     {
7598       enum machine_mode smode;
7599       rtx label, test;
7600
7601       /* Now emit code to save SSE registers.  The AX parameter contains number
7602          of SSE parameter registers used to call this function, though all we
7603          actually check here is the zero/non-zero status.  */
7604
7605       label = gen_label_rtx ();
7606       test = gen_rtx_EQ (VOIDmode, gen_rtx_REG (QImode, AX_REG), const0_rtx);
7607       emit_jump_insn (gen_cbranchqi4 (test, XEXP (test, 0), XEXP (test, 1),
7608                                       label));
7609
7610       /* ??? If !TARGET_SSE_TYPELESS_STORES, would we perform better if
7611          we used movdqa (i.e. TImode) instead?  Perhaps even better would
7612          be if we could determine the real mode of the data, via a hook
7613          into pass_stdarg.  Ignore all that for now.  */
7614       smode = V4SFmode;
7615       if (crtl->stack_alignment_needed < GET_MODE_ALIGNMENT (smode))
7616         crtl->stack_alignment_needed = GET_MODE_ALIGNMENT (smode);
7617
7618       max = cum->sse_regno + cfun->va_list_fpr_size / 16;
7619       if (max > X86_64_SSE_REGPARM_MAX)
7620         max = X86_64_SSE_REGPARM_MAX;
7621
7622       for (i = cum->sse_regno; i < max; ++i)
7623         {
7624           mem = plus_constant (save_area, i * 16 + ix86_varargs_gpr_size);
7625           mem = gen_rtx_MEM (smode, mem);
7626           MEM_NOTRAP_P (mem) = 1;
7627           set_mem_alias_set (mem, set);
7628           set_mem_align (mem, GET_MODE_ALIGNMENT (smode));
7629
7630           emit_move_insn (mem, gen_rtx_REG (smode, SSE_REGNO (i)));
7631         }
7632
7633       emit_label (label);
7634     }
7635 }
7636
7637 static void
7638 setup_incoming_varargs_ms_64 (CUMULATIVE_ARGS *cum)
7639 {
7640   alias_set_type set = get_varargs_alias_set ();
7641   int i;
7642
7643   /* Reset to zero, as there might be a sysv vaarg used
7644      before.  */
7645   ix86_varargs_gpr_size = 0;
7646   ix86_varargs_fpr_size = 0;
7647
7648   for (i = cum->regno; i < X86_64_MS_REGPARM_MAX; i++)
7649     {
7650       rtx reg, mem;
7651
7652       mem = gen_rtx_MEM (Pmode,
7653                          plus_constant (virtual_incoming_args_rtx,
7654                                         i * UNITS_PER_WORD));
7655       MEM_NOTRAP_P (mem) = 1;
7656       set_mem_alias_set (mem, set);
7657
7658       reg = gen_rtx_REG (Pmode, x86_64_ms_abi_int_parameter_registers[i]);
7659       emit_move_insn (mem, reg);
7660     }
7661 }
7662
7663 static void
7664 ix86_setup_incoming_varargs (cumulative_args_t cum_v, enum machine_mode mode,
7665                              tree type, int *pretend_size ATTRIBUTE_UNUSED,
7666                              int no_rtl)
7667 {
7668   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
7669   CUMULATIVE_ARGS next_cum;
7670   tree fntype;
7671
7672   /* This argument doesn't appear to be used anymore.  Which is good,
7673      because the old code here didn't suppress rtl generation.  */
7674   gcc_assert (!no_rtl);
7675
7676   if (!TARGET_64BIT)
7677     return;
7678
7679   fntype = TREE_TYPE (current_function_decl);
7680
7681   /* For varargs, we do not want to skip the dummy va_dcl argument.
7682      For stdargs, we do want to skip the last named argument.  */
7683   next_cum = *cum;
7684   if (stdarg_p (fntype))
7685     ix86_function_arg_advance (pack_cumulative_args (&next_cum), mode, type,
7686                                true);
7687
7688   if (cum->call_abi == MS_ABI)
7689     setup_incoming_varargs_ms_64 (&next_cum);
7690   else
7691     setup_incoming_varargs_64 (&next_cum);
7692 }
7693
7694 /* Checks if TYPE is of kind va_list char *.  */
7695
7696 static bool
7697 is_va_list_char_pointer (tree type)
7698 {
7699   tree canonic;
7700
7701   /* For 32-bit it is always true.  */
7702   if (!TARGET_64BIT)
7703     return true;
7704   canonic = ix86_canonical_va_list_type (type);
7705   return (canonic == ms_va_list_type_node
7706           || (ix86_abi == MS_ABI && canonic == va_list_type_node));
7707 }
7708
7709 /* Implement va_start.  */
7710
7711 static void
7712 ix86_va_start (tree valist, rtx nextarg)
7713 {
7714   HOST_WIDE_INT words, n_gpr, n_fpr;
7715   tree f_gpr, f_fpr, f_ovf, f_sav;
7716   tree gpr, fpr, ovf, sav, t;
7717   tree type;
7718   rtx ovf_rtx;
7719
7720   if (flag_split_stack
7721       && cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7722     {
7723       unsigned int scratch_regno;
7724
7725       /* When we are splitting the stack, we can't refer to the stack
7726          arguments using internal_arg_pointer, because they may be on
7727          the old stack.  The split stack prologue will arrange to
7728          leave a pointer to the old stack arguments in a scratch
7729          register, which we here copy to a pseudo-register.  The split
7730          stack prologue can't set the pseudo-register directly because
7731          it (the prologue) runs before any registers have been saved.  */
7732
7733       scratch_regno = split_stack_prologue_scratch_regno ();
7734       if (scratch_regno != INVALID_REGNUM)
7735         {
7736           rtx reg, seq;
7737
7738           reg = gen_reg_rtx (Pmode);
7739           cfun->machine->split_stack_varargs_pointer = reg;
7740
7741           start_sequence ();
7742           emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
7743           seq = get_insns ();
7744           end_sequence ();
7745
7746           push_topmost_sequence ();
7747           emit_insn_after (seq, entry_of_function ());
7748           pop_topmost_sequence ();
7749         }
7750     }
7751
7752   /* Only 64bit target needs something special.  */
7753   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7754     {
7755       if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7756         std_expand_builtin_va_start (valist, nextarg);
7757       else
7758         {
7759           rtx va_r, next;
7760
7761           va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
7762           next = expand_binop (ptr_mode, add_optab,
7763                                cfun->machine->split_stack_varargs_pointer,
7764                                crtl->args.arg_offset_rtx,
7765                                NULL_RTX, 0, OPTAB_LIB_WIDEN);
7766           convert_move (va_r, next, 0);
7767         }
7768       return;
7769     }
7770
7771   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7772   f_fpr = DECL_CHAIN (f_gpr);
7773   f_ovf = DECL_CHAIN (f_fpr);
7774   f_sav = DECL_CHAIN (f_ovf);
7775
7776   valist = build_simple_mem_ref (valist);
7777   TREE_TYPE (valist) = TREE_TYPE (sysv_va_list_type_node);
7778   /* The following should be folded into the MEM_REF offset.  */
7779   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), unshare_expr (valist),
7780                 f_gpr, NULL_TREE);
7781   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
7782                 f_fpr, NULL_TREE);
7783   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
7784                 f_ovf, NULL_TREE);
7785   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
7786                 f_sav, NULL_TREE);
7787
7788   /* Count number of gp and fp argument registers used.  */
7789   words = crtl->args.info.words;
7790   n_gpr = crtl->args.info.regno;
7791   n_fpr = crtl->args.info.sse_regno;
7792
7793   if (cfun->va_list_gpr_size)
7794     {
7795       type = TREE_TYPE (gpr);
7796       t = build2 (MODIFY_EXPR, type,
7797                   gpr, build_int_cst (type, n_gpr * 8));
7798       TREE_SIDE_EFFECTS (t) = 1;
7799       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7800     }
7801
7802   if (TARGET_SSE && cfun->va_list_fpr_size)
7803     {
7804       type = TREE_TYPE (fpr);
7805       t = build2 (MODIFY_EXPR, type, fpr,
7806                   build_int_cst (type, n_fpr * 16 + 8*X86_64_REGPARM_MAX));
7807       TREE_SIDE_EFFECTS (t) = 1;
7808       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7809     }
7810
7811   /* Find the overflow area.  */
7812   type = TREE_TYPE (ovf);
7813   if (cfun->machine->split_stack_varargs_pointer == NULL_RTX)
7814     ovf_rtx = crtl->args.internal_arg_pointer;
7815   else
7816     ovf_rtx = cfun->machine->split_stack_varargs_pointer;
7817   t = make_tree (type, ovf_rtx);
7818   if (words != 0)
7819     t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD);
7820   t = build2 (MODIFY_EXPR, type, ovf, t);
7821   TREE_SIDE_EFFECTS (t) = 1;
7822   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7823
7824   if (ix86_varargs_gpr_size || ix86_varargs_fpr_size)
7825     {
7826       /* Find the register save area.
7827          Prologue of the function save it right above stack frame.  */
7828       type = TREE_TYPE (sav);
7829       t = make_tree (type, frame_pointer_rtx);
7830       if (!ix86_varargs_gpr_size)
7831         t = fold_build_pointer_plus_hwi (t, -8 * X86_64_REGPARM_MAX);
7832       t = build2 (MODIFY_EXPR, type, sav, t);
7833       TREE_SIDE_EFFECTS (t) = 1;
7834       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7835     }
7836 }
7837
7838 /* Implement va_arg.  */
7839
7840 static tree
7841 ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
7842                       gimple_seq *post_p)
7843 {
7844   static const int intreg[6] = { 0, 1, 2, 3, 4, 5 };
7845   tree f_gpr, f_fpr, f_ovf, f_sav;
7846   tree gpr, fpr, ovf, sav, t;
7847   int size, rsize;
7848   tree lab_false, lab_over = NULL_TREE;
7849   tree addr, t2;
7850   rtx container;
7851   int indirect_p = 0;
7852   tree ptrtype;
7853   enum machine_mode nat_mode;
7854   unsigned int arg_boundary;
7855
7856   /* Only 64bit target needs something special.  */
7857   if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist)))
7858     return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
7859
7860   f_gpr = TYPE_FIELDS (TREE_TYPE (sysv_va_list_type_node));
7861   f_fpr = DECL_CHAIN (f_gpr);
7862   f_ovf = DECL_CHAIN (f_fpr);
7863   f_sav = DECL_CHAIN (f_ovf);
7864
7865   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr),
7866                 build_va_arg_indirect_ref (valist), f_gpr, NULL_TREE);
7867   valist = build_va_arg_indirect_ref (valist);
7868   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
7869   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
7870   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
7871
7872   indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
7873   if (indirect_p)
7874     type = build_pointer_type (type);
7875   size = int_size_in_bytes (type);
7876   rsize = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7877
7878   nat_mode = type_natural_mode (type, NULL);
7879   switch (nat_mode)
7880     {
7881     case V8SFmode:
7882     case V8SImode:
7883     case V32QImode:
7884     case V16HImode:
7885     case V4DFmode:
7886     case V4DImode:
7887       /* Unnamed 256bit vector mode parameters are passed on stack.  */
7888       if (!TARGET_64BIT_MS_ABI)
7889         {
7890           container = NULL;
7891           break;
7892         }
7893
7894     default:
7895       container = construct_container (nat_mode, TYPE_MODE (type),
7896                                        type, 0, X86_64_REGPARM_MAX,
7897                                        X86_64_SSE_REGPARM_MAX, intreg,
7898                                        0);
7899       break;
7900     }
7901
7902   /* Pull the value out of the saved registers.  */
7903
7904   addr = create_tmp_var (ptr_type_node, "addr");
7905
7906   if (container)
7907     {
7908       int needed_intregs, needed_sseregs;
7909       bool need_temp;
7910       tree int_addr, sse_addr;
7911
7912       lab_false = create_artificial_label (UNKNOWN_LOCATION);
7913       lab_over = create_artificial_label (UNKNOWN_LOCATION);
7914
7915       examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
7916
7917       need_temp = (!REG_P (container)
7918                    && ((needed_intregs && TYPE_ALIGN (type) > 64)
7919                        || TYPE_ALIGN (type) > 128));
7920
7921       /* In case we are passing structure, verify that it is consecutive block
7922          on the register save area.  If not we need to do moves.  */
7923       if (!need_temp && !REG_P (container))
7924         {
7925           /* Verify that all registers are strictly consecutive  */
7926           if (SSE_REGNO_P (REGNO (XEXP (XVECEXP (container, 0, 0), 0))))
7927             {
7928               int i;
7929
7930               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7931                 {
7932                   rtx slot = XVECEXP (container, 0, i);
7933                   if (REGNO (XEXP (slot, 0)) != FIRST_SSE_REG + (unsigned int) i
7934                       || INTVAL (XEXP (slot, 1)) != i * 16)
7935                     need_temp = 1;
7936                 }
7937             }
7938           else
7939             {
7940               int i;
7941
7942               for (i = 0; i < XVECLEN (container, 0) && !need_temp; i++)
7943                 {
7944                   rtx slot = XVECEXP (container, 0, i);
7945                   if (REGNO (XEXP (slot, 0)) != (unsigned int) i
7946                       || INTVAL (XEXP (slot, 1)) != i * 8)
7947                     need_temp = 1;
7948                 }
7949             }
7950         }
7951       if (!need_temp)
7952         {
7953           int_addr = addr;
7954           sse_addr = addr;
7955         }
7956       else
7957         {
7958           int_addr = create_tmp_var (ptr_type_node, "int_addr");
7959           sse_addr = create_tmp_var (ptr_type_node, "sse_addr");
7960         }
7961
7962       /* First ensure that we fit completely in registers.  */
7963       if (needed_intregs)
7964         {
7965           t = build_int_cst (TREE_TYPE (gpr),
7966                              (X86_64_REGPARM_MAX - needed_intregs + 1) * 8);
7967           t = build2 (GE_EXPR, boolean_type_node, gpr, t);
7968           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7969           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7970           gimplify_and_add (t, pre_p);
7971         }
7972       if (needed_sseregs)
7973         {
7974           t = build_int_cst (TREE_TYPE (fpr),
7975                              (X86_64_SSE_REGPARM_MAX - needed_sseregs + 1) * 16
7976                              + X86_64_REGPARM_MAX * 8);
7977           t = build2 (GE_EXPR, boolean_type_node, fpr, t);
7978           t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
7979           t = build3 (COND_EXPR, void_type_node, t, t2, NULL_TREE);
7980           gimplify_and_add (t, pre_p);
7981         }
7982
7983       /* Compute index to start of area used for integer regs.  */
7984       if (needed_intregs)
7985         {
7986           /* int_addr = gpr + sav; */
7987           t = fold_build_pointer_plus (sav, gpr);
7988           gimplify_assign (int_addr, t, pre_p);
7989         }
7990       if (needed_sseregs)
7991         {
7992           /* sse_addr = fpr + sav; */
7993           t = fold_build_pointer_plus (sav, fpr);
7994           gimplify_assign (sse_addr, t, pre_p);
7995         }
7996       if (need_temp)
7997         {
7998           int i, prev_size = 0;
7999           tree temp = create_tmp_var (type, "va_arg_tmp");
8000
8001           /* addr = &temp; */
8002           t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
8003           gimplify_assign (addr, t, pre_p);
8004
8005           for (i = 0; i < XVECLEN (container, 0); i++)
8006             {
8007               rtx slot = XVECEXP (container, 0, i);
8008               rtx reg = XEXP (slot, 0);
8009               enum machine_mode mode = GET_MODE (reg);
8010               tree piece_type;
8011               tree addr_type;
8012               tree daddr_type;
8013               tree src_addr, src;
8014               int src_offset;
8015               tree dest_addr, dest;
8016               int cur_size = GET_MODE_SIZE (mode);
8017
8018               gcc_assert (prev_size <= INTVAL (XEXP (slot, 1)));
8019               prev_size = INTVAL (XEXP (slot, 1));
8020               if (prev_size + cur_size > size)
8021                 {
8022                   cur_size = size - prev_size;
8023                   mode = mode_for_size (cur_size * BITS_PER_UNIT, MODE_INT, 1);
8024                   if (mode == BLKmode)
8025                     mode = QImode;
8026                 }
8027               piece_type = lang_hooks.types.type_for_mode (mode, 1);
8028               if (mode == GET_MODE (reg))
8029                 addr_type = build_pointer_type (piece_type);
8030               else
8031                 addr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
8032                                                          true);
8033               daddr_type = build_pointer_type_for_mode (piece_type, ptr_mode,
8034                                                         true);
8035
8036               if (SSE_REGNO_P (REGNO (reg)))
8037                 {
8038                   src_addr = sse_addr;
8039                   src_offset = (REGNO (reg) - FIRST_SSE_REG) * 16;
8040                 }
8041               else
8042                 {
8043                   src_addr = int_addr;
8044                   src_offset = REGNO (reg) * 8;
8045                 }
8046               src_addr = fold_convert (addr_type, src_addr);
8047               src_addr = fold_build_pointer_plus_hwi (src_addr, src_offset);
8048
8049               dest_addr = fold_convert (daddr_type, addr);
8050               dest_addr = fold_build_pointer_plus_hwi (dest_addr, prev_size);
8051               if (cur_size == GET_MODE_SIZE (mode))
8052                 {
8053                   src = build_va_arg_indirect_ref (src_addr);
8054                   dest = build_va_arg_indirect_ref (dest_addr);
8055
8056                   gimplify_assign (dest, src, pre_p);
8057                 }
8058               else
8059                 {
8060                   tree copy
8061                     = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
8062                                        3, dest_addr, src_addr,
8063                                        size_int (cur_size));
8064                   gimplify_and_add (copy, pre_p);
8065                 }
8066               prev_size += cur_size;
8067             }
8068         }
8069
8070       if (needed_intregs)
8071         {
8072           t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
8073                       build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
8074           gimplify_assign (gpr, t, pre_p);
8075         }
8076
8077       if (needed_sseregs)
8078         {
8079           t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
8080                       build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
8081           gimplify_assign (fpr, t, pre_p);
8082         }
8083
8084       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
8085
8086       gimple_seq_add_stmt (pre_p, gimple_build_label (lab_false));
8087     }
8088
8089   /* ... otherwise out of the overflow area.  */
8090
8091   /* When we align parameter on stack for caller, if the parameter
8092      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
8093      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
8094      here with caller.  */
8095   arg_boundary = ix86_function_arg_boundary (VOIDmode, type);
8096   if ((unsigned int) arg_boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
8097     arg_boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
8098
8099   /* Care for on-stack alignment if needed.  */
8100   if (arg_boundary <= 64 || size == 0)
8101     t = ovf;
8102  else
8103     {
8104       HOST_WIDE_INT align = arg_boundary / 8;
8105       t = fold_build_pointer_plus_hwi (ovf, align - 1);
8106       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
8107                   build_int_cst (TREE_TYPE (t), -align));
8108     }
8109
8110   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
8111   gimplify_assign (addr, t, pre_p);
8112
8113   t = fold_build_pointer_plus_hwi (t, rsize * UNITS_PER_WORD);
8114   gimplify_assign (unshare_expr (ovf), t, pre_p);
8115
8116   if (container)
8117     gimple_seq_add_stmt (pre_p, gimple_build_label (lab_over));
8118
8119   ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
8120   addr = fold_convert (ptrtype, addr);
8121
8122   if (indirect_p)
8123     addr = build_va_arg_indirect_ref (addr);
8124   return build_va_arg_indirect_ref (addr);
8125 }
8126 \f
8127 /* Return true if OPNUM's MEM should be matched
8128    in movabs* patterns.  */
8129
8130 bool
8131 ix86_check_movabs (rtx insn, int opnum)
8132 {
8133   rtx set, mem;
8134
8135   set = PATTERN (insn);
8136   if (GET_CODE (set) == PARALLEL)
8137     set = XVECEXP (set, 0, 0);
8138   gcc_assert (GET_CODE (set) == SET);
8139   mem = XEXP (set, opnum);
8140   while (GET_CODE (mem) == SUBREG)
8141     mem = SUBREG_REG (mem);
8142   gcc_assert (MEM_P (mem));
8143   return volatile_ok || !MEM_VOLATILE_P (mem);
8144 }
8145 \f
8146 /* Initialize the table of extra 80387 mathematical constants.  */
8147
8148 static void
8149 init_ext_80387_constants (void)
8150 {
8151   static const char * cst[5] =
8152   {
8153     "0.3010299956639811952256464283594894482",  /* 0: fldlg2  */
8154     "0.6931471805599453094286904741849753009",  /* 1: fldln2  */
8155     "1.4426950408889634073876517827983434472",  /* 2: fldl2e  */
8156     "3.3219280948873623478083405569094566090",  /* 3: fldl2t  */
8157     "3.1415926535897932385128089594061862044",  /* 4: fldpi   */
8158   };
8159   int i;
8160
8161   for (i = 0; i < 5; i++)
8162     {
8163       real_from_string (&ext_80387_constants_table[i], cst[i]);
8164       /* Ensure each constant is rounded to XFmode precision.  */
8165       real_convert (&ext_80387_constants_table[i],
8166                     XFmode, &ext_80387_constants_table[i]);
8167     }
8168
8169   ext_80387_constants_init = 1;
8170 }
8171
8172 /* Return non-zero if the constant is something that
8173    can be loaded with a special instruction.  */
8174
8175 int
8176 standard_80387_constant_p (rtx x)
8177 {
8178   enum machine_mode mode = GET_MODE (x);
8179
8180   REAL_VALUE_TYPE r;
8181
8182   if (!(X87_FLOAT_MODE_P (mode) && (GET_CODE (x) == CONST_DOUBLE)))
8183     return -1;
8184
8185   if (x == CONST0_RTX (mode))
8186     return 1;
8187   if (x == CONST1_RTX (mode))
8188     return 2;
8189
8190   REAL_VALUE_FROM_CONST_DOUBLE (r, x);
8191
8192   /* For XFmode constants, try to find a special 80387 instruction when
8193      optimizing for size or on those CPUs that benefit from them.  */
8194   if (mode == XFmode
8195       && (optimize_function_for_size_p (cfun) || TARGET_EXT_80387_CONSTANTS))
8196     {
8197       int i;
8198
8199       if (! ext_80387_constants_init)
8200         init_ext_80387_constants ();
8201
8202       for (i = 0; i < 5; i++)
8203         if (real_identical (&r, &ext_80387_constants_table[i]))
8204           return i + 3;
8205     }
8206
8207   /* Load of the constant -0.0 or -1.0 will be split as
8208      fldz;fchs or fld1;fchs sequence.  */
8209   if (real_isnegzero (&r))
8210     return 8;
8211   if (real_identical (&r, &dconstm1))
8212     return 9;
8213
8214   return 0;
8215 }
8216
8217 /* Return the opcode of the special instruction to be used to load
8218    the constant X.  */
8219
8220 const char *
8221 standard_80387_constant_opcode (rtx x)
8222 {
8223   switch (standard_80387_constant_p (x))
8224     {
8225     case 1:
8226       return "fldz";
8227     case 2:
8228       return "fld1";
8229     case 3:
8230       return "fldlg2";
8231     case 4:
8232       return "fldln2";
8233     case 5:
8234       return "fldl2e";
8235     case 6:
8236       return "fldl2t";
8237     case 7:
8238       return "fldpi";
8239     case 8:
8240     case 9:
8241       return "#";
8242     default:
8243       gcc_unreachable ();
8244     }
8245 }
8246
8247 /* Return the CONST_DOUBLE representing the 80387 constant that is
8248    loaded by the specified special instruction.  The argument IDX
8249    matches the return value from standard_80387_constant_p.  */
8250
8251 rtx
8252 standard_80387_constant_rtx (int idx)
8253 {
8254   int i;
8255
8256   if (! ext_80387_constants_init)
8257     init_ext_80387_constants ();
8258
8259   switch (idx)
8260     {
8261     case 3:
8262     case 4:
8263     case 5:
8264     case 6:
8265     case 7:
8266       i = idx - 3;
8267       break;
8268
8269     default:
8270       gcc_unreachable ();
8271     }
8272
8273   return CONST_DOUBLE_FROM_REAL_VALUE (ext_80387_constants_table[i],
8274                                        XFmode);
8275 }
8276
8277 /* Return 1 if X is all 0s and 2 if x is all 1s
8278    in supported SSE/AVX vector mode.  */
8279
8280 int
8281 standard_sse_constant_p (rtx x)
8282 {
8283   enum machine_mode mode = GET_MODE (x);
8284
8285   if (x == const0_rtx || x == CONST0_RTX (GET_MODE (x)))
8286     return 1;
8287   if (vector_all_ones_operand (x, mode))
8288     switch (mode)
8289       {
8290       case V16QImode:
8291       case V8HImode:
8292       case V4SImode:
8293       case V2DImode:
8294         if (TARGET_SSE2)
8295           return 2;
8296       case V32QImode:
8297       case V16HImode:
8298       case V8SImode:
8299       case V4DImode:
8300         if (TARGET_AVX2)
8301           return 2;
8302       default:
8303         break;
8304       }
8305
8306   return 0;
8307 }
8308
8309 /* Return the opcode of the special instruction to be used to load
8310    the constant X.  */
8311
8312 const char *
8313 standard_sse_constant_opcode (rtx insn, rtx x)
8314 {
8315   switch (standard_sse_constant_p (x))
8316     {
8317     case 1:
8318       switch (get_attr_mode (insn))
8319         {
8320         case MODE_TI:
8321           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8322             return "%vpxor\t%0, %d0";
8323         case MODE_V2DF:
8324           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8325             return "%vxorpd\t%0, %d0";
8326         case MODE_V4SF:
8327           return "%vxorps\t%0, %d0";
8328
8329         case MODE_OI:
8330           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8331             return "vpxor\t%x0, %x0, %x0";
8332         case MODE_V4DF:
8333           if (!TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
8334             return "vxorpd\t%x0, %x0, %x0";
8335         case MODE_V8SF:
8336           return "vxorps\t%x0, %x0, %x0";
8337
8338         default:
8339           break;
8340         }
8341
8342     case 2:
8343       if (TARGET_AVX)
8344         return "vpcmpeqd\t%0, %0, %0";
8345       else
8346         return "pcmpeqd\t%0, %0";
8347
8348     default:
8349       break;
8350     }
8351   gcc_unreachable ();
8352 }
8353
8354 /* Returns true if OP contains a symbol reference */
8355
8356 bool
8357 symbolic_reference_mentioned_p (rtx op)
8358 {
8359   const char *fmt;
8360   int i;
8361
8362   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
8363     return true;
8364
8365   fmt = GET_RTX_FORMAT (GET_CODE (op));
8366   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
8367     {
8368       if (fmt[i] == 'E')
8369         {
8370           int j;
8371
8372           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
8373             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
8374               return true;
8375         }
8376
8377       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
8378         return true;
8379     }
8380
8381   return false;
8382 }
8383
8384 /* Return true if it is appropriate to emit `ret' instructions in the
8385    body of a function.  Do this only if the epilogue is simple, needing a
8386    couple of insns.  Prior to reloading, we can't tell how many registers
8387    must be saved, so return false then.  Return false if there is no frame
8388    marker to de-allocate.  */
8389
8390 bool
8391 ix86_can_use_return_insn_p (void)
8392 {
8393   struct ix86_frame frame;
8394
8395   if (! reload_completed || frame_pointer_needed)
8396     return 0;
8397
8398   /* Don't allow more than 32k pop, since that's all we can do
8399      with one instruction.  */
8400   if (crtl->args.pops_args && crtl->args.size >= 32768)
8401     return 0;
8402
8403   ix86_compute_frame_layout (&frame);
8404   return (frame.stack_pointer_offset == UNITS_PER_WORD
8405           && (frame.nregs + frame.nsseregs) == 0);
8406 }
8407 \f
8408 /* Value should be nonzero if functions must have frame pointers.
8409    Zero means the frame pointer need not be set up (and parms may
8410    be accessed via the stack pointer) in functions that seem suitable.  */
8411
8412 static bool
8413 ix86_frame_pointer_required (void)
8414 {
8415   /* If we accessed previous frames, then the generated code expects
8416      to be able to access the saved ebp value in our frame.  */
8417   if (cfun->machine->accesses_prev_frame)
8418     return true;
8419
8420   /* Several x86 os'es need a frame pointer for other reasons,
8421      usually pertaining to setjmp.  */
8422   if (SUBTARGET_FRAME_POINTER_REQUIRED)
8423     return true;
8424
8425   /* For older 32-bit runtimes setjmp requires valid frame-pointer.  */
8426   if (TARGET_32BIT_MS_ABI && cfun->calls_setjmp)
8427     return true;
8428
8429   /* In ix86_option_override_internal, TARGET_OMIT_LEAF_FRAME_POINTER
8430      turns off the frame pointer by default.  Turn it back on now if
8431      we've not got a leaf function.  */
8432   if (TARGET_OMIT_LEAF_FRAME_POINTER
8433       && (!current_function_is_leaf
8434           || ix86_current_function_calls_tls_descriptor))
8435     return true;
8436
8437   if (crtl->profile && !flag_fentry)
8438     return true;
8439
8440   return false;
8441 }
8442
8443 /* Record that the current function accesses previous call frames.  */
8444
8445 void
8446 ix86_setup_frame_addresses (void)
8447 {
8448   cfun->machine->accesses_prev_frame = 1;
8449 }
8450 \f
8451 #ifndef USE_HIDDEN_LINKONCE
8452 # if defined(HAVE_GAS_HIDDEN) && (SUPPORTS_ONE_ONLY - 0)
8453 #  define USE_HIDDEN_LINKONCE 1
8454 # else
8455 #  define USE_HIDDEN_LINKONCE 0
8456 # endif
8457 #endif
8458
8459 static int pic_labels_used;
8460
8461 /* Fills in the label name that should be used for a pc thunk for
8462    the given register.  */
8463
8464 static void
8465 get_pc_thunk_name (char name[32], unsigned int regno)
8466 {
8467   gcc_assert (!TARGET_64BIT);
8468
8469   if (USE_HIDDEN_LINKONCE)
8470     sprintf (name, "__x86.get_pc_thunk.%s", reg_names[regno]);
8471   else
8472     ASM_GENERATE_INTERNAL_LABEL (name, "LPR", regno);
8473 }
8474
8475
8476 /* This function generates code for -fpic that loads %ebx with
8477    the return address of the caller and then returns.  */
8478
8479 static void
8480 ix86_code_end (void)
8481 {
8482   rtx xops[2];
8483   int regno;
8484
8485   for (regno = AX_REG; regno <= SP_REG; regno++)
8486     {
8487       char name[32];
8488       tree decl;
8489
8490       if (!(pic_labels_used & (1 << regno)))
8491         continue;
8492
8493       get_pc_thunk_name (name, regno);
8494
8495       decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
8496                          get_identifier (name),
8497                          build_function_type_list (void_type_node, NULL_TREE));
8498       DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
8499                                        NULL_TREE, void_type_node);
8500       TREE_PUBLIC (decl) = 1;
8501       TREE_STATIC (decl) = 1;
8502
8503 #if TARGET_MACHO
8504       if (TARGET_MACHO)
8505         {
8506           switch_to_section (darwin_sections[text_coal_section]);
8507           fputs ("\t.weak_definition\t", asm_out_file);
8508           assemble_name (asm_out_file, name);
8509           fputs ("\n\t.private_extern\t", asm_out_file);
8510           assemble_name (asm_out_file, name);
8511           putc ('\n', asm_out_file);
8512           ASM_OUTPUT_LABEL (asm_out_file, name);
8513           DECL_WEAK (decl) = 1;
8514         }
8515       else
8516 #endif
8517       if (USE_HIDDEN_LINKONCE)
8518         {
8519           DECL_COMDAT_GROUP (decl) = DECL_ASSEMBLER_NAME (decl);
8520
8521           targetm.asm_out.unique_section (decl, 0);
8522           switch_to_section (get_named_section (decl, NULL, 0));
8523
8524           targetm.asm_out.globalize_label (asm_out_file, name);
8525           fputs ("\t.hidden\t", asm_out_file);
8526           assemble_name (asm_out_file, name);
8527           putc ('\n', asm_out_file);
8528           ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
8529         }
8530       else
8531         {
8532           switch_to_section (text_section);
8533           ASM_OUTPUT_LABEL (asm_out_file, name);
8534         }
8535
8536       DECL_INITIAL (decl) = make_node (BLOCK);
8537       current_function_decl = decl;
8538       init_function_start (decl);
8539       first_function_block_is_cold = false;
8540       /* Make sure unwind info is emitted for the thunk if needed.  */
8541       final_start_function (emit_barrier (), asm_out_file, 1);
8542
8543       /* Pad stack IP move with 4 instructions (two NOPs count
8544          as one instruction).  */
8545       if (TARGET_PAD_SHORT_FUNCTION)
8546         {
8547           int i = 8;
8548
8549           while (i--)
8550             fputs ("\tnop\n", asm_out_file);
8551         }
8552
8553       xops[0] = gen_rtx_REG (Pmode, regno);
8554       xops[1] = gen_rtx_MEM (Pmode, stack_pointer_rtx);
8555       output_asm_insn ("mov%z0\t{%1, %0|%0, %1}", xops);
8556       fputs ("\tret\n", asm_out_file);
8557       final_end_function ();
8558       init_insn_lengths ();
8559       free_after_compilation (cfun);
8560       set_cfun (NULL);
8561       current_function_decl = NULL;
8562     }
8563
8564   if (flag_split_stack)
8565     file_end_indicate_split_stack ();
8566 }
8567
8568 /* Emit code for the SET_GOT patterns.  */
8569
8570 const char *
8571 output_set_got (rtx dest, rtx label ATTRIBUTE_UNUSED)
8572 {
8573   rtx xops[3];
8574
8575   xops[0] = dest;
8576
8577   if (TARGET_VXWORKS_RTP && flag_pic)
8578     {
8579       /* Load (*VXWORKS_GOTT_BASE) into the PIC register.  */
8580       xops[2] = gen_rtx_MEM (Pmode,
8581                              gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE));
8582       output_asm_insn ("mov{l}\t{%2, %0|%0, %2}", xops);
8583
8584       /* Load (*VXWORKS_GOTT_BASE)[VXWORKS_GOTT_INDEX] into the PIC register.
8585          Use %P and a local symbol in order to print VXWORKS_GOTT_INDEX as
8586          an unadorned address.  */
8587       xops[2] = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
8588       SYMBOL_REF_FLAGS (xops[2]) |= SYMBOL_FLAG_LOCAL;
8589       output_asm_insn ("mov{l}\t{%P2(%0), %0|%0, DWORD PTR %P2[%0]}", xops);
8590       return "";
8591     }
8592
8593   xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME);
8594
8595   if (!flag_pic)
8596     {
8597       xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ());
8598
8599       output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops);
8600
8601 #if TARGET_MACHO
8602       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8603          is what will be referenced by the Mach-O PIC subsystem.  */
8604       if (!label)
8605         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8606 #endif
8607
8608       targetm.asm_out.internal_label (asm_out_file, "L",
8609                                       CODE_LABEL_NUMBER (XEXP (xops[2], 0)));
8610     }
8611   else
8612     {
8613       char name[32];
8614       get_pc_thunk_name (name, REGNO (dest));
8615       pic_labels_used |= 1 << REGNO (dest);
8616
8617       xops[2] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
8618       xops[2] = gen_rtx_MEM (QImode, xops[2]);
8619       output_asm_insn ("call\t%X2", xops);
8620       /* Output the Mach-O "canonical" label name ("Lxx$pb") here too.  This
8621          is what will be referenced by the Mach-O PIC subsystem.  */
8622 #if TARGET_MACHO
8623       if (!label)
8624         ASM_OUTPUT_LABEL (asm_out_file, MACHOPIC_FUNCTION_BASE_NAME);
8625       else
8626         targetm.asm_out.internal_label (asm_out_file, "L",
8627                                            CODE_LABEL_NUMBER (label));
8628 #endif
8629     }
8630
8631   if (!TARGET_MACHO)
8632     output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops);
8633
8634   return "";
8635 }
8636
8637 /* Generate an "push" pattern for input ARG.  */
8638
8639 static rtx
8640 gen_push (rtx arg)
8641 {
8642   struct machine_function *m = cfun->machine;
8643
8644   if (m->fs.cfa_reg == stack_pointer_rtx)
8645     m->fs.cfa_offset += UNITS_PER_WORD;
8646   m->fs.sp_offset += UNITS_PER_WORD;
8647
8648   return gen_rtx_SET (VOIDmode,
8649                       gen_rtx_MEM (Pmode,
8650                                    gen_rtx_PRE_DEC (Pmode,
8651                                                     stack_pointer_rtx)),
8652                       arg);
8653 }
8654
8655 /* Generate an "pop" pattern for input ARG.  */
8656
8657 static rtx
8658 gen_pop (rtx arg)
8659 {
8660   return gen_rtx_SET (VOIDmode,
8661                       arg,
8662                       gen_rtx_MEM (Pmode,
8663                                    gen_rtx_POST_INC (Pmode,
8664                                                      stack_pointer_rtx)));
8665 }
8666
8667 /* Return >= 0 if there is an unused call-clobbered register available
8668    for the entire function.  */
8669
8670 static unsigned int
8671 ix86_select_alt_pic_regnum (void)
8672 {
8673   if (current_function_is_leaf
8674       && !crtl->profile
8675       && !ix86_current_function_calls_tls_descriptor)
8676     {
8677       int i, drap;
8678       /* Can't use the same register for both PIC and DRAP.  */
8679       if (crtl->drap_reg)
8680         drap = REGNO (crtl->drap_reg);
8681       else
8682         drap = -1;
8683       for (i = 2; i >= 0; --i)
8684         if (i != drap && !df_regs_ever_live_p (i))
8685           return i;
8686     }
8687
8688   return INVALID_REGNUM;
8689 }
8690
8691 /* Return TRUE if we need to save REGNO.  */
8692
8693 static bool
8694 ix86_save_reg (unsigned int regno, bool maybe_eh_return)
8695 {
8696   if (pic_offset_table_rtx
8697       && regno == REAL_PIC_OFFSET_TABLE_REGNUM
8698       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
8699           || crtl->profile
8700           || crtl->calls_eh_return
8701           || crtl->uses_const_pool))
8702     return ix86_select_alt_pic_regnum () == INVALID_REGNUM;
8703
8704   if (crtl->calls_eh_return && maybe_eh_return)
8705     {
8706       unsigned i;
8707       for (i = 0; ; i++)
8708         {
8709           unsigned test = EH_RETURN_DATA_REGNO (i);
8710           if (test == INVALID_REGNUM)
8711             break;
8712           if (test == regno)
8713             return true;
8714         }
8715     }
8716
8717   if (crtl->drap_reg && regno == REGNO (crtl->drap_reg))
8718     return true;
8719
8720   return (df_regs_ever_live_p (regno)
8721           && !call_used_regs[regno]
8722           && !fixed_regs[regno]
8723           && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
8724 }
8725
8726 /* Return number of saved general prupose registers.  */
8727
8728 static int
8729 ix86_nsaved_regs (void)
8730 {
8731   int nregs = 0;
8732   int regno;
8733
8734   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8735     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8736       nregs ++;
8737   return nregs;
8738 }
8739
8740 /* Return number of saved SSE registrers.  */
8741
8742 static int
8743 ix86_nsaved_sseregs (void)
8744 {
8745   int nregs = 0;
8746   int regno;
8747
8748   if (!TARGET_64BIT_MS_ABI)
8749     return 0;
8750   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8751     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
8752       nregs ++;
8753   return nregs;
8754 }
8755
8756 /* Given FROM and TO register numbers, say whether this elimination is
8757    allowed.  If stack alignment is needed, we can only replace argument
8758    pointer with hard frame pointer, or replace frame pointer with stack
8759    pointer.  Otherwise, frame pointer elimination is automatically
8760    handled and all other eliminations are valid.  */
8761
8762 static bool
8763 ix86_can_eliminate (const int from, const int to)
8764 {
8765   if (stack_realign_fp)
8766     return ((from == ARG_POINTER_REGNUM
8767              && to == HARD_FRAME_POINTER_REGNUM)
8768             || (from == FRAME_POINTER_REGNUM
8769                 && to == STACK_POINTER_REGNUM));
8770   else
8771     return to == STACK_POINTER_REGNUM ? !frame_pointer_needed : true;
8772 }
8773
8774 /* Return the offset between two registers, one to be eliminated, and the other
8775    its replacement, at the start of a routine.  */
8776
8777 HOST_WIDE_INT
8778 ix86_initial_elimination_offset (int from, int to)
8779 {
8780   struct ix86_frame frame;
8781   ix86_compute_frame_layout (&frame);
8782
8783   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8784     return frame.hard_frame_pointer_offset;
8785   else if (from == FRAME_POINTER_REGNUM
8786            && to == HARD_FRAME_POINTER_REGNUM)
8787     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
8788   else
8789     {
8790       gcc_assert (to == STACK_POINTER_REGNUM);
8791
8792       if (from == ARG_POINTER_REGNUM)
8793         return frame.stack_pointer_offset;
8794
8795       gcc_assert (from == FRAME_POINTER_REGNUM);
8796       return frame.stack_pointer_offset - frame.frame_pointer_offset;
8797     }
8798 }
8799
8800 /* In a dynamically-aligned function, we can't know the offset from
8801    stack pointer to frame pointer, so we must ensure that setjmp
8802    eliminates fp against the hard fp (%ebp) rather than trying to
8803    index from %esp up to the top of the frame across a gap that is
8804    of unknown (at compile-time) size.  */
8805 static rtx
8806 ix86_builtin_setjmp_frame_value (void)
8807 {
8808   return stack_realign_fp ? hard_frame_pointer_rtx : virtual_stack_vars_rtx;
8809 }
8810
8811 /* When using -fsplit-stack, the allocation routines set a field in
8812    the TCB to the bottom of the stack plus this much space, measured
8813    in bytes.  */
8814
8815 #define SPLIT_STACK_AVAILABLE 256
8816
8817 /* Fill structure ix86_frame about frame of currently computed function.  */
8818
8819 static void
8820 ix86_compute_frame_layout (struct ix86_frame *frame)
8821 {
8822   unsigned int stack_alignment_needed;
8823   HOST_WIDE_INT offset;
8824   unsigned int preferred_alignment;
8825   HOST_WIDE_INT size = get_frame_size ();
8826   HOST_WIDE_INT to_allocate;
8827
8828   frame->nregs = ix86_nsaved_regs ();
8829   frame->nsseregs = ix86_nsaved_sseregs ();
8830
8831   stack_alignment_needed = crtl->stack_alignment_needed / BITS_PER_UNIT;
8832   preferred_alignment = crtl->preferred_stack_boundary / BITS_PER_UNIT;
8833
8834   /* 64-bit MS ABI seem to require stack alignment to be always 16 except for
8835      function prologues and leaf.  */
8836   if ((TARGET_64BIT_MS_ABI && preferred_alignment < 16)
8837       && (!current_function_is_leaf || cfun->calls_alloca != 0
8838           || ix86_current_function_calls_tls_descriptor))
8839     {
8840       preferred_alignment = 16;
8841       stack_alignment_needed = 16;
8842       crtl->preferred_stack_boundary = 128;
8843       crtl->stack_alignment_needed = 128;
8844     }
8845
8846   gcc_assert (!size || stack_alignment_needed);
8847   gcc_assert (preferred_alignment >= STACK_BOUNDARY / BITS_PER_UNIT);
8848   gcc_assert (preferred_alignment <= stack_alignment_needed);
8849
8850   /* For SEH we have to limit the amount of code movement into the prologue.
8851      At present we do this via a BLOCKAGE, at which point there's very little
8852      scheduling that can be done, which means that there's very little point
8853      in doing anything except PUSHs.  */
8854   if (TARGET_SEH)
8855     cfun->machine->use_fast_prologue_epilogue = false;
8856
8857   /* During reload iteration the amount of registers saved can change.
8858      Recompute the value as needed.  Do not recompute when amount of registers
8859      didn't change as reload does multiple calls to the function and does not
8860      expect the decision to change within single iteration.  */
8861   else if (!optimize_function_for_size_p (cfun)
8862            && cfun->machine->use_fast_prologue_epilogue_nregs != frame->nregs)
8863     {
8864       int count = frame->nregs;
8865       struct cgraph_node *node = cgraph_get_node (current_function_decl);
8866
8867       cfun->machine->use_fast_prologue_epilogue_nregs = count;
8868
8869       /* The fast prologue uses move instead of push to save registers.  This
8870          is significantly longer, but also executes faster as modern hardware
8871          can execute the moves in parallel, but can't do that for push/pop.
8872
8873          Be careful about choosing what prologue to emit:  When function takes
8874          many instructions to execute we may use slow version as well as in
8875          case function is known to be outside hot spot (this is known with
8876          feedback only).  Weight the size of function by number of registers
8877          to save as it is cheap to use one or two push instructions but very
8878          slow to use many of them.  */
8879       if (count)
8880         count = (count - 1) * FAST_PROLOGUE_INSN_COUNT;
8881       if (node->frequency < NODE_FREQUENCY_NORMAL
8882           || (flag_branch_probabilities
8883               && node->frequency < NODE_FREQUENCY_HOT))
8884         cfun->machine->use_fast_prologue_epilogue = false;
8885       else
8886         cfun->machine->use_fast_prologue_epilogue
8887            = !expensive_function_p (count);
8888     }
8889
8890   frame->save_regs_using_mov
8891     = (TARGET_PROLOGUE_USING_MOVE && cfun->machine->use_fast_prologue_epilogue
8892        /* If static stack checking is enabled and done with probes,
8893           the registers need to be saved before allocating the frame.  */
8894        && flag_stack_check != STATIC_BUILTIN_STACK_CHECK);
8895
8896   /* Skip return address.  */
8897   offset = UNITS_PER_WORD;
8898
8899   /* Skip pushed static chain.  */
8900   if (ix86_static_chain_on_stack)
8901     offset += UNITS_PER_WORD;
8902
8903   /* Skip saved base pointer.  */
8904   if (frame_pointer_needed)
8905     offset += UNITS_PER_WORD;
8906   frame->hfp_save_offset = offset;
8907
8908   /* The traditional frame pointer location is at the top of the frame.  */
8909   frame->hard_frame_pointer_offset = offset;
8910
8911   /* Register save area */
8912   offset += frame->nregs * UNITS_PER_WORD;
8913   frame->reg_save_offset = offset;
8914
8915   /* Align and set SSE register save area.  */
8916   if (frame->nsseregs)
8917     {
8918       /* The only ABI that has saved SSE registers (Win64) also has a
8919          16-byte aligned default stack, and thus we don't need to be
8920          within the re-aligned local stack frame to save them.  */
8921       gcc_assert (INCOMING_STACK_BOUNDARY >= 128);
8922       offset = (offset + 16 - 1) & -16;
8923       offset += frame->nsseregs * 16;
8924     }
8925   frame->sse_reg_save_offset = offset;
8926
8927   /* The re-aligned stack starts here.  Values before this point are not
8928      directly comparable with values below this point.  In order to make
8929      sure that no value happens to be the same before and after, force
8930      the alignment computation below to add a non-zero value.  */
8931   if (stack_realign_fp)
8932     offset = (offset + stack_alignment_needed) & -stack_alignment_needed;
8933
8934   /* Va-arg area */
8935   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
8936   offset += frame->va_arg_size;
8937
8938   /* Align start of frame for local function.  */
8939   if (stack_realign_fp
8940       || offset != frame->sse_reg_save_offset
8941       || size != 0
8942       || !current_function_is_leaf
8943       || cfun->calls_alloca
8944       || ix86_current_function_calls_tls_descriptor)
8945     offset = (offset + stack_alignment_needed - 1) & -stack_alignment_needed;
8946
8947   /* Frame pointer points here.  */
8948   frame->frame_pointer_offset = offset;
8949
8950   offset += size;
8951
8952   /* Add outgoing arguments area.  Can be skipped if we eliminated
8953      all the function calls as dead code.
8954      Skipping is however impossible when function calls alloca.  Alloca
8955      expander assumes that last crtl->outgoing_args_size
8956      of stack frame are unused.  */
8957   if (ACCUMULATE_OUTGOING_ARGS
8958       && (!current_function_is_leaf || cfun->calls_alloca
8959           || ix86_current_function_calls_tls_descriptor))
8960     {
8961       offset += crtl->outgoing_args_size;
8962       frame->outgoing_arguments_size = crtl->outgoing_args_size;
8963     }
8964   else
8965     frame->outgoing_arguments_size = 0;
8966
8967   /* Align stack boundary.  Only needed if we're calling another function
8968      or using alloca.  */
8969   if (!current_function_is_leaf || cfun->calls_alloca
8970       || ix86_current_function_calls_tls_descriptor)
8971     offset = (offset + preferred_alignment - 1) & -preferred_alignment;
8972
8973   /* We've reached end of stack frame.  */
8974   frame->stack_pointer_offset = offset;
8975
8976   /* Size prologue needs to allocate.  */
8977   to_allocate = offset - frame->sse_reg_save_offset;
8978
8979   if ((!to_allocate && frame->nregs <= 1)
8980       || (TARGET_64BIT && to_allocate >= (HOST_WIDE_INT) 0x80000000))
8981     frame->save_regs_using_mov = false;
8982
8983   if (ix86_using_red_zone ()
8984       && current_function_sp_is_unchanging
8985       && current_function_is_leaf
8986       && !ix86_current_function_calls_tls_descriptor)
8987     {
8988       frame->red_zone_size = to_allocate;
8989       if (frame->save_regs_using_mov)
8990         frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
8991       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
8992         frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
8993     }
8994   else
8995     frame->red_zone_size = 0;
8996   frame->stack_pointer_offset -= frame->red_zone_size;
8997
8998   /* The SEH frame pointer location is near the bottom of the frame.
8999      This is enforced by the fact that the difference between the
9000      stack pointer and the frame pointer is limited to 240 bytes in
9001      the unwind data structure.  */
9002   if (TARGET_SEH)
9003     {
9004       HOST_WIDE_INT diff;
9005
9006       /* If we can leave the frame pointer where it is, do so.  */
9007       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
9008       if (diff > 240 || (diff & 15) != 0)
9009         {
9010           /* Ideally we'd determine what portion of the local stack frame
9011              (within the constraint of the lowest 240) is most heavily used.
9012              But without that complication, simply bias the frame pointer
9013              by 128 bytes so as to maximize the amount of the local stack
9014              frame that is addressable with 8-bit offsets.  */
9015           frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
9016         }
9017     }
9018 }
9019
9020 /* This is semi-inlined memory_address_length, but simplified
9021    since we know that we're always dealing with reg+offset, and
9022    to avoid having to create and discard all that rtl.  */
9023
9024 static inline int
9025 choose_baseaddr_len (unsigned int regno, HOST_WIDE_INT offset)
9026 {
9027   int len = 4;
9028
9029   if (offset == 0)
9030     {
9031       /* EBP and R13 cannot be encoded without an offset.  */
9032       len = (regno == BP_REG || regno == R13_REG);
9033     }
9034   else if (IN_RANGE (offset, -128, 127))
9035     len = 1;
9036
9037   /* ESP and R12 must be encoded with a SIB byte.  */
9038   if (regno == SP_REG || regno == R12_REG)
9039     len++;
9040
9041   return len;
9042 }
9043
9044 /* Return an RTX that points to CFA_OFFSET within the stack frame.
9045    The valid base registers are taken from CFUN->MACHINE->FS.  */
9046
9047 static rtx
9048 choose_baseaddr (HOST_WIDE_INT cfa_offset)
9049 {
9050   const struct machine_function *m = cfun->machine;
9051   rtx base_reg = NULL;
9052   HOST_WIDE_INT base_offset = 0;
9053
9054   if (m->use_fast_prologue_epilogue)
9055     {
9056       /* Choose the base register most likely to allow the most scheduling
9057          opportunities.  Generally FP is valid througout the function,
9058          while DRAP must be reloaded within the epilogue.  But choose either
9059          over the SP due to increased encoding size.  */
9060
9061       if (m->fs.fp_valid)
9062         {
9063           base_reg = hard_frame_pointer_rtx;
9064           base_offset = m->fs.fp_offset - cfa_offset;
9065         }
9066       else if (m->fs.drap_valid)
9067         {
9068           base_reg = crtl->drap_reg;
9069           base_offset = 0 - cfa_offset;
9070         }
9071       else if (m->fs.sp_valid)
9072         {
9073           base_reg = stack_pointer_rtx;
9074           base_offset = m->fs.sp_offset - cfa_offset;
9075         }
9076     }
9077   else
9078     {
9079       HOST_WIDE_INT toffset;
9080       int len = 16, tlen;
9081
9082       /* Choose the base register with the smallest address encoding.
9083          With a tie, choose FP > DRAP > SP.  */
9084       if (m->fs.sp_valid)
9085         {
9086           base_reg = stack_pointer_rtx;
9087           base_offset = m->fs.sp_offset - cfa_offset;
9088           len = choose_baseaddr_len (STACK_POINTER_REGNUM, base_offset);
9089         }
9090       if (m->fs.drap_valid)
9091         {
9092           toffset = 0 - cfa_offset;
9093           tlen = choose_baseaddr_len (REGNO (crtl->drap_reg), toffset);
9094           if (tlen <= len)
9095             {
9096               base_reg = crtl->drap_reg;
9097               base_offset = toffset;
9098               len = tlen;
9099             }
9100         }
9101       if (m->fs.fp_valid)
9102         {
9103           toffset = m->fs.fp_offset - cfa_offset;
9104           tlen = choose_baseaddr_len (HARD_FRAME_POINTER_REGNUM, toffset);
9105           if (tlen <= len)
9106             {
9107               base_reg = hard_frame_pointer_rtx;
9108               base_offset = toffset;
9109               len = tlen;
9110             }
9111         }
9112     }
9113   gcc_assert (base_reg != NULL);
9114
9115   return plus_constant (base_reg, base_offset);
9116 }
9117
9118 /* Emit code to save registers in the prologue.  */
9119
9120 static void
9121 ix86_emit_save_regs (void)
9122 {
9123   unsigned int regno;
9124   rtx insn;
9125
9126   for (regno = FIRST_PSEUDO_REGISTER - 1; regno-- > 0; )
9127     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9128       {
9129         insn = emit_insn (gen_push (gen_rtx_REG (Pmode, regno)));
9130         RTX_FRAME_RELATED_P (insn) = 1;
9131       }
9132 }
9133
9134 /* Emit a single register save at CFA - CFA_OFFSET.  */
9135
9136 static void
9137 ix86_emit_save_reg_using_mov (enum machine_mode mode, unsigned int regno,
9138                               HOST_WIDE_INT cfa_offset)
9139 {
9140   struct machine_function *m = cfun->machine;
9141   rtx reg = gen_rtx_REG (mode, regno);
9142   rtx mem, addr, base, insn;
9143
9144   addr = choose_baseaddr (cfa_offset);
9145   mem = gen_frame_mem (mode, addr);
9146
9147   /* For SSE saves, we need to indicate the 128-bit alignment.  */
9148   set_mem_align (mem, GET_MODE_ALIGNMENT (mode));
9149
9150   insn = emit_move_insn (mem, reg);
9151   RTX_FRAME_RELATED_P (insn) = 1;
9152
9153   base = addr;
9154   if (GET_CODE (base) == PLUS)
9155     base = XEXP (base, 0);
9156   gcc_checking_assert (REG_P (base));
9157
9158   /* When saving registers into a re-aligned local stack frame, avoid
9159      any tricky guessing by dwarf2out.  */
9160   if (m->fs.realigned)
9161     {
9162       gcc_checking_assert (stack_realign_drap);
9163
9164       if (regno == REGNO (crtl->drap_reg))
9165         {
9166           /* A bit of a hack.  We force the DRAP register to be saved in
9167              the re-aligned stack frame, which provides us with a copy
9168              of the CFA that will last past the prologue.  Install it.  */
9169           gcc_checking_assert (cfun->machine->fs.fp_valid);
9170           addr = plus_constant (hard_frame_pointer_rtx,
9171                                 cfun->machine->fs.fp_offset - cfa_offset);
9172           mem = gen_rtx_MEM (mode, addr);
9173           add_reg_note (insn, REG_CFA_DEF_CFA, mem);
9174         }
9175       else
9176         {
9177           /* The frame pointer is a stable reference within the
9178              aligned frame.  Use it.  */
9179           gcc_checking_assert (cfun->machine->fs.fp_valid);
9180           addr = plus_constant (hard_frame_pointer_rtx,
9181                                 cfun->machine->fs.fp_offset - cfa_offset);
9182           mem = gen_rtx_MEM (mode, addr);
9183           add_reg_note (insn, REG_CFA_EXPRESSION,
9184                         gen_rtx_SET (VOIDmode, mem, reg));
9185         }
9186     }
9187
9188   /* The memory may not be relative to the current CFA register,
9189      which means that we may need to generate a new pattern for
9190      use by the unwind info.  */
9191   else if (base != m->fs.cfa_reg)
9192     {
9193       addr = plus_constant (m->fs.cfa_reg, m->fs.cfa_offset - cfa_offset);
9194       mem = gen_rtx_MEM (mode, addr);
9195       add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, mem, reg));
9196     }
9197 }
9198
9199 /* Emit code to save registers using MOV insns.
9200    First register is stored at CFA - CFA_OFFSET.  */
9201 static void
9202 ix86_emit_save_regs_using_mov (HOST_WIDE_INT cfa_offset)
9203 {
9204   unsigned int regno;
9205
9206   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9207     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9208       {
9209         ix86_emit_save_reg_using_mov (Pmode, regno, cfa_offset);
9210         cfa_offset -= UNITS_PER_WORD;
9211       }
9212 }
9213
9214 /* Emit code to save SSE registers using MOV insns.
9215    First register is stored at CFA - CFA_OFFSET.  */
9216 static void
9217 ix86_emit_save_sse_regs_using_mov (HOST_WIDE_INT cfa_offset)
9218 {
9219   unsigned int regno;
9220
9221   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
9222     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, true))
9223       {
9224         ix86_emit_save_reg_using_mov (V4SFmode, regno, cfa_offset);
9225         cfa_offset -= 16;
9226       }
9227 }
9228
9229 static GTY(()) rtx queued_cfa_restores;
9230
9231 /* Add a REG_CFA_RESTORE REG note to INSN or queue them until next stack
9232    manipulation insn.  The value is on the stack at CFA - CFA_OFFSET.
9233    Don't add the note if the previously saved value will be left untouched
9234    within stack red-zone till return, as unwinders can find the same value
9235    in the register and on the stack.  */
9236
9237 static void
9238 ix86_add_cfa_restore_note (rtx insn, rtx reg, HOST_WIDE_INT cfa_offset)
9239 {
9240   if (!crtl->shrink_wrapped
9241       && cfa_offset <= cfun->machine->fs.red_zone_offset)
9242     return;
9243
9244   if (insn)
9245     {
9246       add_reg_note (insn, REG_CFA_RESTORE, reg);
9247       RTX_FRAME_RELATED_P (insn) = 1;
9248     }
9249   else
9250     queued_cfa_restores
9251       = alloc_reg_note (REG_CFA_RESTORE, reg, queued_cfa_restores);
9252 }
9253
9254 /* Add queued REG_CFA_RESTORE notes if any to INSN.  */
9255
9256 static void
9257 ix86_add_queued_cfa_restore_notes (rtx insn)
9258 {
9259   rtx last;
9260   if (!queued_cfa_restores)
9261     return;
9262   for (last = queued_cfa_restores; XEXP (last, 1); last = XEXP (last, 1))
9263     ;
9264   XEXP (last, 1) = REG_NOTES (insn);
9265   REG_NOTES (insn) = queued_cfa_restores;
9266   queued_cfa_restores = NULL_RTX;
9267   RTX_FRAME_RELATED_P (insn) = 1;
9268 }
9269
9270 /* Expand prologue or epilogue stack adjustment.
9271    The pattern exist to put a dependency on all ebp-based memory accesses.
9272    STYLE should be negative if instructions should be marked as frame related,
9273    zero if %r11 register is live and cannot be freely used and positive
9274    otherwise.  */
9275
9276 static void
9277 pro_epilogue_adjust_stack (rtx dest, rtx src, rtx offset,
9278                            int style, bool set_cfa)
9279 {
9280   struct machine_function *m = cfun->machine;
9281   rtx insn;
9282   bool add_frame_related_expr = false;
9283
9284   if (! TARGET_64BIT)
9285     insn = gen_pro_epilogue_adjust_stack_si_add (dest, src, offset);
9286   else if (x86_64_immediate_operand (offset, DImode))
9287     insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, offset);
9288   else
9289     {
9290       rtx tmp;
9291       /* r11 is used by indirect sibcall return as well, set before the
9292          epilogue and used after the epilogue.  */
9293       if (style)
9294         tmp = gen_rtx_REG (DImode, R11_REG);
9295       else
9296         {
9297           gcc_assert (src != hard_frame_pointer_rtx
9298                       && dest != hard_frame_pointer_rtx);
9299           tmp = hard_frame_pointer_rtx;
9300         }
9301       insn = emit_insn (gen_rtx_SET (DImode, tmp, offset));
9302       if (style < 0)
9303         add_frame_related_expr = true;
9304
9305       insn = gen_pro_epilogue_adjust_stack_di_add (dest, src, tmp);
9306     }
9307
9308   insn = emit_insn (insn);
9309   if (style >= 0)
9310     ix86_add_queued_cfa_restore_notes (insn);
9311
9312   if (set_cfa)
9313     {
9314       rtx r;
9315
9316       gcc_assert (m->fs.cfa_reg == src);
9317       m->fs.cfa_offset += INTVAL (offset);
9318       m->fs.cfa_reg = dest;
9319
9320       r = gen_rtx_PLUS (Pmode, src, offset);
9321       r = gen_rtx_SET (VOIDmode, dest, r);
9322       add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
9323       RTX_FRAME_RELATED_P (insn) = 1;
9324     }
9325   else if (style < 0)
9326     {
9327       RTX_FRAME_RELATED_P (insn) = 1;
9328       if (add_frame_related_expr)
9329         {
9330           rtx r = gen_rtx_PLUS (Pmode, src, offset);
9331           r = gen_rtx_SET (VOIDmode, dest, r);
9332           add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
9333         }
9334     }
9335
9336   if (dest == stack_pointer_rtx)
9337     {
9338       HOST_WIDE_INT ooffset = m->fs.sp_offset;
9339       bool valid = m->fs.sp_valid;
9340
9341       if (src == hard_frame_pointer_rtx)
9342         {
9343           valid = m->fs.fp_valid;
9344           ooffset = m->fs.fp_offset;
9345         }
9346       else if (src == crtl->drap_reg)
9347         {
9348           valid = m->fs.drap_valid;
9349           ooffset = 0;
9350         }
9351       else
9352         {
9353           /* Else there are two possibilities: SP itself, which we set
9354              up as the default above.  Or EH_RETURN_STACKADJ_RTX, which is
9355              taken care of this by hand along the eh_return path.  */
9356           gcc_checking_assert (src == stack_pointer_rtx
9357                                || offset == const0_rtx);
9358         }
9359
9360       m->fs.sp_offset = ooffset - INTVAL (offset);
9361       m->fs.sp_valid = valid;
9362     }
9363 }
9364
9365 /* Find an available register to be used as dynamic realign argument
9366    pointer regsiter.  Such a register will be written in prologue and
9367    used in begin of body, so it must not be
9368         1. parameter passing register.
9369         2. GOT pointer.
9370    We reuse static-chain register if it is available.  Otherwise, we
9371    use DI for i386 and R13 for x86-64.  We chose R13 since it has
9372    shorter encoding.
9373
9374    Return: the regno of chosen register.  */
9375
9376 static unsigned int
9377 find_drap_reg (void)
9378 {
9379   tree decl = cfun->decl;
9380
9381   if (TARGET_64BIT)
9382     {
9383       /* Use R13 for nested function or function need static chain.
9384          Since function with tail call may use any caller-saved
9385          registers in epilogue, DRAP must not use caller-saved
9386          register in such case.  */
9387       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9388         return R13_REG;
9389
9390       return R10_REG;
9391     }
9392   else
9393     {
9394       /* Use DI for nested function or function need static chain.
9395          Since function with tail call may use any caller-saved
9396          registers in epilogue, DRAP must not use caller-saved
9397          register in such case.  */
9398       if (DECL_STATIC_CHAIN (decl) || crtl->tail_call_emit)
9399         return DI_REG;
9400
9401       /* Reuse static chain register if it isn't used for parameter
9402          passing.  */
9403       if (ix86_function_regparm (TREE_TYPE (decl), decl) <= 2)
9404         {
9405           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl));
9406           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) == 0)
9407             return CX_REG;
9408         }
9409       return DI_REG;
9410     }
9411 }
9412
9413 /* Return minimum incoming stack alignment.  */
9414
9415 static unsigned int
9416 ix86_minimum_incoming_stack_boundary (bool sibcall)
9417 {
9418   unsigned int incoming_stack_boundary;
9419
9420   /* Prefer the one specified at command line. */
9421   if (ix86_user_incoming_stack_boundary)
9422     incoming_stack_boundary = ix86_user_incoming_stack_boundary;
9423   /* In 32bit, use MIN_STACK_BOUNDARY for incoming stack boundary
9424      if -mstackrealign is used, it isn't used for sibcall check and
9425      estimated stack alignment is 128bit.  */
9426   else if (!sibcall
9427            && !TARGET_64BIT
9428            && ix86_force_align_arg_pointer
9429            && crtl->stack_alignment_estimated == 128)
9430     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9431   else
9432     incoming_stack_boundary = ix86_default_incoming_stack_boundary;
9433
9434   /* Incoming stack alignment can be changed on individual functions
9435      via force_align_arg_pointer attribute.  We use the smallest
9436      incoming stack boundary.  */
9437   if (incoming_stack_boundary > MIN_STACK_BOUNDARY
9438       && lookup_attribute (ix86_force_align_arg_pointer_string,
9439                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
9440     incoming_stack_boundary = MIN_STACK_BOUNDARY;
9441
9442   /* The incoming stack frame has to be aligned at least at
9443      parm_stack_boundary.  */
9444   if (incoming_stack_boundary < crtl->parm_stack_boundary)
9445     incoming_stack_boundary = crtl->parm_stack_boundary;
9446
9447   /* Stack at entrance of main is aligned by runtime.  We use the
9448      smallest incoming stack boundary. */
9449   if (incoming_stack_boundary > MAIN_STACK_BOUNDARY
9450       && DECL_NAME (current_function_decl)
9451       && MAIN_NAME_P (DECL_NAME (current_function_decl))
9452       && DECL_FILE_SCOPE_P (current_function_decl))
9453     incoming_stack_boundary = MAIN_STACK_BOUNDARY;
9454
9455   return incoming_stack_boundary;
9456 }
9457
9458 /* Update incoming stack boundary and estimated stack alignment.  */
9459
9460 static void
9461 ix86_update_stack_boundary (void)
9462 {
9463   ix86_incoming_stack_boundary
9464     = ix86_minimum_incoming_stack_boundary (false);
9465
9466   /* x86_64 vararg needs 16byte stack alignment for register save
9467      area.  */
9468   if (TARGET_64BIT
9469       && cfun->stdarg
9470       && crtl->stack_alignment_estimated < 128)
9471     crtl->stack_alignment_estimated = 128;
9472 }
9473
9474 /* Handle the TARGET_GET_DRAP_RTX hook.  Return NULL if no DRAP is
9475    needed or an rtx for DRAP otherwise.  */
9476
9477 static rtx
9478 ix86_get_drap_rtx (void)
9479 {
9480   if (ix86_force_drap || !ACCUMULATE_OUTGOING_ARGS)
9481     crtl->need_drap = true;
9482
9483   if (stack_realign_drap)
9484     {
9485       /* Assign DRAP to vDRAP and returns vDRAP */
9486       unsigned int regno = find_drap_reg ();
9487       rtx drap_vreg;
9488       rtx arg_ptr;
9489       rtx seq, insn;
9490
9491       arg_ptr = gen_rtx_REG (Pmode, regno);
9492       crtl->drap_reg = arg_ptr;
9493
9494       start_sequence ();
9495       drap_vreg = copy_to_reg (arg_ptr);
9496       seq = get_insns ();
9497       end_sequence ();
9498
9499       insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
9500       if (!optimize)
9501         {
9502           add_reg_note (insn, REG_CFA_SET_VDRAP, drap_vreg);
9503           RTX_FRAME_RELATED_P (insn) = 1;
9504         }
9505       return drap_vreg;
9506     }
9507   else
9508     return NULL;
9509 }
9510
9511 /* Handle the TARGET_INTERNAL_ARG_POINTER hook.  */
9512
9513 static rtx
9514 ix86_internal_arg_pointer (void)
9515 {
9516   return virtual_incoming_args_rtx;
9517 }
9518
9519 struct scratch_reg {
9520   rtx reg;
9521   bool saved;
9522 };
9523
9524 /* Return a short-lived scratch register for use on function entry.
9525    In 32-bit mode, it is valid only after the registers are saved
9526    in the prologue.  This register must be released by means of
9527    release_scratch_register_on_entry once it is dead.  */
9528
9529 static void
9530 get_scratch_register_on_entry (struct scratch_reg *sr)
9531 {
9532   int regno;
9533
9534   sr->saved = false;
9535
9536   if (TARGET_64BIT)
9537     {
9538       /* We always use R11 in 64-bit mode.  */
9539       regno = R11_REG;
9540     }
9541   else
9542     {
9543       tree decl = current_function_decl, fntype = TREE_TYPE (decl);
9544       bool fastcall_p
9545         = lookup_attribute ("fastcall", TYPE_ATTRIBUTES (fntype)) != NULL_TREE;
9546       bool static_chain_p = DECL_STATIC_CHAIN (decl);
9547       int regparm = ix86_function_regparm (fntype, decl);
9548       int drap_regno
9549         = crtl->drap_reg ? REGNO (crtl->drap_reg) : INVALID_REGNUM;
9550
9551       /* 'fastcall' sets regparm to 2, uses ecx/edx for arguments and eax
9552           for the static chain register.  */
9553       if ((regparm < 1 || (fastcall_p && !static_chain_p))
9554           && drap_regno != AX_REG)
9555         regno = AX_REG;
9556       else if (regparm < 2 && drap_regno != DX_REG)
9557         regno = DX_REG;
9558       /* ecx is the static chain register.  */
9559       else if (regparm < 3 && !fastcall_p && !static_chain_p
9560                && drap_regno != CX_REG)
9561         regno = CX_REG;
9562       else if (ix86_save_reg (BX_REG, true))
9563         regno = BX_REG;
9564       /* esi is the static chain register.  */
9565       else if (!(regparm == 3 && static_chain_p)
9566                && ix86_save_reg (SI_REG, true))
9567         regno = SI_REG;
9568       else if (ix86_save_reg (DI_REG, true))
9569         regno = DI_REG;
9570       else
9571         {
9572           regno = (drap_regno == AX_REG ? DX_REG : AX_REG);
9573           sr->saved = true;
9574         }
9575     }
9576
9577   sr->reg = gen_rtx_REG (Pmode, regno);
9578   if (sr->saved)
9579     {
9580       rtx insn = emit_insn (gen_push (sr->reg));
9581       RTX_FRAME_RELATED_P (insn) = 1;
9582     }
9583 }
9584
9585 /* Release a scratch register obtained from the preceding function.  */
9586
9587 static void
9588 release_scratch_register_on_entry (struct scratch_reg *sr)
9589 {
9590   if (sr->saved)
9591     {
9592       rtx x, insn = emit_insn (gen_pop (sr->reg));
9593
9594       /* The RTX_FRAME_RELATED_P mechanism doesn't know about pop.  */
9595       RTX_FRAME_RELATED_P (insn) = 1;
9596       x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
9597       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
9598       add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
9599     }
9600 }
9601
9602 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
9603
9604 /* Emit code to adjust the stack pointer by SIZE bytes while probing it.  */
9605
9606 static void
9607 ix86_adjust_stack_and_probe (const HOST_WIDE_INT size)
9608 {
9609   /* We skip the probe for the first interval + a small dope of 4 words and
9610      probe that many bytes past the specified size to maintain a protection
9611      area at the botton of the stack.  */
9612   const int dope = 4 * UNITS_PER_WORD;
9613   rtx size_rtx = GEN_INT (size), last;
9614
9615   /* See if we have a constant small number of probes to generate.  If so,
9616      that's the easy case.  The run-time loop is made up of 11 insns in the
9617      generic case while the compile-time loop is made up of 3+2*(n-1) insns
9618      for n # of intervals.  */
9619   if (size <= 5 * PROBE_INTERVAL)
9620     {
9621       HOST_WIDE_INT i, adjust;
9622       bool first_probe = true;
9623
9624       /* Adjust SP and probe at PROBE_INTERVAL + N * PROBE_INTERVAL for
9625          values of N from 1 until it exceeds SIZE.  If only one probe is
9626          needed, this will not generate any code.  Then adjust and probe
9627          to PROBE_INTERVAL + SIZE.  */
9628       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9629         {
9630           if (first_probe)
9631             {
9632               adjust = 2 * PROBE_INTERVAL + dope;
9633               first_probe = false;
9634             }
9635           else
9636             adjust = PROBE_INTERVAL;
9637
9638           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9639                                   plus_constant (stack_pointer_rtx, -adjust)));
9640           emit_stack_probe (stack_pointer_rtx);
9641         }
9642
9643       if (first_probe)
9644         adjust = size + PROBE_INTERVAL + dope;
9645       else
9646         adjust = size + PROBE_INTERVAL - i;
9647
9648       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9649                               plus_constant (stack_pointer_rtx, -adjust)));
9650       emit_stack_probe (stack_pointer_rtx);
9651
9652       /* Adjust back to account for the additional first interval.  */
9653       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9654                                      plus_constant (stack_pointer_rtx,
9655                                                     PROBE_INTERVAL + dope)));
9656     }
9657
9658   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9659      extra careful with variables wrapping around because we might be at
9660      the very top (or the very bottom) of the address space and we have
9661      to be able to handle this case properly; in particular, we use an
9662      equality test for the loop condition.  */
9663   else
9664     {
9665       HOST_WIDE_INT rounded_size;
9666       struct scratch_reg sr;
9667
9668       get_scratch_register_on_entry (&sr);
9669
9670
9671       /* Step 1: round SIZE to the previous multiple of the interval.  */
9672
9673       rounded_size = size & -PROBE_INTERVAL;
9674
9675
9676       /* Step 2: compute initial and final value of the loop counter.  */
9677
9678       /* SP = SP_0 + PROBE_INTERVAL.  */
9679       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9680                               plus_constant (stack_pointer_rtx,
9681                                              - (PROBE_INTERVAL + dope))));
9682
9683       /* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE.  */
9684       emit_move_insn (sr.reg, GEN_INT (-rounded_size));
9685       emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
9686                               gen_rtx_PLUS (Pmode, sr.reg,
9687                                             stack_pointer_rtx)));
9688
9689
9690       /* Step 3: the loop
9691
9692          while (SP != LAST_ADDR)
9693            {
9694              SP = SP + PROBE_INTERVAL
9695              probe at SP
9696            }
9697
9698          adjusts SP and probes to PROBE_INTERVAL + N * PROBE_INTERVAL for
9699          values of N from 1 until it is equal to ROUNDED_SIZE.  */
9700
9701       emit_insn (ix86_gen_adjust_stack_and_probe (sr.reg, sr.reg, size_rtx));
9702
9703
9704       /* Step 4: adjust SP and probe at PROBE_INTERVAL + SIZE if we cannot
9705          assert at compile-time that SIZE is equal to ROUNDED_SIZE.  */
9706
9707       if (size != rounded_size)
9708         {
9709           emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9710                                   plus_constant (stack_pointer_rtx,
9711                                                  rounded_size - size)));
9712           emit_stack_probe (stack_pointer_rtx);
9713         }
9714
9715       /* Adjust back to account for the additional first interval.  */
9716       last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9717                                      plus_constant (stack_pointer_rtx,
9718                                                     PROBE_INTERVAL + dope)));
9719
9720       release_scratch_register_on_entry (&sr);
9721     }
9722
9723   gcc_assert (cfun->machine->fs.cfa_reg != stack_pointer_rtx);
9724
9725   /* Even if the stack pointer isn't the CFA register, we need to correctly
9726      describe the adjustments made to it, in particular differentiate the
9727      frame-related ones from the frame-unrelated ones.  */
9728   if (size > 0)
9729     {
9730       rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
9731       XVECEXP (expr, 0, 0)
9732         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9733                        plus_constant (stack_pointer_rtx, -size));
9734       XVECEXP (expr, 0, 1)
9735         = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
9736                        plus_constant (stack_pointer_rtx,
9737                                       PROBE_INTERVAL + dope + size));
9738       add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
9739       RTX_FRAME_RELATED_P (last) = 1;
9740
9741       cfun->machine->fs.sp_offset += size;
9742     }
9743
9744   /* Make sure nothing is scheduled before we are done.  */
9745   emit_insn (gen_blockage ());
9746 }
9747
9748 /* Adjust the stack pointer up to REG while probing it.  */
9749
9750 const char *
9751 output_adjust_stack_and_probe (rtx reg)
9752 {
9753   static int labelno = 0;
9754   char loop_lab[32], end_lab[32];
9755   rtx xops[2];
9756
9757   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9758   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9759
9760   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9761
9762   /* Jump to END_LAB if SP == LAST_ADDR.  */
9763   xops[0] = stack_pointer_rtx;
9764   xops[1] = reg;
9765   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9766   fputs ("\tje\t", asm_out_file);
9767   assemble_name_raw (asm_out_file, end_lab);
9768   fputc ('\n', asm_out_file);
9769
9770   /* SP = SP + PROBE_INTERVAL.  */
9771   xops[1] = GEN_INT (PROBE_INTERVAL);
9772   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9773
9774   /* Probe at SP.  */
9775   xops[1] = const0_rtx;
9776   output_asm_insn ("or%z0\t{%1, (%0)|DWORD PTR [%0], %1}", xops);
9777
9778   fprintf (asm_out_file, "\tjmp\t");
9779   assemble_name_raw (asm_out_file, loop_lab);
9780   fputc ('\n', asm_out_file);
9781
9782   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9783
9784   return "";
9785 }
9786
9787 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
9788    inclusive.  These are offsets from the current stack pointer.  */
9789
9790 static void
9791 ix86_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
9792 {
9793   /* See if we have a constant small number of probes to generate.  If so,
9794      that's the easy case.  The run-time loop is made up of 7 insns in the
9795      generic case while the compile-time loop is made up of n insns for n #
9796      of intervals.  */
9797   if (size <= 7 * PROBE_INTERVAL)
9798     {
9799       HOST_WIDE_INT i;
9800
9801       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
9802          it exceeds SIZE.  If only one probe is needed, this will not
9803          generate any code.  Then probe at FIRST + SIZE.  */
9804       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
9805         emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + i)));
9806
9807       emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + size)));
9808     }
9809
9810   /* Otherwise, do the same as above, but in a loop.  Note that we must be
9811      extra careful with variables wrapping around because we might be at
9812      the very top (or the very bottom) of the address space and we have
9813      to be able to handle this case properly; in particular, we use an
9814      equality test for the loop condition.  */
9815   else
9816     {
9817       HOST_WIDE_INT rounded_size, last;
9818       struct scratch_reg sr;
9819
9820       get_scratch_register_on_entry (&sr);
9821
9822
9823       /* Step 1: round SIZE to the previous multiple of the interval.  */
9824
9825       rounded_size = size & -PROBE_INTERVAL;
9826
9827
9828       /* Step 2: compute initial and final value of the loop counter.  */
9829
9830       /* TEST_OFFSET = FIRST.  */
9831       emit_move_insn (sr.reg, GEN_INT (-first));
9832
9833       /* LAST_OFFSET = FIRST + ROUNDED_SIZE.  */
9834       last = first + rounded_size;
9835
9836
9837       /* Step 3: the loop
9838
9839          while (TEST_ADDR != LAST_ADDR)
9840            {
9841              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
9842              probe at TEST_ADDR
9843            }
9844
9845          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
9846          until it is equal to ROUNDED_SIZE.  */
9847
9848       emit_insn (ix86_gen_probe_stack_range (sr.reg, sr.reg, GEN_INT (-last)));
9849
9850
9851       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
9852          that SIZE is equal to ROUNDED_SIZE.  */
9853
9854       if (size != rounded_size)
9855         emit_stack_probe (plus_constant (gen_rtx_PLUS (Pmode,
9856                                                        stack_pointer_rtx,
9857                                                        sr.reg),
9858                                          rounded_size - size));
9859
9860       release_scratch_register_on_entry (&sr);
9861     }
9862
9863   /* Make sure nothing is scheduled before we are done.  */
9864   emit_insn (gen_blockage ());
9865 }
9866
9867 /* Probe a range of stack addresses from REG to END, inclusive.  These are
9868    offsets from the current stack pointer.  */
9869
9870 const char *
9871 output_probe_stack_range (rtx reg, rtx end)
9872 {
9873   static int labelno = 0;
9874   char loop_lab[32], end_lab[32];
9875   rtx xops[3];
9876
9877   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
9878   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
9879
9880   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
9881
9882   /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
9883   xops[0] = reg;
9884   xops[1] = end;
9885   output_asm_insn ("cmp%z0\t{%1, %0|%0, %1}", xops);
9886   fputs ("\tje\t", asm_out_file);
9887   assemble_name_raw (asm_out_file, end_lab);
9888   fputc ('\n', asm_out_file);
9889
9890   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
9891   xops[1] = GEN_INT (PROBE_INTERVAL);
9892   output_asm_insn ("sub%z0\t{%1, %0|%0, %1}", xops);
9893
9894   /* Probe at TEST_ADDR.  */
9895   xops[0] = stack_pointer_rtx;
9896   xops[1] = reg;
9897   xops[2] = const0_rtx;
9898   output_asm_insn ("or%z0\t{%2, (%0,%1)|DWORD PTR [%0+%1], %2}", xops);
9899
9900   fprintf (asm_out_file, "\tjmp\t");
9901   assemble_name_raw (asm_out_file, loop_lab);
9902   fputc ('\n', asm_out_file);
9903
9904   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
9905
9906   return "";
9907 }
9908
9909 /* Finalize stack_realign_needed flag, which will guide prologue/epilogue
9910    to be generated in correct form.  */
9911 static void
9912 ix86_finalize_stack_realign_flags (void)
9913 {
9914   /* Check if stack realign is really needed after reload, and
9915      stores result in cfun */
9916   unsigned int incoming_stack_boundary
9917     = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary
9918        ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary);
9919   unsigned int stack_realign = (incoming_stack_boundary
9920                                 < (current_function_is_leaf
9921                                    ? crtl->max_used_stack_slot_alignment
9922                                    : crtl->stack_alignment_needed));
9923
9924   if (crtl->stack_realign_finalized)
9925     {
9926       /* After stack_realign_needed is finalized, we can't no longer
9927          change it.  */
9928       gcc_assert (crtl->stack_realign_needed == stack_realign);
9929       return;
9930     }
9931
9932   /* If the only reason for frame_pointer_needed is that we conservatively
9933      assumed stack realignment might be needed, but in the end nothing that
9934      needed the stack alignment had been spilled, clear frame_pointer_needed
9935      and say we don't need stack realignment.  */
9936   if (stack_realign
9937       && !crtl->need_drap
9938       && frame_pointer_needed
9939       && current_function_is_leaf
9940       && flag_omit_frame_pointer
9941       && current_function_sp_is_unchanging
9942       && !ix86_current_function_calls_tls_descriptor
9943       && !crtl->accesses_prior_frames
9944       && !cfun->calls_alloca
9945       && !crtl->calls_eh_return
9946       && !(flag_stack_check && STACK_CHECK_MOVING_SP)
9947       && !ix86_frame_pointer_required ()
9948       && get_frame_size () == 0
9949       && ix86_nsaved_sseregs () == 0
9950       && ix86_varargs_gpr_size + ix86_varargs_fpr_size == 0)
9951     {
9952       HARD_REG_SET set_up_by_prologue, prologue_used;
9953       basic_block bb;
9954
9955       CLEAR_HARD_REG_SET (prologue_used);
9956       CLEAR_HARD_REG_SET (set_up_by_prologue);
9957       add_to_hard_reg_set (&set_up_by_prologue, Pmode, STACK_POINTER_REGNUM);
9958       add_to_hard_reg_set (&set_up_by_prologue, Pmode, ARG_POINTER_REGNUM);
9959       add_to_hard_reg_set (&set_up_by_prologue, Pmode,
9960                            HARD_FRAME_POINTER_REGNUM);
9961       FOR_EACH_BB (bb)
9962         {
9963           rtx insn;
9964           FOR_BB_INSNS (bb, insn)
9965             if (NONDEBUG_INSN_P (insn)
9966                 && requires_stack_frame_p (insn, prologue_used,
9967                                            set_up_by_prologue))
9968               {
9969                 crtl->stack_realign_needed = stack_realign;
9970                 crtl->stack_realign_finalized = true;
9971                 return;
9972               }
9973         }
9974
9975       frame_pointer_needed = false;
9976       stack_realign = false;
9977       crtl->max_used_stack_slot_alignment = incoming_stack_boundary;
9978       crtl->stack_alignment_needed = incoming_stack_boundary;
9979       crtl->stack_alignment_estimated = incoming_stack_boundary;
9980       if (crtl->preferred_stack_boundary > incoming_stack_boundary)
9981         crtl->preferred_stack_boundary = incoming_stack_boundary;
9982       df_finish_pass (true);
9983       df_scan_alloc (NULL);
9984       df_scan_blocks ();
9985       df_compute_regs_ever_live (true);
9986       df_analyze ();
9987     }
9988
9989   crtl->stack_realign_needed = stack_realign;
9990   crtl->stack_realign_finalized = true;
9991 }
9992
9993 /* Expand the prologue into a bunch of separate insns.  */
9994
9995 void
9996 ix86_expand_prologue (void)
9997 {
9998   struct machine_function *m = cfun->machine;
9999   rtx insn, t;
10000   bool pic_reg_used;
10001   struct ix86_frame frame;
10002   HOST_WIDE_INT allocate;
10003   bool int_registers_saved;
10004
10005   ix86_finalize_stack_realign_flags ();
10006
10007   /* DRAP should not coexist with stack_realign_fp */
10008   gcc_assert (!(crtl->drap_reg && stack_realign_fp));
10009
10010   memset (&m->fs, 0, sizeof (m->fs));
10011
10012   /* Initialize CFA state for before the prologue.  */
10013   m->fs.cfa_reg = stack_pointer_rtx;
10014   m->fs.cfa_offset = INCOMING_FRAME_SP_OFFSET;
10015
10016   /* Track SP offset to the CFA.  We continue tracking this after we've
10017      swapped the CFA register away from SP.  In the case of re-alignment
10018      this is fudged; we're interested to offsets within the local frame.  */
10019   m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
10020   m->fs.sp_valid = true;
10021
10022   ix86_compute_frame_layout (&frame);
10023
10024   if (!TARGET_64BIT && ix86_function_ms_hook_prologue (current_function_decl))
10025     {
10026       /* We should have already generated an error for any use of
10027          ms_hook on a nested function.  */
10028       gcc_checking_assert (!ix86_static_chain_on_stack);
10029
10030       /* Check if profiling is active and we shall use profiling before
10031          prologue variant. If so sorry.  */
10032       if (crtl->profile && flag_fentry != 0)
10033         sorry ("ms_hook_prologue attribute isn%'t compatible "
10034                "with -mfentry for 32-bit");
10035
10036       /* In ix86_asm_output_function_label we emitted:
10037          8b ff     movl.s %edi,%edi
10038          55        push   %ebp
10039          8b ec     movl.s %esp,%ebp
10040
10041          This matches the hookable function prologue in Win32 API
10042          functions in Microsoft Windows XP Service Pack 2 and newer.
10043          Wine uses this to enable Windows apps to hook the Win32 API
10044          functions provided by Wine.
10045
10046          What that means is that we've already set up the frame pointer.  */
10047
10048       if (frame_pointer_needed
10049           && !(crtl->drap_reg && crtl->stack_realign_needed))
10050         {
10051           rtx push, mov;
10052
10053           /* We've decided to use the frame pointer already set up.
10054              Describe this to the unwinder by pretending that both
10055              push and mov insns happen right here.
10056
10057              Putting the unwind info here at the end of the ms_hook
10058              is done so that we can make absolutely certain we get
10059              the required byte sequence at the start of the function,
10060              rather than relying on an assembler that can produce
10061              the exact encoding required.
10062
10063              However it does mean (in the unpatched case) that we have
10064              a 1 insn window where the asynchronous unwind info is
10065              incorrect.  However, if we placed the unwind info at
10066              its correct location we would have incorrect unwind info
10067              in the patched case.  Which is probably all moot since
10068              I don't expect Wine generates dwarf2 unwind info for the
10069              system libraries that use this feature.  */
10070
10071           insn = emit_insn (gen_blockage ());
10072
10073           push = gen_push (hard_frame_pointer_rtx);
10074           mov = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
10075                              stack_pointer_rtx);
10076           RTX_FRAME_RELATED_P (push) = 1;
10077           RTX_FRAME_RELATED_P (mov) = 1;
10078
10079           RTX_FRAME_RELATED_P (insn) = 1;
10080           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
10081                         gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, push, mov)));
10082
10083           /* Note that gen_push incremented m->fs.cfa_offset, even
10084              though we didn't emit the push insn here.  */
10085           m->fs.cfa_reg = hard_frame_pointer_rtx;
10086           m->fs.fp_offset = m->fs.cfa_offset;
10087           m->fs.fp_valid = true;
10088         }
10089       else
10090         {
10091           /* The frame pointer is not needed so pop %ebp again.
10092              This leaves us with a pristine state.  */
10093           emit_insn (gen_pop (hard_frame_pointer_rtx));
10094         }
10095     }
10096
10097   /* The first insn of a function that accepts its static chain on the
10098      stack is to push the register that would be filled in by a direct
10099      call.  This insn will be skipped by the trampoline.  */
10100   else if (ix86_static_chain_on_stack)
10101     {
10102       insn = emit_insn (gen_push (ix86_static_chain (cfun->decl, false)));
10103       emit_insn (gen_blockage ());
10104
10105       /* We don't want to interpret this push insn as a register save,
10106          only as a stack adjustment.  The real copy of the register as
10107          a save will be done later, if needed.  */
10108       t = plus_constant (stack_pointer_rtx, -UNITS_PER_WORD);
10109       t = gen_rtx_SET (VOIDmode, stack_pointer_rtx, t);
10110       add_reg_note (insn, REG_CFA_ADJUST_CFA, t);
10111       RTX_FRAME_RELATED_P (insn) = 1;
10112     }
10113
10114   /* Emit prologue code to adjust stack alignment and setup DRAP, in case
10115      of DRAP is needed and stack realignment is really needed after reload */
10116   if (stack_realign_drap)
10117     {
10118       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
10119
10120       /* Only need to push parameter pointer reg if it is caller saved.  */
10121       if (!call_used_regs[REGNO (crtl->drap_reg)])
10122         {
10123           /* Push arg pointer reg */
10124           insn = emit_insn (gen_push (crtl->drap_reg));
10125           RTX_FRAME_RELATED_P (insn) = 1;
10126         }
10127
10128       /* Grab the argument pointer.  */
10129       t = plus_constant (stack_pointer_rtx, m->fs.sp_offset);
10130       insn = emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
10131       RTX_FRAME_RELATED_P (insn) = 1;
10132       m->fs.cfa_reg = crtl->drap_reg;
10133       m->fs.cfa_offset = 0;
10134
10135       /* Align the stack.  */
10136       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
10137                                         stack_pointer_rtx,
10138                                         GEN_INT (-align_bytes)));
10139       RTX_FRAME_RELATED_P (insn) = 1;
10140
10141       /* Replicate the return address on the stack so that return
10142          address can be reached via (argp - 1) slot.  This is needed
10143          to implement macro RETURN_ADDR_RTX and intrinsic function
10144          expand_builtin_return_addr etc.  */
10145       t = plus_constant (crtl->drap_reg, -UNITS_PER_WORD);
10146       t = gen_frame_mem (Pmode, t);
10147       insn = emit_insn (gen_push (t));
10148       RTX_FRAME_RELATED_P (insn) = 1;
10149
10150       /* For the purposes of frame and register save area addressing,
10151          we've started over with a new frame.  */
10152       m->fs.sp_offset = INCOMING_FRAME_SP_OFFSET;
10153       m->fs.realigned = true;
10154     }
10155
10156   if (frame_pointer_needed && !m->fs.fp_valid)
10157     {
10158       /* Note: AT&T enter does NOT have reversed args.  Enter is probably
10159          slower on all targets.  Also sdb doesn't like it.  */
10160       insn = emit_insn (gen_push (hard_frame_pointer_rtx));
10161       RTX_FRAME_RELATED_P (insn) = 1;
10162
10163       if (m->fs.sp_offset == frame.hard_frame_pointer_offset)
10164         {
10165           insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
10166           RTX_FRAME_RELATED_P (insn) = 1;
10167
10168           if (m->fs.cfa_reg == stack_pointer_rtx)
10169             m->fs.cfa_reg = hard_frame_pointer_rtx;
10170           m->fs.fp_offset = m->fs.sp_offset;
10171           m->fs.fp_valid = true;
10172         }
10173     }
10174
10175   int_registers_saved = (frame.nregs == 0);
10176
10177   if (!int_registers_saved)
10178     {
10179       /* If saving registers via PUSH, do so now.  */
10180       if (!frame.save_regs_using_mov)
10181         {
10182           ix86_emit_save_regs ();
10183           int_registers_saved = true;
10184           gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
10185         }
10186
10187       /* When using red zone we may start register saving before allocating
10188          the stack frame saving one cycle of the prologue.  However, avoid
10189          doing this if we have to probe the stack; at least on x86_64 the
10190          stack probe can turn into a call that clobbers a red zone location. */
10191       else if (ix86_using_red_zone ()
10192                && (! TARGET_STACK_PROBE
10193                    || frame.stack_pointer_offset < CHECK_STACK_LIMIT))
10194         {
10195           ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10196           int_registers_saved = true;
10197         }
10198     }
10199
10200   if (stack_realign_fp)
10201     {
10202       int align_bytes = crtl->stack_alignment_needed / BITS_PER_UNIT;
10203       gcc_assert (align_bytes > MIN_STACK_BOUNDARY / BITS_PER_UNIT);
10204
10205       /* The computation of the size of the re-aligned stack frame means
10206          that we must allocate the size of the register save area before
10207          performing the actual alignment.  Otherwise we cannot guarantee
10208          that there's enough storage above the realignment point.  */
10209       if (m->fs.sp_offset != frame.sse_reg_save_offset)
10210         pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10211                                    GEN_INT (m->fs.sp_offset
10212                                             - frame.sse_reg_save_offset),
10213                                    -1, false);
10214
10215       /* Align the stack.  */
10216       insn = emit_insn (ix86_gen_andsp (stack_pointer_rtx,
10217                                         stack_pointer_rtx,
10218                                         GEN_INT (-align_bytes)));
10219
10220       /* For the purposes of register save area addressing, the stack
10221          pointer is no longer valid.  As for the value of sp_offset,
10222          see ix86_compute_frame_layout, which we need to match in order
10223          to pass verification of stack_pointer_offset at the end.  */
10224       m->fs.sp_offset = (m->fs.sp_offset + align_bytes) & -align_bytes;
10225       m->fs.sp_valid = false;
10226     }
10227
10228   allocate = frame.stack_pointer_offset - m->fs.sp_offset;
10229
10230   if (flag_stack_usage_info)
10231     {
10232       /* We start to count from ARG_POINTER.  */
10233       HOST_WIDE_INT stack_size = frame.stack_pointer_offset;
10234
10235       /* If it was realigned, take into account the fake frame.  */
10236       if (stack_realign_drap)
10237         {
10238           if (ix86_static_chain_on_stack)
10239             stack_size += UNITS_PER_WORD;
10240
10241           if (!call_used_regs[REGNO (crtl->drap_reg)])
10242             stack_size += UNITS_PER_WORD;
10243
10244           /* This over-estimates by 1 minimal-stack-alignment-unit but
10245              mitigates that by counting in the new return address slot.  */
10246           current_function_dynamic_stack_size
10247             += crtl->stack_alignment_needed / BITS_PER_UNIT;
10248         }
10249
10250       current_function_static_stack_size = stack_size;
10251     }
10252
10253   /* The stack has already been decremented by the instruction calling us
10254      so probe if the size is non-negative to preserve the protection area.  */
10255   if (allocate >= 0 && flag_stack_check == STATIC_BUILTIN_STACK_CHECK)
10256     {
10257       /* We expect the registers to be saved when probes are used.  */
10258       gcc_assert (int_registers_saved);
10259
10260       if (STACK_CHECK_MOVING_SP)
10261         {
10262           ix86_adjust_stack_and_probe (allocate);
10263           allocate = 0;
10264         }
10265       else
10266         {
10267           HOST_WIDE_INT size = allocate;
10268
10269           if (TARGET_64BIT && size >= (HOST_WIDE_INT) 0x80000000)
10270             size = 0x80000000 - STACK_CHECK_PROTECT - 1;
10271
10272           if (TARGET_STACK_PROBE)
10273             ix86_emit_probe_stack_range (0, size + STACK_CHECK_PROTECT);
10274           else
10275             ix86_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
10276         }
10277     }
10278
10279   if (allocate == 0)
10280     ;
10281   else if (!ix86_target_stack_probe ()
10282            || frame.stack_pointer_offset < CHECK_STACK_LIMIT)
10283     {
10284       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10285                                  GEN_INT (-allocate), -1,
10286                                  m->fs.cfa_reg == stack_pointer_rtx);
10287     }
10288   else
10289     {
10290       rtx eax = gen_rtx_REG (Pmode, AX_REG);
10291       rtx r10 = NULL;
10292       rtx (*adjust_stack_insn)(rtx, rtx, rtx);
10293
10294       bool eax_live = false;
10295       bool r10_live = false;
10296
10297       if (TARGET_64BIT)
10298         r10_live = (DECL_STATIC_CHAIN (current_function_decl) != 0);
10299       if (!TARGET_64BIT_MS_ABI)
10300         eax_live = ix86_eax_live_at_start_p ();
10301
10302       if (eax_live)
10303         {
10304           emit_insn (gen_push (eax));
10305           allocate -= UNITS_PER_WORD;
10306         }
10307       if (r10_live)
10308         {
10309           r10 = gen_rtx_REG (Pmode, R10_REG);
10310           emit_insn (gen_push (r10));
10311           allocate -= UNITS_PER_WORD;
10312         }
10313
10314       emit_move_insn (eax, GEN_INT (allocate));
10315       emit_insn (ix86_gen_allocate_stack_worker (eax, eax));
10316
10317       /* Use the fact that AX still contains ALLOCATE.  */
10318       adjust_stack_insn = (TARGET_64BIT
10319                            ? gen_pro_epilogue_adjust_stack_di_sub
10320                            : gen_pro_epilogue_adjust_stack_si_sub);
10321
10322       insn = emit_insn (adjust_stack_insn (stack_pointer_rtx,
10323                                            stack_pointer_rtx, eax));
10324
10325       /* Note that SEH directives need to continue tracking the stack
10326          pointer even after the frame pointer has been set up.  */
10327       if (m->fs.cfa_reg == stack_pointer_rtx || TARGET_SEH)
10328         {
10329           if (m->fs.cfa_reg == stack_pointer_rtx)
10330             m->fs.cfa_offset += allocate;
10331
10332           RTX_FRAME_RELATED_P (insn) = 1;
10333           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
10334                         gen_rtx_SET (VOIDmode, stack_pointer_rtx,
10335                                      plus_constant (stack_pointer_rtx,
10336                                                     -allocate)));
10337         }
10338       m->fs.sp_offset += allocate;
10339
10340       if (r10_live && eax_live)
10341         {
10342           t = choose_baseaddr (m->fs.sp_offset - allocate);
10343           emit_move_insn (r10, gen_frame_mem (Pmode, t));
10344           t = choose_baseaddr (m->fs.sp_offset - allocate - UNITS_PER_WORD);
10345           emit_move_insn (eax, gen_frame_mem (Pmode, t));
10346         }
10347       else if (eax_live || r10_live)
10348         {
10349           t = choose_baseaddr (m->fs.sp_offset - allocate);
10350           emit_move_insn ((eax_live ? eax : r10), gen_frame_mem (Pmode, t));
10351         }
10352     }
10353   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
10354
10355   /* If we havn't already set up the frame pointer, do so now.  */
10356   if (frame_pointer_needed && !m->fs.fp_valid)
10357     {
10358       insn = ix86_gen_add3 (hard_frame_pointer_rtx, stack_pointer_rtx,
10359                             GEN_INT (frame.stack_pointer_offset
10360                                      - frame.hard_frame_pointer_offset));
10361       insn = emit_insn (insn);
10362       RTX_FRAME_RELATED_P (insn) = 1;
10363       add_reg_note (insn, REG_CFA_ADJUST_CFA, NULL);
10364
10365       if (m->fs.cfa_reg == stack_pointer_rtx)
10366         m->fs.cfa_reg = hard_frame_pointer_rtx;
10367       m->fs.fp_offset = frame.hard_frame_pointer_offset;
10368       m->fs.fp_valid = true;
10369     }
10370
10371   if (!int_registers_saved)
10372     ix86_emit_save_regs_using_mov (frame.reg_save_offset);
10373   if (frame.nsseregs)
10374     ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
10375
10376   pic_reg_used = false;
10377   if (pic_offset_table_rtx
10378       && (df_regs_ever_live_p (REAL_PIC_OFFSET_TABLE_REGNUM)
10379           || crtl->profile))
10380     {
10381       unsigned int alt_pic_reg_used = ix86_select_alt_pic_regnum ();
10382
10383       if (alt_pic_reg_used != INVALID_REGNUM)
10384         SET_REGNO (pic_offset_table_rtx, alt_pic_reg_used);
10385
10386       pic_reg_used = true;
10387     }
10388
10389   if (pic_reg_used)
10390     {
10391       if (TARGET_64BIT)
10392         {
10393           if (ix86_cmodel == CM_LARGE_PIC)
10394             {
10395               rtx tmp_reg = gen_rtx_REG (DImode, R11_REG);
10396               rtx label = gen_label_rtx ();
10397               emit_label (label);
10398               LABEL_PRESERVE_P (label) = 1;
10399               gcc_assert (REGNO (pic_offset_table_rtx) != REGNO (tmp_reg));
10400               insn = emit_insn (gen_set_rip_rex64 (pic_offset_table_rtx, label));
10401               insn = emit_insn (gen_set_got_offset_rex64 (tmp_reg, label));
10402               insn = emit_insn (gen_adddi3 (pic_offset_table_rtx,
10403                                             pic_offset_table_rtx, tmp_reg));
10404             }
10405           else
10406             insn = emit_insn (gen_set_got_rex64 (pic_offset_table_rtx));
10407         }
10408       else
10409         {
10410           insn = emit_insn (gen_set_got (pic_offset_table_rtx));
10411           RTX_FRAME_RELATED_P (insn) = 1;
10412           add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
10413         }
10414     }
10415
10416   /* In the pic_reg_used case, make sure that the got load isn't deleted
10417      when mcount needs it.  Blockage to avoid call movement across mcount
10418      call is emitted in generic code after the NOTE_INSN_PROLOGUE_END
10419      note.  */
10420   if (crtl->profile && !flag_fentry && pic_reg_used)
10421     emit_insn (gen_prologue_use (pic_offset_table_rtx));
10422
10423   if (crtl->drap_reg && !crtl->stack_realign_needed)
10424     {
10425       /* vDRAP is setup but after reload it turns out stack realign
10426          isn't necessary, here we will emit prologue to setup DRAP
10427          without stack realign adjustment */
10428       t = choose_baseaddr (0);
10429       emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
10430     }
10431
10432   /* Prevent instructions from being scheduled into register save push
10433      sequence when access to the redzone area is done through frame pointer.
10434      The offset between the frame pointer and the stack pointer is calculated
10435      relative to the value of the stack pointer at the end of the function
10436      prologue, and moving instructions that access redzone area via frame
10437      pointer inside push sequence violates this assumption.  */
10438   if (frame_pointer_needed && frame.red_zone_size)
10439     emit_insn (gen_memory_blockage ());
10440
10441   /* Emit cld instruction if stringops are used in the function.  */
10442   if (TARGET_CLD && ix86_current_function_needs_cld)
10443     emit_insn (gen_cld ());
10444
10445   /* SEH requires that the prologue end within 256 bytes of the start of
10446      the function.  Prevent instruction schedules that would extend that.
10447      Further, prevent alloca modifications to the stack pointer from being
10448      combined with prologue modifications.  */
10449   if (TARGET_SEH)
10450     emit_insn (gen_prologue_use (stack_pointer_rtx));
10451 }
10452
10453 /* Emit code to restore REG using a POP insn.  */
10454
10455 static void
10456 ix86_emit_restore_reg_using_pop (rtx reg)
10457 {
10458   struct machine_function *m = cfun->machine;
10459   rtx insn = emit_insn (gen_pop (reg));
10460
10461   ix86_add_cfa_restore_note (insn, reg, m->fs.sp_offset);
10462   m->fs.sp_offset -= UNITS_PER_WORD;
10463
10464   if (m->fs.cfa_reg == crtl->drap_reg
10465       && REGNO (reg) == REGNO (crtl->drap_reg))
10466     {
10467       /* Previously we'd represented the CFA as an expression
10468          like *(%ebp - 8).  We've just popped that value from
10469          the stack, which means we need to reset the CFA to
10470          the drap register.  This will remain until we restore
10471          the stack pointer.  */
10472       add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10473       RTX_FRAME_RELATED_P (insn) = 1;
10474
10475       /* This means that the DRAP register is valid for addressing too.  */
10476       m->fs.drap_valid = true;
10477       return;
10478     }
10479
10480   if (m->fs.cfa_reg == stack_pointer_rtx)
10481     {
10482       rtx x = plus_constant (stack_pointer_rtx, UNITS_PER_WORD);
10483       x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
10484       add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
10485       RTX_FRAME_RELATED_P (insn) = 1;
10486
10487       m->fs.cfa_offset -= UNITS_PER_WORD;
10488     }
10489
10490   /* When the frame pointer is the CFA, and we pop it, we are
10491      swapping back to the stack pointer as the CFA.  This happens
10492      for stack frames that don't allocate other data, so we assume
10493      the stack pointer is now pointing at the return address, i.e.
10494      the function entry state, which makes the offset be 1 word.  */
10495   if (reg == hard_frame_pointer_rtx)
10496     {
10497       m->fs.fp_valid = false;
10498       if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10499         {
10500           m->fs.cfa_reg = stack_pointer_rtx;
10501           m->fs.cfa_offset -= UNITS_PER_WORD;
10502
10503           add_reg_note (insn, REG_CFA_DEF_CFA,
10504                         gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10505                                       GEN_INT (m->fs.cfa_offset)));
10506           RTX_FRAME_RELATED_P (insn) = 1;
10507         }
10508     }
10509 }
10510
10511 /* Emit code to restore saved registers using POP insns.  */
10512
10513 static void
10514 ix86_emit_restore_regs_using_pop (void)
10515 {
10516   unsigned int regno;
10517
10518   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10519     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, false))
10520       ix86_emit_restore_reg_using_pop (gen_rtx_REG (Pmode, regno));
10521 }
10522
10523 /* Emit code and notes for the LEAVE instruction.  */
10524
10525 static void
10526 ix86_emit_leave (void)
10527 {
10528   struct machine_function *m = cfun->machine;
10529   rtx insn = emit_insn (ix86_gen_leave ());
10530
10531   ix86_add_queued_cfa_restore_notes (insn);
10532
10533   gcc_assert (m->fs.fp_valid);
10534   m->fs.sp_valid = true;
10535   m->fs.sp_offset = m->fs.fp_offset - UNITS_PER_WORD;
10536   m->fs.fp_valid = false;
10537
10538   if (m->fs.cfa_reg == hard_frame_pointer_rtx)
10539     {
10540       m->fs.cfa_reg = stack_pointer_rtx;
10541       m->fs.cfa_offset = m->fs.sp_offset;
10542
10543       add_reg_note (insn, REG_CFA_DEF_CFA,
10544                     plus_constant (stack_pointer_rtx, m->fs.sp_offset));
10545       RTX_FRAME_RELATED_P (insn) = 1;
10546     }
10547   ix86_add_cfa_restore_note (insn, hard_frame_pointer_rtx,
10548                              m->fs.fp_offset);
10549 }
10550
10551 /* Emit code to restore saved registers using MOV insns.
10552    First register is restored from CFA - CFA_OFFSET.  */
10553 static void
10554 ix86_emit_restore_regs_using_mov (HOST_WIDE_INT cfa_offset,
10555                                   bool maybe_eh_return)
10556 {
10557   struct machine_function *m = cfun->machine;
10558   unsigned int regno;
10559
10560   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10561     if (!SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10562       {
10563         rtx reg = gen_rtx_REG (Pmode, regno);
10564         rtx insn, mem;
10565
10566         mem = choose_baseaddr (cfa_offset);
10567         mem = gen_frame_mem (Pmode, mem);
10568         insn = emit_move_insn (reg, mem);
10569
10570         if (m->fs.cfa_reg == crtl->drap_reg && regno == REGNO (crtl->drap_reg))
10571           {
10572             /* Previously we'd represented the CFA as an expression
10573                like *(%ebp - 8).  We've just popped that value from
10574                the stack, which means we need to reset the CFA to
10575                the drap register.  This will remain until we restore
10576                the stack pointer.  */
10577             add_reg_note (insn, REG_CFA_DEF_CFA, reg);
10578             RTX_FRAME_RELATED_P (insn) = 1;
10579
10580             /* This means that the DRAP register is valid for addressing.  */
10581             m->fs.drap_valid = true;
10582           }
10583         else
10584           ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10585
10586         cfa_offset -= UNITS_PER_WORD;
10587       }
10588 }
10589
10590 /* Emit code to restore saved registers using MOV insns.
10591    First register is restored from CFA - CFA_OFFSET.  */
10592 static void
10593 ix86_emit_restore_sse_regs_using_mov (HOST_WIDE_INT cfa_offset,
10594                                       bool maybe_eh_return)
10595 {
10596   unsigned int regno;
10597
10598   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10599     if (SSE_REGNO_P (regno) && ix86_save_reg (regno, maybe_eh_return))
10600       {
10601         rtx reg = gen_rtx_REG (V4SFmode, regno);
10602         rtx mem;
10603
10604         mem = choose_baseaddr (cfa_offset);
10605         mem = gen_rtx_MEM (V4SFmode, mem);
10606         set_mem_align (mem, 128);
10607         emit_move_insn (reg, mem);
10608
10609         ix86_add_cfa_restore_note (NULL_RTX, reg, cfa_offset);
10610
10611         cfa_offset -= 16;
10612       }
10613 }
10614
10615 /* Emit vzeroupper if needed.  */
10616
10617 void
10618 ix86_maybe_emit_epilogue_vzeroupper (void)
10619 {
10620   if (TARGET_VZEROUPPER
10621       && !TREE_THIS_VOLATILE (cfun->decl)
10622       && !cfun->machine->caller_return_avx256_p)
10623     emit_insn (gen_avx_vzeroupper (GEN_INT (call_no_avx256)));
10624 }
10625
10626 /* Restore function stack, frame, and registers.  */
10627
10628 void
10629 ix86_expand_epilogue (int style)
10630 {
10631   struct machine_function *m = cfun->machine;
10632   struct machine_frame_state frame_state_save = m->fs;
10633   struct ix86_frame frame;
10634   bool restore_regs_via_mov;
10635   bool using_drap;
10636
10637   ix86_finalize_stack_realign_flags ();
10638   ix86_compute_frame_layout (&frame);
10639
10640   m->fs.sp_valid = (!frame_pointer_needed
10641                     || (current_function_sp_is_unchanging
10642                         && !stack_realign_fp));
10643   gcc_assert (!m->fs.sp_valid
10644               || m->fs.sp_offset == frame.stack_pointer_offset);
10645
10646   /* The FP must be valid if the frame pointer is present.  */
10647   gcc_assert (frame_pointer_needed == m->fs.fp_valid);
10648   gcc_assert (!m->fs.fp_valid
10649               || m->fs.fp_offset == frame.hard_frame_pointer_offset);
10650
10651   /* We must have *some* valid pointer to the stack frame.  */
10652   gcc_assert (m->fs.sp_valid || m->fs.fp_valid);
10653
10654   /* The DRAP is never valid at this point.  */
10655   gcc_assert (!m->fs.drap_valid);
10656
10657   /* See the comment about red zone and frame
10658      pointer usage in ix86_expand_prologue.  */
10659   if (frame_pointer_needed && frame.red_zone_size)
10660     emit_insn (gen_memory_blockage ());
10661
10662   using_drap = crtl->drap_reg && crtl->stack_realign_needed;
10663   gcc_assert (!using_drap || m->fs.cfa_reg == crtl->drap_reg);
10664
10665   /* Determine the CFA offset of the end of the red-zone.  */
10666   m->fs.red_zone_offset = 0;
10667   if (ix86_using_red_zone () && crtl->args.pops_args < 65536)
10668     {
10669       /* The red-zone begins below the return address.  */
10670       m->fs.red_zone_offset = RED_ZONE_SIZE + UNITS_PER_WORD;
10671
10672       /* When the register save area is in the aligned portion of
10673          the stack, determine the maximum runtime displacement that
10674          matches up with the aligned frame.  */
10675       if (stack_realign_drap)
10676         m->fs.red_zone_offset -= (crtl->stack_alignment_needed / BITS_PER_UNIT
10677                                   + UNITS_PER_WORD);
10678     }
10679
10680   /* Special care must be taken for the normal return case of a function
10681      using eh_return: the eax and edx registers are marked as saved, but
10682      not restored along this path.  Adjust the save location to match.  */
10683   if (crtl->calls_eh_return && style != 2)
10684     frame.reg_save_offset -= 2 * UNITS_PER_WORD;
10685
10686   /* EH_RETURN requires the use of moves to function properly.  */
10687   if (crtl->calls_eh_return)
10688     restore_regs_via_mov = true;
10689   /* SEH requires the use of pops to identify the epilogue.  */
10690   else if (TARGET_SEH)
10691     restore_regs_via_mov = false;
10692   /* If we're only restoring one register and sp is not valid then
10693      using a move instruction to restore the register since it's
10694      less work than reloading sp and popping the register.  */
10695   else if (!m->fs.sp_valid && frame.nregs <= 1)
10696     restore_regs_via_mov = true;
10697   else if (TARGET_EPILOGUE_USING_MOVE
10698            && cfun->machine->use_fast_prologue_epilogue
10699            && (frame.nregs > 1
10700                || m->fs.sp_offset != frame.reg_save_offset))
10701     restore_regs_via_mov = true;
10702   else if (frame_pointer_needed
10703            && !frame.nregs
10704            && m->fs.sp_offset != frame.reg_save_offset)
10705     restore_regs_via_mov = true;
10706   else if (frame_pointer_needed
10707            && TARGET_USE_LEAVE
10708            && cfun->machine->use_fast_prologue_epilogue
10709            && frame.nregs == 1)
10710     restore_regs_via_mov = true;
10711   else
10712     restore_regs_via_mov = false;
10713
10714   if (restore_regs_via_mov || frame.nsseregs)
10715     {
10716       /* Ensure that the entire register save area is addressable via
10717          the stack pointer, if we will restore via sp.  */
10718       if (TARGET_64BIT
10719           && m->fs.sp_offset > 0x7fffffff
10720           && !(m->fs.fp_valid || m->fs.drap_valid)
10721           && (frame.nsseregs + frame.nregs) != 0)
10722         {
10723           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10724                                      GEN_INT (m->fs.sp_offset
10725                                               - frame.sse_reg_save_offset),
10726                                      style,
10727                                      m->fs.cfa_reg == stack_pointer_rtx);
10728         }
10729     }
10730
10731   /* If there are any SSE registers to restore, then we have to do it
10732      via moves, since there's obviously no pop for SSE regs.  */
10733   if (frame.nsseregs)
10734     ix86_emit_restore_sse_regs_using_mov (frame.sse_reg_save_offset,
10735                                           style == 2);
10736
10737   if (restore_regs_via_mov)
10738     {
10739       rtx t;
10740
10741       if (frame.nregs)
10742         ix86_emit_restore_regs_using_mov (frame.reg_save_offset, style == 2);
10743
10744       /* eh_return epilogues need %ecx added to the stack pointer.  */
10745       if (style == 2)
10746         {
10747           rtx insn, sa = EH_RETURN_STACKADJ_RTX;
10748
10749           /* Stack align doesn't work with eh_return.  */
10750           gcc_assert (!stack_realign_drap);
10751           /* Neither does regparm nested functions.  */
10752           gcc_assert (!ix86_static_chain_on_stack);
10753
10754           if (frame_pointer_needed)
10755             {
10756               t = gen_rtx_PLUS (Pmode, hard_frame_pointer_rtx, sa);
10757               t = plus_constant (t, m->fs.fp_offset - UNITS_PER_WORD);
10758               emit_insn (gen_rtx_SET (VOIDmode, sa, t));
10759
10760               t = gen_frame_mem (Pmode, hard_frame_pointer_rtx);
10761               insn = emit_move_insn (hard_frame_pointer_rtx, t);
10762
10763               /* Note that we use SA as a temporary CFA, as the return
10764                  address is at the proper place relative to it.  We
10765                  pretend this happens at the FP restore insn because
10766                  prior to this insn the FP would be stored at the wrong
10767                  offset relative to SA, and after this insn we have no
10768                  other reasonable register to use for the CFA.  We don't
10769                  bother resetting the CFA to the SP for the duration of
10770                  the return insn.  */
10771               add_reg_note (insn, REG_CFA_DEF_CFA,
10772                             plus_constant (sa, UNITS_PER_WORD));
10773               ix86_add_queued_cfa_restore_notes (insn);
10774               add_reg_note (insn, REG_CFA_RESTORE, hard_frame_pointer_rtx);
10775               RTX_FRAME_RELATED_P (insn) = 1;
10776
10777               m->fs.cfa_reg = sa;
10778               m->fs.cfa_offset = UNITS_PER_WORD;
10779               m->fs.fp_valid = false;
10780
10781               pro_epilogue_adjust_stack (stack_pointer_rtx, sa,
10782                                          const0_rtx, style, false);
10783             }
10784           else
10785             {
10786               t = gen_rtx_PLUS (Pmode, stack_pointer_rtx, sa);
10787               t = plus_constant (t, m->fs.sp_offset - UNITS_PER_WORD);
10788               insn = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx, t));
10789               ix86_add_queued_cfa_restore_notes (insn);
10790
10791               gcc_assert (m->fs.cfa_reg == stack_pointer_rtx);
10792               if (m->fs.cfa_offset != UNITS_PER_WORD)
10793                 {
10794                   m->fs.cfa_offset = UNITS_PER_WORD;
10795                   add_reg_note (insn, REG_CFA_DEF_CFA,
10796                                 plus_constant (stack_pointer_rtx,
10797                                                UNITS_PER_WORD));
10798                   RTX_FRAME_RELATED_P (insn) = 1;
10799                 }
10800             }
10801           m->fs.sp_offset = UNITS_PER_WORD;
10802           m->fs.sp_valid = true;
10803         }
10804     }
10805   else
10806     {
10807       /* SEH requires that the function end with (1) a stack adjustment
10808          if necessary, (2) a sequence of pops, and (3) a return or
10809          jump instruction.  Prevent insns from the function body from
10810          being scheduled into this sequence.  */
10811       if (TARGET_SEH)
10812         {
10813           /* Prevent a catch region from being adjacent to the standard
10814              epilogue sequence.  Unfortuantely crtl->uses_eh_lsda nor
10815              several other flags that would be interesting to test are
10816              not yet set up.  */
10817           if (flag_non_call_exceptions)
10818             emit_insn (gen_nops (const1_rtx));
10819           else
10820             emit_insn (gen_blockage ());
10821         }
10822
10823       /* First step is to deallocate the stack frame so that we can
10824          pop the registers.  */
10825       if (!m->fs.sp_valid)
10826         {
10827           pro_epilogue_adjust_stack (stack_pointer_rtx, hard_frame_pointer_rtx,
10828                                      GEN_INT (m->fs.fp_offset
10829                                               - frame.reg_save_offset),
10830                                      style, false);
10831         }
10832       else if (m->fs.sp_offset != frame.reg_save_offset)
10833         {
10834           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10835                                      GEN_INT (m->fs.sp_offset
10836                                               - frame.reg_save_offset),
10837                                      style,
10838                                      m->fs.cfa_reg == stack_pointer_rtx);
10839         }
10840
10841       ix86_emit_restore_regs_using_pop ();
10842     }
10843
10844   /* If we used a stack pointer and haven't already got rid of it,
10845      then do so now.  */
10846   if (m->fs.fp_valid)
10847     {
10848       /* If the stack pointer is valid and pointing at the frame
10849          pointer store address, then we only need a pop.  */
10850       if (m->fs.sp_valid && m->fs.sp_offset == frame.hfp_save_offset)
10851         ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10852       /* Leave results in shorter dependency chains on CPUs that are
10853          able to grok it fast.  */
10854       else if (TARGET_USE_LEAVE
10855                || optimize_function_for_size_p (cfun)
10856                || !cfun->machine->use_fast_prologue_epilogue)
10857         ix86_emit_leave ();
10858       else
10859         {
10860           pro_epilogue_adjust_stack (stack_pointer_rtx,
10861                                      hard_frame_pointer_rtx,
10862                                      const0_rtx, style, !using_drap);
10863           ix86_emit_restore_reg_using_pop (hard_frame_pointer_rtx);
10864         }
10865     }
10866
10867   if (using_drap)
10868     {
10869       int param_ptr_offset = UNITS_PER_WORD;
10870       rtx insn;
10871
10872       gcc_assert (stack_realign_drap);
10873
10874       if (ix86_static_chain_on_stack)
10875         param_ptr_offset += UNITS_PER_WORD;
10876       if (!call_used_regs[REGNO (crtl->drap_reg)])
10877         param_ptr_offset += UNITS_PER_WORD;
10878
10879       insn = emit_insn (gen_rtx_SET
10880                         (VOIDmode, stack_pointer_rtx,
10881                          gen_rtx_PLUS (Pmode,
10882                                        crtl->drap_reg,
10883                                        GEN_INT (-param_ptr_offset))));
10884       m->fs.cfa_reg = stack_pointer_rtx;
10885       m->fs.cfa_offset = param_ptr_offset;
10886       m->fs.sp_offset = param_ptr_offset;
10887       m->fs.realigned = false;
10888
10889       add_reg_note (insn, REG_CFA_DEF_CFA,
10890                     gen_rtx_PLUS (Pmode, stack_pointer_rtx,
10891                                   GEN_INT (param_ptr_offset)));
10892       RTX_FRAME_RELATED_P (insn) = 1;
10893
10894       if (!call_used_regs[REGNO (crtl->drap_reg)])
10895         ix86_emit_restore_reg_using_pop (crtl->drap_reg);
10896     }
10897
10898   /* At this point the stack pointer must be valid, and we must have
10899      restored all of the registers.  We may not have deallocated the
10900      entire stack frame.  We've delayed this until now because it may
10901      be possible to merge the local stack deallocation with the
10902      deallocation forced by ix86_static_chain_on_stack.   */
10903   gcc_assert (m->fs.sp_valid);
10904   gcc_assert (!m->fs.fp_valid);
10905   gcc_assert (!m->fs.realigned);
10906   if (m->fs.sp_offset != UNITS_PER_WORD)
10907     {
10908       pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10909                                  GEN_INT (m->fs.sp_offset - UNITS_PER_WORD),
10910                                  style, true);
10911     }
10912   else
10913     ix86_add_queued_cfa_restore_notes (get_last_insn ());
10914
10915   /* Sibcall epilogues don't want a return instruction.  */
10916   if (style == 0)
10917     {
10918       m->fs = frame_state_save;
10919       return;
10920     }
10921
10922   /* Emit vzeroupper if needed.  */
10923   ix86_maybe_emit_epilogue_vzeroupper ();
10924
10925   if (crtl->args.pops_args && crtl->args.size)
10926     {
10927       rtx popc = GEN_INT (crtl->args.pops_args);
10928
10929       /* i386 can only pop 64K bytes.  If asked to pop more, pop return
10930          address, do explicit add, and jump indirectly to the caller.  */
10931
10932       if (crtl->args.pops_args >= 65536)
10933         {
10934           rtx ecx = gen_rtx_REG (SImode, CX_REG);
10935           rtx insn;
10936
10937           /* There is no "pascal" calling convention in any 64bit ABI.  */
10938           gcc_assert (!TARGET_64BIT);
10939
10940           insn = emit_insn (gen_pop (ecx));
10941           m->fs.cfa_offset -= UNITS_PER_WORD;
10942           m->fs.sp_offset -= UNITS_PER_WORD;
10943
10944           add_reg_note (insn, REG_CFA_ADJUST_CFA,
10945                         copy_rtx (XVECEXP (PATTERN (insn), 0, 1)));
10946           add_reg_note (insn, REG_CFA_REGISTER,
10947                         gen_rtx_SET (VOIDmode, ecx, pc_rtx));
10948           RTX_FRAME_RELATED_P (insn) = 1;
10949
10950           pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
10951                                      popc, -1, true);
10952           emit_jump_insn (gen_simple_return_indirect_internal (ecx));
10953         }
10954       else
10955         emit_jump_insn (gen_simple_return_pop_internal (popc));
10956     }
10957   else
10958     emit_jump_insn (gen_simple_return_internal ());
10959
10960   /* Restore the state back to the state from the prologue,
10961      so that it's correct for the next epilogue.  */
10962   m->fs = frame_state_save;
10963 }
10964
10965 /* Reset from the function's potential modifications.  */
10966
10967 static void
10968 ix86_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
10969                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
10970 {
10971   if (pic_offset_table_rtx)
10972     SET_REGNO (pic_offset_table_rtx, REAL_PIC_OFFSET_TABLE_REGNUM);
10973 #if TARGET_MACHO
10974   /* Mach-O doesn't support labels at the end of objects, so if
10975      it looks like we might want one, insert a NOP.  */
10976   {
10977     rtx insn = get_last_insn ();
10978     rtx deleted_debug_label = NULL_RTX;
10979     while (insn
10980            && NOTE_P (insn)
10981            && NOTE_KIND (insn) != NOTE_INSN_DELETED_LABEL)
10982       {
10983         /* Don't insert a nop for NOTE_INSN_DELETED_DEBUG_LABEL
10984            notes only, instead set their CODE_LABEL_NUMBER to -1,
10985            otherwise there would be code generation differences
10986            in between -g and -g0.  */
10987         if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL)
10988           deleted_debug_label = insn;
10989         insn = PREV_INSN (insn);
10990       }
10991     if (insn
10992         && (LABEL_P (insn)
10993             || (NOTE_P (insn)
10994                 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))
10995       fputs ("\tnop\n", file);
10996     else if (deleted_debug_label)
10997       for (insn = deleted_debug_label; insn; insn = NEXT_INSN (insn))
10998         if (NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL)
10999           CODE_LABEL_NUMBER (insn) = -1;
11000   }
11001 #endif
11002
11003 }
11004
11005 /* Return a scratch register to use in the split stack prologue.  The
11006    split stack prologue is used for -fsplit-stack.  It is the first
11007    instructions in the function, even before the regular prologue.
11008    The scratch register can be any caller-saved register which is not
11009    used for parameters or for the static chain.  */
11010
11011 static unsigned int
11012 split_stack_prologue_scratch_regno (void)
11013 {
11014   if (TARGET_64BIT)
11015     return R11_REG;
11016   else
11017     {
11018       bool is_fastcall;
11019       int regparm;
11020
11021       is_fastcall = (lookup_attribute ("fastcall",
11022                                        TYPE_ATTRIBUTES (TREE_TYPE (cfun->decl)))
11023                      != NULL);
11024       regparm = ix86_function_regparm (TREE_TYPE (cfun->decl), cfun->decl);
11025
11026       if (is_fastcall)
11027         {
11028           if (DECL_STATIC_CHAIN (cfun->decl))
11029             {
11030               sorry ("-fsplit-stack does not support fastcall with "
11031                      "nested function");
11032               return INVALID_REGNUM;
11033             }
11034           return AX_REG;
11035         }
11036       else if (regparm < 3)
11037         {
11038           if (!DECL_STATIC_CHAIN (cfun->decl))
11039             return CX_REG;
11040           else
11041             {
11042               if (regparm >= 2)
11043                 {
11044                   sorry ("-fsplit-stack does not support 2 register "
11045                          " parameters for a nested function");
11046                   return INVALID_REGNUM;
11047                 }
11048               return DX_REG;
11049             }
11050         }
11051       else
11052         {
11053           /* FIXME: We could make this work by pushing a register
11054              around the addition and comparison.  */
11055           sorry ("-fsplit-stack does not support 3 register parameters");
11056           return INVALID_REGNUM;
11057         }
11058     }
11059 }
11060
11061 /* A SYMBOL_REF for the function which allocates new stackspace for
11062    -fsplit-stack.  */
11063
11064 static GTY(()) rtx split_stack_fn;
11065
11066 /* A SYMBOL_REF for the more stack function when using the large
11067    model.  */
11068
11069 static GTY(()) rtx split_stack_fn_large;
11070
11071 /* Handle -fsplit-stack.  These are the first instructions in the
11072    function, even before the regular prologue.  */
11073
11074 void
11075 ix86_expand_split_stack_prologue (void)
11076 {
11077   struct ix86_frame frame;
11078   HOST_WIDE_INT allocate;
11079   unsigned HOST_WIDE_INT args_size;
11080   rtx label, limit, current, jump_insn, allocate_rtx, call_insn, call_fusage;
11081   rtx scratch_reg = NULL_RTX;
11082   rtx varargs_label = NULL_RTX;
11083   rtx fn;
11084
11085   gcc_assert (flag_split_stack && reload_completed);
11086
11087   ix86_finalize_stack_realign_flags ();
11088   ix86_compute_frame_layout (&frame);
11089   allocate = frame.stack_pointer_offset - INCOMING_FRAME_SP_OFFSET;
11090
11091   /* This is the label we will branch to if we have enough stack
11092      space.  We expect the basic block reordering pass to reverse this
11093      branch if optimizing, so that we branch in the unlikely case.  */
11094   label = gen_label_rtx ();
11095
11096   /* We need to compare the stack pointer minus the frame size with
11097      the stack boundary in the TCB.  The stack boundary always gives
11098      us SPLIT_STACK_AVAILABLE bytes, so if we need less than that we
11099      can compare directly.  Otherwise we need to do an addition.  */
11100
11101   limit = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
11102                           UNSPEC_STACK_CHECK);
11103   limit = gen_rtx_CONST (Pmode, limit);
11104   limit = gen_rtx_MEM (Pmode, limit);
11105   if (allocate < SPLIT_STACK_AVAILABLE)
11106     current = stack_pointer_rtx;
11107   else
11108     {
11109       unsigned int scratch_regno;
11110       rtx offset;
11111
11112       /* We need a scratch register to hold the stack pointer minus
11113          the required frame size.  Since this is the very start of the
11114          function, the scratch register can be any caller-saved
11115          register which is not used for parameters.  */
11116       offset = GEN_INT (- allocate);
11117       scratch_regno = split_stack_prologue_scratch_regno ();
11118       if (scratch_regno == INVALID_REGNUM)
11119         return;
11120       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
11121       if (!TARGET_64BIT || x86_64_immediate_operand (offset, Pmode))
11122         {
11123           /* We don't use ix86_gen_add3 in this case because it will
11124              want to split to lea, but when not optimizing the insn
11125              will not be split after this point.  */
11126           emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11127                                   gen_rtx_PLUS (Pmode, stack_pointer_rtx,
11128                                                 offset)));
11129         }
11130       else
11131         {
11132           emit_move_insn (scratch_reg, offset);
11133           emit_insn (gen_adddi3 (scratch_reg, scratch_reg,
11134                                  stack_pointer_rtx));
11135         }
11136       current = scratch_reg;
11137     }
11138
11139   ix86_expand_branch (GEU, current, limit, label);
11140   jump_insn = get_last_insn ();
11141   JUMP_LABEL (jump_insn) = label;
11142
11143   /* Mark the jump as very likely to be taken.  */
11144   add_reg_note (jump_insn, REG_BR_PROB,
11145                 GEN_INT (REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100));
11146
11147   if (split_stack_fn == NULL_RTX)
11148     split_stack_fn = gen_rtx_SYMBOL_REF (Pmode, "__morestack");
11149   fn = split_stack_fn;
11150
11151   /* Get more stack space.  We pass in the desired stack space and the
11152      size of the arguments to copy to the new stack.  In 32-bit mode
11153      we push the parameters; __morestack will return on a new stack
11154      anyhow.  In 64-bit mode we pass the parameters in r10 and
11155      r11.  */
11156   allocate_rtx = GEN_INT (allocate);
11157   args_size = crtl->args.size >= 0 ? crtl->args.size : 0;
11158   call_fusage = NULL_RTX;
11159   if (TARGET_64BIT)
11160     {
11161       rtx reg10, reg11;
11162
11163       reg10 = gen_rtx_REG (Pmode, R10_REG);
11164       reg11 = gen_rtx_REG (Pmode, R11_REG);
11165
11166       /* If this function uses a static chain, it will be in %r10.
11167          Preserve it across the call to __morestack.  */
11168       if (DECL_STATIC_CHAIN (cfun->decl))
11169         {
11170           rtx rax;
11171
11172           rax = gen_rtx_REG (Pmode, AX_REG);
11173           emit_move_insn (rax, reg10);
11174           use_reg (&call_fusage, rax);
11175         }
11176
11177       if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
11178         {
11179           HOST_WIDE_INT argval;
11180
11181           /* When using the large model we need to load the address
11182              into a register, and we've run out of registers.  So we
11183              switch to a different calling convention, and we call a
11184              different function: __morestack_large.  We pass the
11185              argument size in the upper 32 bits of r10 and pass the
11186              frame size in the lower 32 bits.  */
11187           gcc_assert ((allocate & (HOST_WIDE_INT) 0xffffffff) == allocate);
11188           gcc_assert ((args_size & 0xffffffff) == args_size);
11189
11190           if (split_stack_fn_large == NULL_RTX)
11191             split_stack_fn_large =
11192               gen_rtx_SYMBOL_REF (Pmode, "__morestack_large_model");
11193
11194           if (ix86_cmodel == CM_LARGE_PIC)
11195             {
11196               rtx label, x;
11197
11198               label = gen_label_rtx ();
11199               emit_label (label);
11200               LABEL_PRESERVE_P (label) = 1;
11201               emit_insn (gen_set_rip_rex64 (reg10, label));
11202               emit_insn (gen_set_got_offset_rex64 (reg11, label));
11203               emit_insn (gen_adddi3 (reg10, reg10, reg11));
11204               x = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, split_stack_fn_large),
11205                                   UNSPEC_GOT);
11206               x = gen_rtx_CONST (Pmode, x);
11207               emit_move_insn (reg11, x);
11208               x = gen_rtx_PLUS (Pmode, reg10, reg11);
11209               x = gen_const_mem (Pmode, x);
11210               emit_move_insn (reg11, x);
11211             }
11212           else
11213             emit_move_insn (reg11, split_stack_fn_large);
11214
11215           fn = reg11;
11216
11217           argval = ((args_size << 16) << 16) + allocate;
11218           emit_move_insn (reg10, GEN_INT (argval));
11219         }
11220       else
11221         {
11222           emit_move_insn (reg10, allocate_rtx);
11223           emit_move_insn (reg11, GEN_INT (args_size));
11224           use_reg (&call_fusage, reg11);
11225         }
11226
11227       use_reg (&call_fusage, reg10);
11228     }
11229   else
11230     {
11231       emit_insn (gen_push (GEN_INT (args_size)));
11232       emit_insn (gen_push (allocate_rtx));
11233     }
11234   call_insn = ix86_expand_call (NULL_RTX, gen_rtx_MEM (QImode, fn),
11235                                 GEN_INT (UNITS_PER_WORD), constm1_rtx,
11236                                 NULL_RTX, false);
11237   add_function_usage_to (call_insn, call_fusage);
11238
11239   /* In order to make call/return prediction work right, we now need
11240      to execute a return instruction.  See
11241      libgcc/config/i386/morestack.S for the details on how this works.
11242
11243      For flow purposes gcc must not see this as a return
11244      instruction--we need control flow to continue at the subsequent
11245      label.  Therefore, we use an unspec.  */
11246   gcc_assert (crtl->args.pops_args < 65536);
11247   emit_insn (gen_split_stack_return (GEN_INT (crtl->args.pops_args)));
11248
11249   /* If we are in 64-bit mode and this function uses a static chain,
11250      we saved %r10 in %rax before calling _morestack.  */
11251   if (TARGET_64BIT && DECL_STATIC_CHAIN (cfun->decl))
11252     emit_move_insn (gen_rtx_REG (Pmode, R10_REG),
11253                     gen_rtx_REG (Pmode, AX_REG));
11254
11255   /* If this function calls va_start, we need to store a pointer to
11256      the arguments on the old stack, because they may not have been
11257      all copied to the new stack.  At this point the old stack can be
11258      found at the frame pointer value used by __morestack, because
11259      __morestack has set that up before calling back to us.  Here we
11260      store that pointer in a scratch register, and in
11261      ix86_expand_prologue we store the scratch register in a stack
11262      slot.  */
11263   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11264     {
11265       unsigned int scratch_regno;
11266       rtx frame_reg;
11267       int words;
11268
11269       scratch_regno = split_stack_prologue_scratch_regno ();
11270       scratch_reg = gen_rtx_REG (Pmode, scratch_regno);
11271       frame_reg = gen_rtx_REG (Pmode, BP_REG);
11272
11273       /* 64-bit:
11274          fp -> old fp value
11275                return address within this function
11276                return address of caller of this function
11277                stack arguments
11278          So we add three words to get to the stack arguments.
11279
11280          32-bit:
11281          fp -> old fp value
11282                return address within this function
11283                first argument to __morestack
11284                second argument to __morestack
11285                return address of caller of this function
11286                stack arguments
11287          So we add five words to get to the stack arguments.
11288       */
11289       words = TARGET_64BIT ? 3 : 5;
11290       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11291                               gen_rtx_PLUS (Pmode, frame_reg,
11292                                             GEN_INT (words * UNITS_PER_WORD))));
11293
11294       varargs_label = gen_label_rtx ();
11295       emit_jump_insn (gen_jump (varargs_label));
11296       JUMP_LABEL (get_last_insn ()) = varargs_label;
11297
11298       emit_barrier ();
11299     }
11300
11301   emit_label (label);
11302   LABEL_NUSES (label) = 1;
11303
11304   /* If this function calls va_start, we now have to set the scratch
11305      register for the case where we do not call __morestack.  In this
11306      case we need to set it based on the stack pointer.  */
11307   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11308     {
11309       emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
11310                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
11311                                             GEN_INT (UNITS_PER_WORD))));
11312
11313       emit_label (varargs_label);
11314       LABEL_NUSES (varargs_label) = 1;
11315     }
11316 }
11317
11318 /* We may have to tell the dataflow pass that the split stack prologue
11319    is initializing a scratch register.  */
11320
11321 static void
11322 ix86_live_on_entry (bitmap regs)
11323 {
11324   if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
11325     {
11326       gcc_assert (flag_split_stack);
11327       bitmap_set_bit (regs, split_stack_prologue_scratch_regno ());
11328     }
11329 }
11330 \f
11331 /* Determine if op is suitable SUBREG RTX for address.  */
11332
11333 static bool
11334 ix86_address_subreg_operand (rtx op)
11335 {
11336   enum machine_mode mode;
11337
11338   if (!REG_P (op))
11339     return false;
11340
11341   mode = GET_MODE (op);
11342
11343   if (GET_MODE_CLASS (mode) != MODE_INT)
11344     return false;
11345
11346   /* Don't allow SUBREGs that span more than a word.  It can lead to spill
11347      failures when the register is one word out of a two word structure.  */
11348   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
11349     return false;
11350
11351   /* Allow only SUBREGs of non-eliminable hard registers.  */
11352   return register_no_elim_operand (op, mode);
11353 }
11354
11355 /* Extract the parts of an RTL expression that is a valid memory address
11356    for an instruction.  Return 0 if the structure of the address is
11357    grossly off.  Return -1 if the address contains ASHIFT, so it is not
11358    strictly valid, but still used for computing length of lea instruction.  */
11359
11360 int
11361 ix86_decompose_address (rtx addr, struct ix86_address *out)
11362 {
11363   rtx base = NULL_RTX, index = NULL_RTX, disp = NULL_RTX;
11364   rtx base_reg, index_reg;
11365   HOST_WIDE_INT scale = 1;
11366   rtx scale_rtx = NULL_RTX;
11367   rtx tmp;
11368   int retval = 1;
11369   enum ix86_address_seg seg = SEG_DEFAULT;
11370
11371   /* Allow zero-extended SImode addresses,
11372      they will be emitted with addr32 prefix.  */
11373   if (TARGET_64BIT && GET_MODE (addr) == DImode)
11374     {
11375       if (GET_CODE (addr) == ZERO_EXTEND
11376           && GET_MODE (XEXP (addr, 0)) == SImode)
11377         addr = XEXP (addr, 0);
11378       else if (GET_CODE (addr) == AND
11379                && const_32bit_mask (XEXP (addr, 1), DImode))
11380         {
11381           addr = XEXP (addr, 0);
11382
11383           /* Strip subreg.  */
11384           if (GET_CODE (addr) == SUBREG
11385               && GET_MODE (SUBREG_REG (addr)) == SImode)
11386             addr = SUBREG_REG (addr);
11387         }
11388     }
11389
11390   if (REG_P (addr))
11391     base = addr;
11392   else if (GET_CODE (addr) == SUBREG)
11393     {
11394       if (ix86_address_subreg_operand (SUBREG_REG (addr)))
11395         base = addr;
11396       else
11397         return 0;
11398     }
11399   else if (GET_CODE (addr) == PLUS)
11400     {
11401       rtx addends[4], op;
11402       int n = 0, i;
11403
11404       op = addr;
11405       do
11406         {
11407           if (n >= 4)
11408             return 0;
11409           addends[n++] = XEXP (op, 1);
11410           op = XEXP (op, 0);
11411         }
11412       while (GET_CODE (op) == PLUS);
11413       if (n >= 4)
11414         return 0;
11415       addends[n] = op;
11416
11417       for (i = n; i >= 0; --i)
11418         {
11419           op = addends[i];
11420           switch (GET_CODE (op))
11421             {
11422             case MULT:
11423               if (index)
11424                 return 0;
11425               index = XEXP (op, 0);
11426               scale_rtx = XEXP (op, 1);
11427               break;
11428
11429             case ASHIFT:
11430               if (index)
11431                 return 0;
11432               index = XEXP (op, 0);
11433               tmp = XEXP (op, 1);
11434               if (!CONST_INT_P (tmp))
11435                 return 0;
11436               scale = INTVAL (tmp);
11437               if ((unsigned HOST_WIDE_INT) scale > 3)
11438                 return 0;
11439               scale = 1 << scale;
11440               break;
11441
11442             case UNSPEC:
11443               if (XINT (op, 1) == UNSPEC_TP
11444                   && TARGET_TLS_DIRECT_SEG_REFS
11445                   && seg == SEG_DEFAULT)
11446                 seg = TARGET_64BIT ? SEG_FS : SEG_GS;
11447               else
11448                 return 0;
11449               break;
11450
11451             case SUBREG:
11452               if (!ix86_address_subreg_operand (SUBREG_REG (op)))
11453                 return 0;
11454               /* FALLTHRU */
11455
11456             case REG:
11457               if (!base)
11458                 base = op;
11459               else if (!index)
11460                 index = op;
11461               else
11462                 return 0;
11463               break;
11464
11465             case CONST:
11466             case CONST_INT:
11467             case SYMBOL_REF:
11468             case LABEL_REF:
11469               if (disp)
11470                 return 0;
11471               disp = op;
11472               break;
11473
11474             default:
11475               return 0;
11476             }
11477         }
11478     }
11479   else if (GET_CODE (addr) == MULT)
11480     {
11481       index = XEXP (addr, 0);           /* index*scale */
11482       scale_rtx = XEXP (addr, 1);
11483     }
11484   else if (GET_CODE (addr) == ASHIFT)
11485     {
11486       /* We're called for lea too, which implements ashift on occasion.  */
11487       index = XEXP (addr, 0);
11488       tmp = XEXP (addr, 1);
11489       if (!CONST_INT_P (tmp))
11490         return 0;
11491       scale = INTVAL (tmp);
11492       if ((unsigned HOST_WIDE_INT) scale > 3)
11493         return 0;
11494       scale = 1 << scale;
11495       retval = -1;
11496     }
11497   else
11498     disp = addr;                        /* displacement */
11499
11500   if (index)
11501     {
11502       if (REG_P (index))
11503         ;
11504       else if (GET_CODE (index) == SUBREG
11505                && ix86_address_subreg_operand (SUBREG_REG (index)))
11506         ;
11507       else
11508         return 0;
11509     }
11510
11511   /* Extract the integral value of scale.  */
11512   if (scale_rtx)
11513     {
11514       if (!CONST_INT_P (scale_rtx))
11515         return 0;
11516       scale = INTVAL (scale_rtx);
11517     }
11518
11519   base_reg = base && GET_CODE (base) == SUBREG ? SUBREG_REG (base) : base;
11520   index_reg = index && GET_CODE (index) == SUBREG ? SUBREG_REG (index) : index;
11521
11522   /* Avoid useless 0 displacement.  */
11523   if (disp == const0_rtx && (base || index))
11524     disp = NULL_RTX;
11525
11526   /* Allow arg pointer and stack pointer as index if there is not scaling.  */
11527   if (base_reg && index_reg && scale == 1
11528       && (index_reg == arg_pointer_rtx
11529           || index_reg == frame_pointer_rtx
11530           || (REG_P (index_reg) && REGNO (index_reg) == STACK_POINTER_REGNUM)))
11531     {
11532       rtx tmp;
11533       tmp = base, base = index, index = tmp;
11534       tmp = base_reg, base_reg = index_reg, index_reg = tmp;
11535     }
11536
11537   /* Special case: %ebp cannot be encoded as a base without a displacement.
11538      Similarly %r13.  */
11539   if (!disp
11540       && base_reg
11541       && (base_reg == hard_frame_pointer_rtx
11542           || base_reg == frame_pointer_rtx
11543           || base_reg == arg_pointer_rtx
11544           || (REG_P (base_reg)
11545               && (REGNO (base_reg) == HARD_FRAME_POINTER_REGNUM
11546                   || REGNO (base_reg) == R13_REG))))
11547     disp = const0_rtx;
11548
11549   /* Special case: on K6, [%esi] makes the instruction vector decoded.
11550      Avoid this by transforming to [%esi+0].
11551      Reload calls address legitimization without cfun defined, so we need
11552      to test cfun for being non-NULL. */
11553   if (TARGET_K6 && cfun && optimize_function_for_speed_p (cfun)
11554       && base_reg && !index_reg && !disp
11555       && REG_P (base_reg) && REGNO (base_reg) == SI_REG)
11556     disp = const0_rtx;
11557
11558   /* Special case: encode reg+reg instead of reg*2.  */
11559   if (!base && index && scale == 2)
11560     base = index, base_reg = index_reg, scale = 1;
11561
11562   /* Special case: scaling cannot be encoded without base or displacement.  */
11563   if (!base && !disp && index && scale != 1)
11564     disp = const0_rtx;
11565
11566   out->base = base;
11567   out->index = index;
11568   out->disp = disp;
11569   out->scale = scale;
11570   out->seg = seg;
11571
11572   return retval;
11573 }
11574 \f
11575 /* Return cost of the memory address x.
11576    For i386, it is better to use a complex address than let gcc copy
11577    the address into a reg and make a new pseudo.  But not if the address
11578    requires to two regs - that would mean more pseudos with longer
11579    lifetimes.  */
11580 static int
11581 ix86_address_cost (rtx x, bool speed ATTRIBUTE_UNUSED)
11582 {
11583   struct ix86_address parts;
11584   int cost = 1;
11585   int ok = ix86_decompose_address (x, &parts);
11586
11587   gcc_assert (ok);
11588
11589   if (parts.base && GET_CODE (parts.base) == SUBREG)
11590     parts.base = SUBREG_REG (parts.base);
11591   if (parts.index && GET_CODE (parts.index) == SUBREG)
11592     parts.index = SUBREG_REG (parts.index);
11593
11594   /* Attempt to minimize number of registers in the address.  */
11595   if ((parts.base
11596        && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER))
11597       || (parts.index
11598           && (!REG_P (parts.index)
11599               || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)))
11600     cost++;
11601
11602   if (parts.base
11603       && (!REG_P (parts.base) || REGNO (parts.base) >= FIRST_PSEUDO_REGISTER)
11604       && parts.index
11605       && (!REG_P (parts.index) || REGNO (parts.index) >= FIRST_PSEUDO_REGISTER)
11606       && parts.base != parts.index)
11607     cost++;
11608
11609   /* AMD-K6 don't like addresses with ModR/M set to 00_xxx_100b,
11610      since it's predecode logic can't detect the length of instructions
11611      and it degenerates to vector decoded.  Increase cost of such
11612      addresses here.  The penalty is minimally 2 cycles.  It may be worthwhile
11613      to split such addresses or even refuse such addresses at all.
11614
11615      Following addressing modes are affected:
11616       [base+scale*index]
11617       [scale*index+disp]
11618       [base+index]
11619
11620      The first and last case  may be avoidable by explicitly coding the zero in
11621      memory address, but I don't have AMD-K6 machine handy to check this
11622      theory.  */
11623
11624   if (TARGET_K6
11625       && ((!parts.disp && parts.base && parts.index && parts.scale != 1)
11626           || (parts.disp && !parts.base && parts.index && parts.scale != 1)
11627           || (!parts.disp && parts.base && parts.index && parts.scale == 1)))
11628     cost += 10;
11629
11630   return cost;
11631 }
11632 \f
11633 /* Allow {LABEL | SYMBOL}_REF - SYMBOL_REF-FOR-PICBASE for Mach-O as
11634    this is used for to form addresses to local data when -fPIC is in
11635    use.  */
11636
11637 static bool
11638 darwin_local_data_pic (rtx disp)
11639 {
11640   return (GET_CODE (disp) == UNSPEC
11641           && XINT (disp, 1) == UNSPEC_MACHOPIC_OFFSET);
11642 }
11643
11644 /* Determine if a given RTX is a valid constant.  We already know this
11645    satisfies CONSTANT_P.  */
11646
11647 static bool
11648 ix86_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
11649 {
11650   switch (GET_CODE (x))
11651     {
11652     case CONST:
11653       x = XEXP (x, 0);
11654
11655       if (GET_CODE (x) == PLUS)
11656         {
11657           if (!CONST_INT_P (XEXP (x, 1)))
11658             return false;
11659           x = XEXP (x, 0);
11660         }
11661
11662       if (TARGET_MACHO && darwin_local_data_pic (x))
11663         return true;
11664
11665       /* Only some unspecs are valid as "constants".  */
11666       if (GET_CODE (x) == UNSPEC)
11667         switch (XINT (x, 1))
11668           {
11669           case UNSPEC_GOT:
11670           case UNSPEC_GOTOFF:
11671           case UNSPEC_PLTOFF:
11672             return TARGET_64BIT;
11673           case UNSPEC_TPOFF:
11674           case UNSPEC_NTPOFF:
11675             x = XVECEXP (x, 0, 0);
11676             return (GET_CODE (x) == SYMBOL_REF
11677                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11678           case UNSPEC_DTPOFF:
11679             x = XVECEXP (x, 0, 0);
11680             return (GET_CODE (x) == SYMBOL_REF
11681                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC);
11682           default:
11683             return false;
11684           }
11685
11686       /* We must have drilled down to a symbol.  */
11687       if (GET_CODE (x) == LABEL_REF)
11688         return true;
11689       if (GET_CODE (x) != SYMBOL_REF)
11690         return false;
11691       /* FALLTHRU */
11692
11693     case SYMBOL_REF:
11694       /* TLS symbols are never valid.  */
11695       if (SYMBOL_REF_TLS_MODEL (x))
11696         return false;
11697
11698       /* DLLIMPORT symbols are never valid.  */
11699       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
11700           && SYMBOL_REF_DLLIMPORT_P (x))
11701         return false;
11702
11703 #if TARGET_MACHO
11704       /* mdynamic-no-pic */
11705       if (MACHO_DYNAMIC_NO_PIC_P)
11706         return machopic_symbol_defined_p (x);
11707 #endif
11708       break;
11709
11710     case CONST_DOUBLE:
11711       if (GET_MODE (x) == TImode
11712           && x != CONST0_RTX (TImode)
11713           && !TARGET_64BIT)
11714         return false;
11715       break;
11716
11717     case CONST_VECTOR:
11718       if (!standard_sse_constant_p (x))
11719         return false;
11720
11721     default:
11722       break;
11723     }
11724
11725   /* Otherwise we handle everything else in the move patterns.  */
11726   return true;
11727 }
11728
11729 /* Determine if it's legal to put X into the constant pool.  This
11730    is not possible for the address of thread-local symbols, which
11731    is checked above.  */
11732
11733 static bool
11734 ix86_cannot_force_const_mem (enum machine_mode mode, rtx x)
11735 {
11736   /* We can always put integral constants and vectors in memory.  */
11737   switch (GET_CODE (x))
11738     {
11739     case CONST_INT:
11740     case CONST_DOUBLE:
11741     case CONST_VECTOR:
11742       return false;
11743
11744     default:
11745       break;
11746     }
11747   return !ix86_legitimate_constant_p (mode, x);
11748 }
11749
11750
11751 /* Nonzero if the constant value X is a legitimate general operand
11752    when generating PIC code.  It is given that flag_pic is on and
11753    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
11754
11755 bool
11756 legitimate_pic_operand_p (rtx x)
11757 {
11758   rtx inner;
11759
11760   switch (GET_CODE (x))
11761     {
11762     case CONST:
11763       inner = XEXP (x, 0);
11764       if (GET_CODE (inner) == PLUS
11765           && CONST_INT_P (XEXP (inner, 1)))
11766         inner = XEXP (inner, 0);
11767
11768       /* Only some unspecs are valid as "constants".  */
11769       if (GET_CODE (inner) == UNSPEC)
11770         switch (XINT (inner, 1))
11771           {
11772           case UNSPEC_GOT:
11773           case UNSPEC_GOTOFF:
11774           case UNSPEC_PLTOFF:
11775             return TARGET_64BIT;
11776           case UNSPEC_TPOFF:
11777             x = XVECEXP (inner, 0, 0);
11778             return (GET_CODE (x) == SYMBOL_REF
11779                     && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_EXEC);
11780           case UNSPEC_MACHOPIC_OFFSET:
11781             return legitimate_pic_address_disp_p (x);
11782           default:
11783             return false;
11784           }
11785       /* FALLTHRU */
11786
11787     case SYMBOL_REF:
11788     case LABEL_REF:
11789       return legitimate_pic_address_disp_p (x);
11790
11791     default:
11792       return true;
11793     }
11794 }
11795
11796 /* Determine if a given CONST RTX is a valid memory displacement
11797    in PIC mode.  */
11798
11799 bool
11800 legitimate_pic_address_disp_p (rtx disp)
11801 {
11802   bool saw_plus;
11803
11804   /* In 64bit mode we can allow direct addresses of symbols and labels
11805      when they are not dynamic symbols.  */
11806   if (TARGET_64BIT)
11807     {
11808       rtx op0 = disp, op1;
11809
11810       switch (GET_CODE (disp))
11811         {
11812         case LABEL_REF:
11813           return true;
11814
11815         case CONST:
11816           if (GET_CODE (XEXP (disp, 0)) != PLUS)
11817             break;
11818           op0 = XEXP (XEXP (disp, 0), 0);
11819           op1 = XEXP (XEXP (disp, 0), 1);
11820           if (!CONST_INT_P (op1)
11821               || INTVAL (op1) >= 16*1024*1024
11822               || INTVAL (op1) < -16*1024*1024)
11823             break;
11824           if (GET_CODE (op0) == LABEL_REF)
11825             return true;
11826           if (GET_CODE (op0) == CONST
11827               && GET_CODE (XEXP (op0, 0)) == UNSPEC
11828               && XINT (XEXP (op0, 0), 1) == UNSPEC_PCREL)
11829             return true;
11830           if (GET_CODE (op0) == UNSPEC
11831               && XINT (op0, 1) == UNSPEC_PCREL)
11832             return true;
11833           if (GET_CODE (op0) != SYMBOL_REF)
11834             break;
11835           /* FALLTHRU */
11836
11837         case SYMBOL_REF:
11838           /* TLS references should always be enclosed in UNSPEC.  */
11839           if (SYMBOL_REF_TLS_MODEL (op0))
11840             return false;
11841           if (!SYMBOL_REF_FAR_ADDR_P (op0) && SYMBOL_REF_LOCAL_P (op0)
11842               && ix86_cmodel != CM_LARGE_PIC)
11843             return true;
11844           break;
11845
11846         default:
11847           break;
11848         }
11849     }
11850   if (GET_CODE (disp) != CONST)
11851     return false;
11852   disp = XEXP (disp, 0);
11853
11854   if (TARGET_64BIT)
11855     {
11856       /* We are unsafe to allow PLUS expressions.  This limit allowed distance
11857          of GOT tables.  We should not need these anyway.  */
11858       if (GET_CODE (disp) != UNSPEC
11859           || (XINT (disp, 1) != UNSPEC_GOTPCREL
11860               && XINT (disp, 1) != UNSPEC_GOTOFF
11861               && XINT (disp, 1) != UNSPEC_PCREL
11862               && XINT (disp, 1) != UNSPEC_PLTOFF))
11863         return false;
11864
11865       if (GET_CODE (XVECEXP (disp, 0, 0)) != SYMBOL_REF
11866           && GET_CODE (XVECEXP (disp, 0, 0)) != LABEL_REF)
11867         return false;
11868       return true;
11869     }
11870
11871   saw_plus = false;
11872   if (GET_CODE (disp) == PLUS)
11873     {
11874       if (!CONST_INT_P (XEXP (disp, 1)))
11875         return false;
11876       disp = XEXP (disp, 0);
11877       saw_plus = true;
11878     }
11879
11880   if (TARGET_MACHO && darwin_local_data_pic (disp))
11881     return true;
11882
11883   if (GET_CODE (disp) != UNSPEC)
11884     return false;
11885
11886   switch (XINT (disp, 1))
11887     {
11888     case UNSPEC_GOT:
11889       if (saw_plus)
11890         return false;
11891       /* We need to check for both symbols and labels because VxWorks loads
11892          text labels with @GOT rather than @GOTOFF.  See gotoff_operand for
11893          details.  */
11894       return (GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11895               || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF);
11896     case UNSPEC_GOTOFF:
11897       /* Refuse GOTOFF in 64bit mode since it is always 64bit when used.
11898          While ABI specify also 32bit relocation but we don't produce it in
11899          small PIC model at all.  */
11900       if ((GET_CODE (XVECEXP (disp, 0, 0)) == SYMBOL_REF
11901            || GET_CODE (XVECEXP (disp, 0, 0)) == LABEL_REF)
11902           && !TARGET_64BIT)
11903         return gotoff_operand (XVECEXP (disp, 0, 0), Pmode);
11904       return false;
11905     case UNSPEC_GOTTPOFF:
11906     case UNSPEC_GOTNTPOFF:
11907     case UNSPEC_INDNTPOFF:
11908       if (saw_plus)
11909         return false;
11910       disp = XVECEXP (disp, 0, 0);
11911       return (GET_CODE (disp) == SYMBOL_REF
11912               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_INITIAL_EXEC);
11913     case UNSPEC_NTPOFF:
11914       disp = XVECEXP (disp, 0, 0);
11915       return (GET_CODE (disp) == SYMBOL_REF
11916               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_EXEC);
11917     case UNSPEC_DTPOFF:
11918       disp = XVECEXP (disp, 0, 0);
11919       return (GET_CODE (disp) == SYMBOL_REF
11920               && SYMBOL_REF_TLS_MODEL (disp) == TLS_MODEL_LOCAL_DYNAMIC);
11921     }
11922
11923   return false;
11924 }
11925
11926 /* Recognizes RTL expressions that are valid memory addresses for an
11927    instruction.  The MODE argument is the machine mode for the MEM
11928    expression that wants to use this address.
11929
11930    It only recognizes address in canonical form.  LEGITIMIZE_ADDRESS should
11931    convert common non-canonical forms to canonical form so that they will
11932    be recognized.  */
11933
11934 static bool
11935 ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
11936                            rtx addr, bool strict)
11937 {
11938   struct ix86_address parts;
11939   rtx base, index, disp;
11940   HOST_WIDE_INT scale;
11941
11942   /* Since constant address in x32 is signed extended to 64bit,
11943      we have to prevent addresses from 0x80000000 to 0xffffffff.  */
11944   if (TARGET_X32
11945       && CONST_INT_P (addr)
11946       && INTVAL (addr) < 0)
11947     return false;
11948
11949   if (ix86_decompose_address (addr, &parts) <= 0)
11950     /* Decomposition failed.  */
11951     return false;
11952
11953   base = parts.base;
11954   index = parts.index;
11955   disp = parts.disp;
11956   scale = parts.scale;
11957
11958   /* Validate base register.  */
11959   if (base)
11960     {
11961       rtx reg;
11962
11963       if (REG_P (base))
11964         reg = base;
11965       else if (GET_CODE (base) == SUBREG && REG_P (SUBREG_REG (base)))
11966         reg = SUBREG_REG (base);
11967       else
11968         /* Base is not a register.  */
11969         return false;
11970
11971       if (GET_MODE (base) != SImode && GET_MODE (base) != DImode)
11972         return false;
11973
11974       if ((strict && ! REG_OK_FOR_BASE_STRICT_P (reg))
11975           || (! strict && ! REG_OK_FOR_BASE_NONSTRICT_P (reg)))
11976         /* Base is not valid.  */
11977         return false;
11978     }
11979
11980   /* Validate index register.  */
11981   if (index)
11982     {
11983       rtx reg;
11984
11985       if (REG_P (index))
11986         reg = index;
11987       else if (GET_CODE (index) == SUBREG && REG_P (SUBREG_REG (index)))
11988         reg = SUBREG_REG (index);
11989       else
11990         /* Index is not a register.  */
11991         return false;
11992
11993       if (GET_MODE (index) != SImode && GET_MODE (index) != DImode)
11994         return false;
11995
11996       if ((strict && ! REG_OK_FOR_INDEX_STRICT_P (reg))
11997           || (! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P (reg)))
11998         /* Index is not valid.  */
11999         return false;
12000     }
12001
12002   /* Index and base should have the same mode.  */
12003   if (base && index
12004       && GET_MODE (base) != GET_MODE (index))
12005     return false;
12006
12007   /* Validate scale factor.  */
12008   if (scale != 1)
12009     {
12010       if (!index)
12011         /* Scale without index.  */
12012         return false;
12013
12014       if (scale != 2 && scale != 4 && scale != 8)
12015         /* Scale is not a valid multiplier.  */
12016         return false;
12017     }
12018
12019   /* Validate displacement.  */
12020   if (disp)
12021     {
12022       if (GET_CODE (disp) == CONST
12023           && GET_CODE (XEXP (disp, 0)) == UNSPEC
12024           && XINT (XEXP (disp, 0), 1) != UNSPEC_MACHOPIC_OFFSET)
12025         switch (XINT (XEXP (disp, 0), 1))
12026           {
12027           /* Refuse GOTOFF and GOT in 64bit mode since it is always 64bit when
12028              used.  While ABI specify also 32bit relocations, we don't produce
12029              them at all and use IP relative instead.  */
12030           case UNSPEC_GOT:
12031           case UNSPEC_GOTOFF:
12032             gcc_assert (flag_pic);
12033             if (!TARGET_64BIT)
12034               goto is_legitimate_pic;
12035
12036             /* 64bit address unspec.  */
12037             return false;
12038
12039           case UNSPEC_GOTPCREL:
12040           case UNSPEC_PCREL:
12041             gcc_assert (flag_pic);
12042             goto is_legitimate_pic;
12043
12044           case UNSPEC_GOTTPOFF:
12045           case UNSPEC_GOTNTPOFF:
12046           case UNSPEC_INDNTPOFF:
12047           case UNSPEC_NTPOFF:
12048           case UNSPEC_DTPOFF:
12049             break;
12050
12051           case UNSPEC_STACK_CHECK:
12052             gcc_assert (flag_split_stack);
12053             break;
12054
12055           default:
12056             /* Invalid address unspec.  */
12057             return false;
12058           }
12059
12060       else if (SYMBOLIC_CONST (disp)
12061                && (flag_pic
12062                    || (TARGET_MACHO
12063 #if TARGET_MACHO
12064                        && MACHOPIC_INDIRECT
12065                        && !machopic_operand_p (disp)
12066 #endif
12067                )))
12068         {
12069
12070         is_legitimate_pic:
12071           if (TARGET_64BIT && (index || base))
12072             {
12073               /* foo@dtpoff(%rX) is ok.  */
12074               if (GET_CODE (disp) != CONST
12075                   || GET_CODE (XEXP (disp, 0)) != PLUS
12076                   || GET_CODE (XEXP (XEXP (disp, 0), 0)) != UNSPEC
12077                   || !CONST_INT_P (XEXP (XEXP (disp, 0), 1))
12078                   || (XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_DTPOFF
12079                       && XINT (XEXP (XEXP (disp, 0), 0), 1) != UNSPEC_NTPOFF))
12080                 /* Non-constant pic memory reference.  */
12081                 return false;
12082             }
12083           else if ((!TARGET_MACHO || flag_pic)
12084                     && ! legitimate_pic_address_disp_p (disp))
12085             /* Displacement is an invalid pic construct.  */
12086             return false;
12087 #if TARGET_MACHO
12088           else if (MACHO_DYNAMIC_NO_PIC_P
12089                    && !ix86_legitimate_constant_p (Pmode, disp))
12090             /* displacment must be referenced via non_lazy_pointer */
12091             return false;
12092 #endif
12093
12094           /* This code used to verify that a symbolic pic displacement
12095              includes the pic_offset_table_rtx register.
12096
12097              While this is good idea, unfortunately these constructs may
12098              be created by "adds using lea" optimization for incorrect
12099              code like:
12100
12101              int a;
12102              int foo(int i)
12103                {
12104                  return *(&a+i);
12105                }
12106
12107              This code is nonsensical, but results in addressing
12108              GOT table with pic_offset_table_rtx base.  We can't
12109              just refuse it easily, since it gets matched by
12110              "addsi3" pattern, that later gets split to lea in the
12111              case output register differs from input.  While this
12112              can be handled by separate addsi pattern for this case
12113              that never results in lea, this seems to be easier and
12114              correct fix for crash to disable this test.  */
12115         }
12116       else if (GET_CODE (disp) != LABEL_REF
12117                && !CONST_INT_P (disp)
12118                && (GET_CODE (disp) != CONST
12119                    || !ix86_legitimate_constant_p (Pmode, disp))
12120                && (GET_CODE (disp) != SYMBOL_REF
12121                    || !ix86_legitimate_constant_p (Pmode, disp)))
12122         /* Displacement is not constant.  */
12123         return false;
12124       else if (TARGET_64BIT
12125                && !x86_64_immediate_operand (disp, VOIDmode))
12126         /* Displacement is out of range.  */
12127         return false;
12128     }
12129
12130   /* Everything looks valid.  */
12131   return true;
12132 }
12133
12134 /* Determine if a given RTX is a valid constant address.  */
12135
12136 bool
12137 constant_address_p (rtx x)
12138 {
12139   return CONSTANT_P (x) && ix86_legitimate_address_p (Pmode, x, 1);
12140 }
12141 \f
12142 /* Return a unique alias set for the GOT.  */
12143
12144 static alias_set_type
12145 ix86_GOT_alias_set (void)
12146 {
12147   static alias_set_type set = -1;
12148   if (set == -1)
12149     set = new_alias_set ();
12150   return set;
12151 }
12152
12153 /* Return a legitimate reference for ORIG (an address) using the
12154    register REG.  If REG is 0, a new pseudo is generated.
12155
12156    There are two types of references that must be handled:
12157
12158    1. Global data references must load the address from the GOT, via
12159       the PIC reg.  An insn is emitted to do this load, and the reg is
12160       returned.
12161
12162    2. Static data references, constant pool addresses, and code labels
12163       compute the address as an offset from the GOT, whose base is in
12164       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
12165       differentiate them from global data objects.  The returned
12166       address is the PIC reg + an unspec constant.
12167
12168    TARGET_LEGITIMATE_ADDRESS_P rejects symbolic references unless the PIC
12169    reg also appears in the address.  */
12170
12171 static rtx
12172 legitimize_pic_address (rtx orig, rtx reg)
12173 {
12174   rtx addr = orig;
12175   rtx new_rtx = orig;
12176   rtx base;
12177
12178 #if TARGET_MACHO
12179   if (TARGET_MACHO && !TARGET_64BIT)
12180     {
12181       if (reg == 0)
12182         reg = gen_reg_rtx (Pmode);
12183       /* Use the generic Mach-O PIC machinery.  */
12184       return machopic_legitimize_pic_address (orig, GET_MODE (orig), reg);
12185     }
12186 #endif
12187
12188   if (TARGET_64BIT && legitimate_pic_address_disp_p (addr))
12189     new_rtx = addr;
12190   else if (TARGET_64BIT
12191            && ix86_cmodel != CM_SMALL_PIC
12192            && gotoff_operand (addr, Pmode))
12193     {
12194       rtx tmpreg;
12195       /* This symbol may be referenced via a displacement from the PIC
12196          base address (@GOTOFF).  */
12197
12198       if (reload_in_progress)
12199         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12200       if (GET_CODE (addr) == CONST)
12201         addr = XEXP (addr, 0);
12202       if (GET_CODE (addr) == PLUS)
12203           {
12204             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
12205                                       UNSPEC_GOTOFF);
12206             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
12207           }
12208         else
12209           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
12210       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12211       if (!reg)
12212         tmpreg = gen_reg_rtx (Pmode);
12213       else
12214         tmpreg = reg;
12215       emit_move_insn (tmpreg, new_rtx);
12216
12217       if (reg != 0)
12218         {
12219           new_rtx = expand_simple_binop (Pmode, PLUS, reg, pic_offset_table_rtx,
12220                                          tmpreg, 1, OPTAB_DIRECT);
12221           new_rtx = reg;
12222         }
12223       else new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmpreg);
12224     }
12225   else if (!TARGET_64BIT && gotoff_operand (addr, Pmode))
12226     {
12227       /* This symbol may be referenced via a displacement from the PIC
12228          base address (@GOTOFF).  */
12229
12230       if (reload_in_progress)
12231         df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12232       if (GET_CODE (addr) == CONST)
12233         addr = XEXP (addr, 0);
12234       if (GET_CODE (addr) == PLUS)
12235           {
12236             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (addr, 0)),
12237                                       UNSPEC_GOTOFF);
12238             new_rtx = gen_rtx_PLUS (Pmode, new_rtx, XEXP (addr, 1));
12239           }
12240         else
12241           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
12242       new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12243       new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12244
12245       if (reg != 0)
12246         {
12247           emit_move_insn (reg, new_rtx);
12248           new_rtx = reg;
12249         }
12250     }
12251   else if ((GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (addr) == 0)
12252            /* We can't use @GOTOFF for text labels on VxWorks;
12253               see gotoff_operand.  */
12254            || (TARGET_VXWORKS_RTP && GET_CODE (addr) == LABEL_REF))
12255     {
12256       if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12257         {
12258           if (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (addr))
12259             return legitimize_dllimport_symbol (addr, true);
12260           if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
12261               && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF
12262               && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (addr, 0), 0)))
12263             {
12264               rtx t = legitimize_dllimport_symbol (XEXP (XEXP (addr, 0), 0), true);
12265               return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (addr, 0), 1));
12266             }
12267         }
12268
12269       /* For x64 PE-COFF there is no GOT table.  So we use address
12270          directly.  */
12271       if (TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12272       {
12273           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_PCREL);
12274           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12275
12276           if (reg == 0)
12277             reg = gen_reg_rtx (Pmode);
12278           emit_move_insn (reg, new_rtx);
12279           new_rtx = reg;
12280       }
12281       else if (TARGET_64BIT && ix86_cmodel != CM_LARGE_PIC)
12282         {
12283           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTPCREL);
12284           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12285           new_rtx = gen_const_mem (Pmode, new_rtx);
12286           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12287
12288           if (reg == 0)
12289             reg = gen_reg_rtx (Pmode);
12290           /* Use directly gen_movsi, otherwise the address is loaded
12291              into register for CSE.  We don't want to CSE this addresses,
12292              instead we CSE addresses from the GOT table, so skip this.  */
12293           emit_insn (gen_movsi (reg, new_rtx));
12294           new_rtx = reg;
12295         }
12296       else
12297         {
12298           /* This symbol must be referenced via a load from the
12299              Global Offset Table (@GOT).  */
12300
12301           if (reload_in_progress)
12302             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12303           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
12304           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12305           if (TARGET_64BIT)
12306             new_rtx = force_reg (Pmode, new_rtx);
12307           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12308           new_rtx = gen_const_mem (Pmode, new_rtx);
12309           set_mem_alias_set (new_rtx, ix86_GOT_alias_set ());
12310
12311           if (reg == 0)
12312             reg = gen_reg_rtx (Pmode);
12313           emit_move_insn (reg, new_rtx);
12314           new_rtx = reg;
12315         }
12316     }
12317   else
12318     {
12319       if (CONST_INT_P (addr)
12320           && !x86_64_immediate_operand (addr, VOIDmode))
12321         {
12322           if (reg)
12323             {
12324               emit_move_insn (reg, addr);
12325               new_rtx = reg;
12326             }
12327           else
12328             new_rtx = force_reg (Pmode, addr);
12329         }
12330       else if (GET_CODE (addr) == CONST)
12331         {
12332           addr = XEXP (addr, 0);
12333
12334           /* We must match stuff we generate before.  Assume the only
12335              unspecs that can get here are ours.  Not that we could do
12336              anything with them anyway....  */
12337           if (GET_CODE (addr) == UNSPEC
12338               || (GET_CODE (addr) == PLUS
12339                   && GET_CODE (XEXP (addr, 0)) == UNSPEC))
12340             return orig;
12341           gcc_assert (GET_CODE (addr) == PLUS);
12342         }
12343       if (GET_CODE (addr) == PLUS)
12344         {
12345           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
12346
12347           /* Check first to see if this is a constant offset from a @GOTOFF
12348              symbol reference.  */
12349           if (gotoff_operand (op0, Pmode)
12350               && CONST_INT_P (op1))
12351             {
12352               if (!TARGET_64BIT)
12353                 {
12354                   if (reload_in_progress)
12355                     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12356                   new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
12357                                             UNSPEC_GOTOFF);
12358                   new_rtx = gen_rtx_PLUS (Pmode, new_rtx, op1);
12359                   new_rtx = gen_rtx_CONST (Pmode, new_rtx);
12360                   new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
12361
12362                   if (reg != 0)
12363                     {
12364                       emit_move_insn (reg, new_rtx);
12365                       new_rtx = reg;
12366                     }
12367                 }
12368               else
12369                 {
12370                   if (INTVAL (op1) < -16*1024*1024
12371                       || INTVAL (op1) >= 16*1024*1024)
12372                     {
12373                       if (!x86_64_immediate_operand (op1, Pmode))
12374                         op1 = force_reg (Pmode, op1);
12375                       new_rtx = gen_rtx_PLUS (Pmode, force_reg (Pmode, op0), op1);
12376                     }
12377                 }
12378             }
12379           else
12380             {
12381               base = legitimize_pic_address (XEXP (addr, 0), reg);
12382               new_rtx  = legitimize_pic_address (XEXP (addr, 1),
12383                                                  base == reg ? NULL_RTX : reg);
12384
12385               if (CONST_INT_P (new_rtx))
12386                 new_rtx = plus_constant (base, INTVAL (new_rtx));
12387               else
12388                 {
12389                   if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1)))
12390                     {
12391                       base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0));
12392                       new_rtx = XEXP (new_rtx, 1);
12393                     }
12394                   new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx);
12395                 }
12396             }
12397         }
12398     }
12399   return new_rtx;
12400 }
12401 \f
12402 /* Load the thread pointer.  If TO_REG is true, force it into a register.  */
12403
12404 static rtx
12405 get_thread_pointer (bool to_reg)
12406 {
12407   rtx tp = gen_rtx_UNSPEC (ptr_mode, gen_rtvec (1, const0_rtx), UNSPEC_TP);
12408
12409   if (GET_MODE (tp) != Pmode)
12410     tp = convert_to_mode (Pmode, tp, 1);
12411
12412   if (to_reg)
12413     tp = copy_addr_to_reg (tp);
12414
12415   return tp;
12416 }
12417
12418 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
12419
12420 static GTY(()) rtx ix86_tls_symbol;
12421
12422 static rtx
12423 ix86_tls_get_addr (void)
12424 {
12425   if (!ix86_tls_symbol)
12426     {
12427       const char *sym
12428         = ((TARGET_ANY_GNU_TLS && !TARGET_64BIT)
12429            ? "___tls_get_addr" : "__tls_get_addr");
12430
12431       ix86_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, sym);
12432     }
12433
12434   return ix86_tls_symbol;
12435 }
12436
12437 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol.  */
12438
12439 static GTY(()) rtx ix86_tls_module_base_symbol;
12440
12441 rtx
12442 ix86_tls_module_base (void)
12443 {
12444   if (!ix86_tls_module_base_symbol)
12445     {
12446       ix86_tls_module_base_symbol
12447         = gen_rtx_SYMBOL_REF (Pmode, "_TLS_MODULE_BASE_");
12448
12449       SYMBOL_REF_FLAGS (ix86_tls_module_base_symbol)
12450         |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT;
12451     }
12452
12453   return ix86_tls_module_base_symbol;
12454 }
12455
12456 /* A subroutine of ix86_legitimize_address and ix86_expand_move.  FOR_MOV is
12457    false if we expect this to be used for a memory address and true if
12458    we expect to load the address into a register.  */
12459
12460 static rtx
12461 legitimize_tls_address (rtx x, enum tls_model model, bool for_mov)
12462 {
12463   rtx dest, base, off;
12464   rtx pic = NULL_RTX, tp = NULL_RTX;
12465   int type;
12466
12467   switch (model)
12468     {
12469     case TLS_MODEL_GLOBAL_DYNAMIC:
12470       dest = gen_reg_rtx (Pmode);
12471
12472       if (!TARGET_64BIT)
12473         {
12474           if (flag_pic)
12475             pic = pic_offset_table_rtx;
12476           else
12477             {
12478               pic = gen_reg_rtx (Pmode);
12479               emit_insn (gen_set_got (pic));
12480             }
12481         }
12482
12483       if (TARGET_GNU2_TLS)
12484         {
12485           if (TARGET_64BIT)
12486             emit_insn (gen_tls_dynamic_gnu2_64 (dest, x));
12487           else
12488             emit_insn (gen_tls_dynamic_gnu2_32 (dest, x, pic));
12489
12490           tp = get_thread_pointer (true);
12491           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, tp, dest));
12492
12493           set_unique_reg_note (get_last_insn (), REG_EQUAL, x);
12494         }
12495       else
12496         {
12497           rtx caddr = ix86_tls_get_addr ();
12498
12499           if (TARGET_64BIT)
12500             {
12501               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns;
12502
12503               start_sequence ();
12504               emit_call_insn (gen_tls_global_dynamic_64 (rax, x, caddr));
12505               insns = get_insns ();
12506               end_sequence ();
12507
12508               RTL_CONST_CALL_P (insns) = 1;
12509               emit_libcall_block (insns, dest, rax, x);
12510             }
12511           else
12512             emit_insn (gen_tls_global_dynamic_32 (dest, x, pic, caddr));
12513         }
12514       break;
12515
12516     case TLS_MODEL_LOCAL_DYNAMIC:
12517       base = gen_reg_rtx (Pmode);
12518
12519       if (!TARGET_64BIT)
12520         {
12521           if (flag_pic)
12522             pic = pic_offset_table_rtx;
12523           else
12524             {
12525               pic = gen_reg_rtx (Pmode);
12526               emit_insn (gen_set_got (pic));
12527             }
12528         }
12529
12530       if (TARGET_GNU2_TLS)
12531         {
12532           rtx tmp = ix86_tls_module_base ();
12533
12534           if (TARGET_64BIT)
12535             emit_insn (gen_tls_dynamic_gnu2_64 (base, tmp));
12536           else
12537             emit_insn (gen_tls_dynamic_gnu2_32 (base, tmp, pic));
12538
12539           tp = get_thread_pointer (true);
12540           set_unique_reg_note (get_last_insn (), REG_EQUAL,
12541                                gen_rtx_MINUS (Pmode, tmp, tp));
12542         }
12543       else
12544         {
12545           rtx caddr = ix86_tls_get_addr ();
12546
12547           if (TARGET_64BIT)
12548             {
12549               rtx rax = gen_rtx_REG (Pmode, AX_REG), insns, eqv;
12550
12551               start_sequence ();
12552               emit_call_insn (gen_tls_local_dynamic_base_64 (rax, caddr));
12553               insns = get_insns ();
12554               end_sequence ();
12555
12556               /* Attach a unique REG_EQUAL, to allow the RTL optimizers to
12557                  share the LD_BASE result with other LD model accesses.  */
12558               eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
12559                                     UNSPEC_TLS_LD_BASE);
12560
12561               RTL_CONST_CALL_P (insns) = 1;
12562               emit_libcall_block (insns, base, rax, eqv);
12563             }
12564           else
12565             emit_insn (gen_tls_local_dynamic_base_32 (base, pic, caddr));
12566         }
12567
12568       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPOFF);
12569       off = gen_rtx_CONST (Pmode, off);
12570
12571       dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, off));
12572
12573       if (TARGET_GNU2_TLS)
12574         {
12575           dest = force_reg (Pmode, gen_rtx_PLUS (Pmode, dest, tp));
12576
12577           set_unique_reg_note (get_last_insn (), REG_EQUAL, x);
12578         }
12579       break;
12580
12581     case TLS_MODEL_INITIAL_EXEC:
12582       if (TARGET_64BIT)
12583         {
12584           if (TARGET_SUN_TLS)
12585             {
12586               /* The Sun linker took the AMD64 TLS spec literally
12587                  and can only handle %rax as destination of the
12588                  initial executable code sequence.  */
12589
12590               dest = gen_reg_rtx (Pmode);
12591               emit_insn (gen_tls_initial_exec_64_sun (dest, x));
12592               return dest;
12593             }
12594
12595           pic = NULL;
12596           type = UNSPEC_GOTNTPOFF;
12597         }
12598       else if (flag_pic)
12599         {
12600           if (reload_in_progress)
12601             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
12602           pic = pic_offset_table_rtx;
12603           type = TARGET_ANY_GNU_TLS ? UNSPEC_GOTNTPOFF : UNSPEC_GOTTPOFF;
12604         }
12605       else if (!TARGET_ANY_GNU_TLS)
12606         {
12607           pic = gen_reg_rtx (Pmode);
12608           emit_insn (gen_set_got (pic));
12609           type = UNSPEC_GOTTPOFF;
12610         }
12611       else
12612         {
12613           pic = NULL;
12614           type = UNSPEC_INDNTPOFF;
12615         }
12616
12617       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), type);
12618       off = gen_rtx_CONST (Pmode, off);
12619       if (pic)
12620         off = gen_rtx_PLUS (Pmode, pic, off);
12621       off = gen_const_mem (Pmode, off);
12622       set_mem_alias_set (off, ix86_GOT_alias_set ());
12623
12624       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12625         {
12626           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12627           off = force_reg (Pmode, off);
12628           return gen_rtx_PLUS (Pmode, base, off);
12629         }
12630       else
12631         {
12632           base = get_thread_pointer (true);
12633           dest = gen_reg_rtx (Pmode);
12634           emit_insn (gen_subsi3 (dest, base, off));
12635         }
12636       break;
12637
12638     case TLS_MODEL_LOCAL_EXEC:
12639       off = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x),
12640                             (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12641                             ? UNSPEC_NTPOFF : UNSPEC_TPOFF);
12642       off = gen_rtx_CONST (Pmode, off);
12643
12644       if (TARGET_64BIT || TARGET_ANY_GNU_TLS)
12645         {
12646           base = get_thread_pointer (for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
12647           return gen_rtx_PLUS (Pmode, base, off);
12648         }
12649       else
12650         {
12651           base = get_thread_pointer (true);
12652           dest = gen_reg_rtx (Pmode);
12653           emit_insn (gen_subsi3 (dest, base, off));
12654         }
12655       break;
12656
12657     default:
12658       gcc_unreachable ();
12659     }
12660
12661   return dest;
12662 }
12663
12664 /* Create or return the unique __imp_DECL dllimport symbol corresponding
12665    to symbol DECL.  */
12666
12667 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
12668   htab_t dllimport_map;
12669
12670 static tree
12671 get_dllimport_decl (tree decl)
12672 {
12673   struct tree_map *h, in;
12674   void **loc;
12675   const char *name;
12676   const char *prefix;
12677   size_t namelen, prefixlen;
12678   char *imp_name;
12679   tree to;
12680   rtx rtl;
12681
12682   if (!dllimport_map)
12683     dllimport_map = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
12684
12685   in.hash = htab_hash_pointer (decl);
12686   in.base.from = decl;
12687   loc = htab_find_slot_with_hash (dllimport_map, &in, in.hash, INSERT);
12688   h = (struct tree_map *) *loc;
12689   if (h)
12690     return h->to;
12691
12692   *loc = h = ggc_alloc_tree_map ();
12693   h->hash = in.hash;
12694   h->base.from = decl;
12695   h->to = to = build_decl (DECL_SOURCE_LOCATION (decl),
12696                            VAR_DECL, NULL, ptr_type_node);
12697   DECL_ARTIFICIAL (to) = 1;
12698   DECL_IGNORED_P (to) = 1;
12699   DECL_EXTERNAL (to) = 1;
12700   TREE_READONLY (to) = 1;
12701
12702   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
12703   name = targetm.strip_name_encoding (name);
12704   prefix = name[0] == FASTCALL_PREFIX || user_label_prefix[0] == 0
12705     ? "*__imp_" : "*__imp__";
12706   namelen = strlen (name);
12707   prefixlen = strlen (prefix);
12708   imp_name = (char *) alloca (namelen + prefixlen + 1);
12709   memcpy (imp_name, prefix, prefixlen);
12710   memcpy (imp_name + prefixlen, name, namelen + 1);
12711
12712   name = ggc_alloc_string (imp_name, namelen + prefixlen);
12713   rtl = gen_rtx_SYMBOL_REF (Pmode, name);
12714   SET_SYMBOL_REF_DECL (rtl, to);
12715   SYMBOL_REF_FLAGS (rtl) = SYMBOL_FLAG_LOCAL;
12716
12717   rtl = gen_const_mem (Pmode, rtl);
12718   set_mem_alias_set (rtl, ix86_GOT_alias_set ());
12719
12720   SET_DECL_RTL (to, rtl);
12721   SET_DECL_ASSEMBLER_NAME (to, get_identifier (name));
12722
12723   return to;
12724 }
12725
12726 /* Expand SYMBOL into its corresponding dllimport symbol.  WANT_REG is
12727    true if we require the result be a register.  */
12728
12729 static rtx
12730 legitimize_dllimport_symbol (rtx symbol, bool want_reg)
12731 {
12732   tree imp_decl;
12733   rtx x;
12734
12735   gcc_assert (SYMBOL_REF_DECL (symbol));
12736   imp_decl = get_dllimport_decl (SYMBOL_REF_DECL (symbol));
12737
12738   x = DECL_RTL (imp_decl);
12739   if (want_reg)
12740     x = force_reg (Pmode, x);
12741   return x;
12742 }
12743
12744 /* Try machine-dependent ways of modifying an illegitimate address
12745    to be legitimate.  If we find one, return the new, valid address.
12746    This macro is used in only one place: `memory_address' in explow.c.
12747
12748    OLDX is the address as it was before break_out_memory_refs was called.
12749    In some cases it is useful to look at this to decide what needs to be done.
12750
12751    It is always safe for this macro to do nothing.  It exists to recognize
12752    opportunities to optimize the output.
12753
12754    For the 80386, we handle X+REG by loading X into a register R and
12755    using R+REG.  R will go in a general reg and indexing will be used.
12756    However, if REG is a broken-out memory address or multiplication,
12757    nothing needs to be done because REG can certainly go in a general reg.
12758
12759    When -fpic is used, special handling is needed for symbolic references.
12760    See comments by legitimize_pic_address in i386.c for details.  */
12761
12762 static rtx
12763 ix86_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
12764                          enum machine_mode mode)
12765 {
12766   int changed = 0;
12767   unsigned log;
12768
12769   log = GET_CODE (x) == SYMBOL_REF ? SYMBOL_REF_TLS_MODEL (x) : 0;
12770   if (log)
12771     return legitimize_tls_address (x, (enum tls_model) log, false);
12772   if (GET_CODE (x) == CONST
12773       && GET_CODE (XEXP (x, 0)) == PLUS
12774       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12775       && (log = SYMBOL_REF_TLS_MODEL (XEXP (XEXP (x, 0), 0))))
12776     {
12777       rtx t = legitimize_tls_address (XEXP (XEXP (x, 0), 0),
12778                                       (enum tls_model) log, false);
12779       return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12780     }
12781
12782   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES)
12783     {
12784       if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P (x))
12785         return legitimize_dllimport_symbol (x, true);
12786       if (GET_CODE (x) == CONST
12787           && GET_CODE (XEXP (x, 0)) == PLUS
12788           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
12789           && SYMBOL_REF_DLLIMPORT_P (XEXP (XEXP (x, 0), 0)))
12790         {
12791           rtx t = legitimize_dllimport_symbol (XEXP (XEXP (x, 0), 0), true);
12792           return gen_rtx_PLUS (Pmode, t, XEXP (XEXP (x, 0), 1));
12793         }
12794     }
12795
12796   if (flag_pic && SYMBOLIC_CONST (x))
12797     return legitimize_pic_address (x, 0);
12798
12799 #if TARGET_MACHO
12800   if (MACHO_DYNAMIC_NO_PIC_P && SYMBOLIC_CONST (x))
12801     return machopic_indirect_data_reference (x, 0);
12802 #endif
12803
12804   /* Canonicalize shifts by 0, 1, 2, 3 into multiply */
12805   if (GET_CODE (x) == ASHIFT
12806       && CONST_INT_P (XEXP (x, 1))
12807       && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) < 4)
12808     {
12809       changed = 1;
12810       log = INTVAL (XEXP (x, 1));
12811       x = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (x, 0)),
12812                         GEN_INT (1 << log));
12813     }
12814
12815   if (GET_CODE (x) == PLUS)
12816     {
12817       /* Canonicalize shifts by 0, 1, 2, 3 into multiply.  */
12818
12819       if (GET_CODE (XEXP (x, 0)) == ASHIFT
12820           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
12821           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 0), 1)) < 4)
12822         {
12823           changed = 1;
12824           log = INTVAL (XEXP (XEXP (x, 0), 1));
12825           XEXP (x, 0) = gen_rtx_MULT (Pmode,
12826                                       force_reg (Pmode, XEXP (XEXP (x, 0), 0)),
12827                                       GEN_INT (1 << log));
12828         }
12829
12830       if (GET_CODE (XEXP (x, 1)) == ASHIFT
12831           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
12832           && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 1), 1)) < 4)
12833         {
12834           changed = 1;
12835           log = INTVAL (XEXP (XEXP (x, 1), 1));
12836           XEXP (x, 1) = gen_rtx_MULT (Pmode,
12837                                       force_reg (Pmode, XEXP (XEXP (x, 1), 0)),
12838                                       GEN_INT (1 << log));
12839         }
12840
12841       /* Put multiply first if it isn't already.  */
12842       if (GET_CODE (XEXP (x, 1)) == MULT)
12843         {
12844           rtx tmp = XEXP (x, 0);
12845           XEXP (x, 0) = XEXP (x, 1);
12846           XEXP (x, 1) = tmp;
12847           changed = 1;
12848         }
12849
12850       /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
12851          into (plus (plus (mult (reg) (const)) (reg)) (const)).  This can be
12852          created by virtual register instantiation, register elimination, and
12853          similar optimizations.  */
12854       if (GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == PLUS)
12855         {
12856           changed = 1;
12857           x = gen_rtx_PLUS (Pmode,
12858                             gen_rtx_PLUS (Pmode, XEXP (x, 0),
12859                                           XEXP (XEXP (x, 1), 0)),
12860                             XEXP (XEXP (x, 1), 1));
12861         }
12862
12863       /* Canonicalize
12864          (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
12865          into (plus (plus (mult (reg) (const)) (reg)) (const)).  */
12866       else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS
12867                && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
12868                && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS
12869                && CONSTANT_P (XEXP (x, 1)))
12870         {
12871           rtx constant;
12872           rtx other = NULL_RTX;
12873
12874           if (CONST_INT_P (XEXP (x, 1)))
12875             {
12876               constant = XEXP (x, 1);
12877               other = XEXP (XEXP (XEXP (x, 0), 1), 1);
12878             }
12879           else if (CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 1), 1)))
12880             {
12881               constant = XEXP (XEXP (XEXP (x, 0), 1), 1);
12882               other = XEXP (x, 1);
12883             }
12884           else
12885             constant = 0;
12886
12887           if (constant)
12888             {
12889               changed = 1;
12890               x = gen_rtx_PLUS (Pmode,
12891                                 gen_rtx_PLUS (Pmode, XEXP (XEXP (x, 0), 0),
12892                                               XEXP (XEXP (XEXP (x, 0), 1), 0)),
12893                                 plus_constant (other, INTVAL (constant)));
12894             }
12895         }
12896
12897       if (changed && ix86_legitimate_address_p (mode, x, false))
12898         return x;
12899
12900       if (GET_CODE (XEXP (x, 0)) == MULT)
12901         {
12902           changed = 1;
12903           XEXP (x, 0) = force_operand (XEXP (x, 0), 0);
12904         }
12905
12906       if (GET_CODE (XEXP (x, 1)) == MULT)
12907         {
12908           changed = 1;
12909           XEXP (x, 1) = force_operand (XEXP (x, 1), 0);
12910         }
12911
12912       if (changed
12913           && REG_P (XEXP (x, 1))
12914           && REG_P (XEXP (x, 0)))
12915         return x;
12916
12917       if (flag_pic && SYMBOLIC_CONST (XEXP (x, 1)))
12918         {
12919           changed = 1;
12920           x = legitimize_pic_address (x, 0);
12921         }
12922
12923       if (changed && ix86_legitimate_address_p (mode, x, false))
12924         return x;
12925
12926       if (REG_P (XEXP (x, 0)))
12927         {
12928           rtx temp = gen_reg_rtx (Pmode);
12929           rtx val  = force_operand (XEXP (x, 1), temp);
12930           if (val != temp)
12931             {
12932               if (GET_MODE (val) != Pmode)
12933                 val = convert_to_mode (Pmode, val, 1);
12934               emit_move_insn (temp, val);
12935             }
12936
12937           XEXP (x, 1) = temp;
12938           return x;
12939         }
12940
12941       else if (REG_P (XEXP (x, 1)))
12942         {
12943           rtx temp = gen_reg_rtx (Pmode);
12944           rtx val  = force_operand (XEXP (x, 0), temp);
12945           if (val != temp)
12946             {
12947               if (GET_MODE (val) != Pmode)
12948                 val = convert_to_mode (Pmode, val, 1);
12949               emit_move_insn (temp, val);
12950             }
12951
12952           XEXP (x, 0) = temp;
12953           return x;
12954         }
12955     }
12956
12957   return x;
12958 }
12959 \f
12960 /* Print an integer constant expression in assembler syntax.  Addition
12961    and subtraction are the only arithmetic that may appear in these
12962    expressions.  FILE is the stdio stream to write to, X is the rtx, and
12963    CODE is the operand print code from the output string.  */
12964
12965 static void
12966 output_pic_addr_const (FILE *file, rtx x, int code)
12967 {
12968   char buf[256];
12969
12970   switch (GET_CODE (x))
12971     {
12972     case PC:
12973       gcc_assert (flag_pic);
12974       putc ('.', file);
12975       break;
12976
12977     case SYMBOL_REF:
12978       if (TARGET_64BIT || ! TARGET_MACHO_BRANCH_ISLANDS)
12979         output_addr_const (file, x);
12980       else
12981         {
12982           const char *name = XSTR (x, 0);
12983
12984           /* Mark the decl as referenced so that cgraph will
12985              output the function.  */
12986           if (SYMBOL_REF_DECL (x))
12987             mark_decl_referenced (SYMBOL_REF_DECL (x));
12988
12989 #if TARGET_MACHO
12990           if (MACHOPIC_INDIRECT
12991               && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
12992             name = machopic_indirection_name (x, /*stub_p=*/true);
12993 #endif
12994           assemble_name (file, name);
12995         }
12996       if (!TARGET_MACHO && !(TARGET_64BIT && DEFAULT_ABI == MS_ABI)
12997           && code == 'P' && ! SYMBOL_REF_LOCAL_P (x))
12998         fputs ("@PLT", file);
12999       break;
13000
13001     case LABEL_REF:
13002       x = XEXP (x, 0);
13003       /* FALLTHRU */
13004     case CODE_LABEL:
13005       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
13006       assemble_name (asm_out_file, buf);
13007       break;
13008
13009     case CONST_INT:
13010       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
13011       break;
13012
13013     case CONST:
13014       /* This used to output parentheses around the expression,
13015          but that does not work on the 386 (either ATT or BSD assembler).  */
13016       output_pic_addr_const (file, XEXP (x, 0), code);
13017       break;
13018
13019     case CONST_DOUBLE:
13020       if (GET_MODE (x) == VOIDmode)
13021         {
13022           /* We can use %d if the number is <32 bits and positive.  */
13023           if (CONST_DOUBLE_HIGH (x) || CONST_DOUBLE_LOW (x) < 0)
13024             fprintf (file, "0x%lx%08lx",
13025                      (unsigned long) CONST_DOUBLE_HIGH (x),
13026                      (unsigned long) CONST_DOUBLE_LOW (x));
13027           else
13028             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
13029         }
13030       else
13031         /* We can't handle floating point constants;
13032            TARGET_PRINT_OPERAND must handle them.  */
13033         output_operand_lossage ("floating constant misused");
13034       break;
13035
13036     case PLUS:
13037       /* Some assemblers need integer constants to appear first.  */
13038       if (CONST_INT_P (XEXP (x, 0)))
13039         {
13040           output_pic_addr_const (file, XEXP (x, 0), code);
13041           putc ('+', file);
13042           output_pic_addr_const (file, XEXP (x, 1), code);
13043         }
13044       else
13045         {
13046           gcc_assert (CONST_INT_P (XEXP (x, 1)));
13047           output_pic_addr_const (file, XEXP (x, 1), code);
13048           putc ('+', file);
13049           output_pic_addr_const (file, XEXP (x, 0), code);
13050         }
13051       break;
13052
13053     case MINUS:
13054       if (!TARGET_MACHO)
13055         putc (ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[', file);
13056       output_pic_addr_const (file, XEXP (x, 0), code);
13057       putc ('-', file);
13058       output_pic_addr_const (file, XEXP (x, 1), code);
13059       if (!TARGET_MACHO)
13060         putc (ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']', file);
13061       break;
13062
13063      case UNSPEC:
13064        if (XINT (x, 1) == UNSPEC_STACK_CHECK)
13065          {
13066            bool f = i386_asm_output_addr_const_extra (file, x);
13067            gcc_assert (f);
13068            break;
13069          }
13070
13071        gcc_assert (XVECLEN (x, 0) == 1);
13072        output_pic_addr_const (file, XVECEXP (x, 0, 0), code);
13073        switch (XINT (x, 1))
13074         {
13075         case UNSPEC_GOT:
13076           fputs ("@GOT", file);
13077           break;
13078         case UNSPEC_GOTOFF:
13079           fputs ("@GOTOFF", file);
13080           break;
13081         case UNSPEC_PLTOFF:
13082           fputs ("@PLTOFF", file);
13083           break;
13084         case UNSPEC_PCREL:
13085           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
13086                  "(%rip)" : "[rip]", file);
13087           break;
13088         case UNSPEC_GOTPCREL:
13089           fputs (ASSEMBLER_DIALECT == ASM_ATT ?
13090                  "@GOTPCREL(%rip)" : "@GOTPCREL[rip]", file);
13091           break;
13092         case UNSPEC_GOTTPOFF:
13093           /* FIXME: This might be @TPOFF in Sun ld too.  */
13094           fputs ("@gottpoff", file);
13095           break;
13096         case UNSPEC_TPOFF:
13097           fputs ("@tpoff", file);
13098           break;
13099         case UNSPEC_NTPOFF:
13100           if (TARGET_64BIT)
13101             fputs ("@tpoff", file);
13102           else
13103             fputs ("@ntpoff", file);
13104           break;
13105         case UNSPEC_DTPOFF:
13106           fputs ("@dtpoff", file);
13107           break;
13108         case UNSPEC_GOTNTPOFF:
13109           if (TARGET_64BIT)
13110             fputs (ASSEMBLER_DIALECT == ASM_ATT ?
13111                    "@gottpoff(%rip)": "@gottpoff[rip]", file);
13112           else
13113             fputs ("@gotntpoff", file);
13114           break;
13115         case UNSPEC_INDNTPOFF:
13116           fputs ("@indntpoff", file);
13117           break;
13118 #if TARGET_MACHO
13119         case UNSPEC_MACHOPIC_OFFSET:
13120           putc ('-', file);
13121           machopic_output_function_base_name (file);
13122           break;
13123 #endif
13124         default:
13125           output_operand_lossage ("invalid UNSPEC as operand");
13126           break;
13127         }
13128        break;
13129
13130     default:
13131       output_operand_lossage ("invalid expression as operand");
13132     }
13133 }
13134
13135 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
13136    We need to emit DTP-relative relocations.  */
13137
13138 static void ATTRIBUTE_UNUSED
13139 i386_output_dwarf_dtprel (FILE *file, int size, rtx x)
13140 {
13141   fputs (ASM_LONG, file);
13142   output_addr_const (file, x);
13143   fputs ("@dtpoff", file);
13144   switch (size)
13145     {
13146     case 4:
13147       break;
13148     case 8:
13149       fputs (", 0", file);
13150       break;
13151     default:
13152       gcc_unreachable ();
13153    }
13154 }
13155
13156 /* Return true if X is a representation of the PIC register.  This copes
13157    with calls from ix86_find_base_term, where the register might have
13158    been replaced by a cselib value.  */
13159
13160 static bool
13161 ix86_pic_register_p (rtx x)
13162 {
13163   if (GET_CODE (x) == VALUE && CSELIB_VAL_PTR (x))
13164     return (pic_offset_table_rtx
13165             && rtx_equal_for_cselib_p (x, pic_offset_table_rtx));
13166   else
13167     return REG_P (x) && REGNO (x) == PIC_OFFSET_TABLE_REGNUM;
13168 }
13169
13170 /* Helper function for ix86_delegitimize_address.
13171    Attempt to delegitimize TLS local-exec accesses.  */
13172
13173 static rtx
13174 ix86_delegitimize_tls_address (rtx orig_x)
13175 {
13176   rtx x = orig_x, unspec;
13177   struct ix86_address addr;
13178
13179   if (!TARGET_TLS_DIRECT_SEG_REFS)
13180     return orig_x;
13181   if (MEM_P (x))
13182     x = XEXP (x, 0);
13183   if (GET_CODE (x) != PLUS || GET_MODE (x) != Pmode)
13184     return orig_x;
13185   if (ix86_decompose_address (x, &addr) == 0
13186       || addr.seg != (TARGET_64BIT ? SEG_FS : SEG_GS)
13187       || addr.disp == NULL_RTX
13188       || GET_CODE (addr.disp) != CONST)
13189     return orig_x;
13190   unspec = XEXP (addr.disp, 0);
13191   if (GET_CODE (unspec) == PLUS && CONST_INT_P (XEXP (unspec, 1)))
13192     unspec = XEXP (unspec, 0);
13193   if (GET_CODE (unspec) != UNSPEC || XINT (unspec, 1) != UNSPEC_NTPOFF)
13194     return orig_x;
13195   x = XVECEXP (unspec, 0, 0);
13196   gcc_assert (GET_CODE (x) == SYMBOL_REF);
13197   if (unspec != XEXP (addr.disp, 0))
13198     x = gen_rtx_PLUS (Pmode, x, XEXP (XEXP (addr.disp, 0), 1));
13199   if (addr.index)
13200     {
13201       rtx idx = addr.index;
13202       if (addr.scale != 1)
13203         idx = gen_rtx_MULT (Pmode, idx, GEN_INT (addr.scale));
13204       x = gen_rtx_PLUS (Pmode, idx, x);
13205     }
13206   if (addr.base)
13207     x = gen_rtx_PLUS (Pmode, addr.base, x);
13208   if (MEM_P (orig_x))
13209     x = replace_equiv_address_nv (orig_x, x);
13210   return x;
13211 }
13212
13213 /* In the name of slightly smaller debug output, and to cater to
13214    general assembler lossage, recognize PIC+GOTOFF and turn it back
13215    into a direct symbol reference.
13216
13217    On Darwin, this is necessary to avoid a crash, because Darwin
13218    has a different PIC label for each routine but the DWARF debugging
13219    information is not associated with any particular routine, so it's
13220    necessary to remove references to the PIC label from RTL stored by
13221    the DWARF output code.  */
13222
13223 static rtx
13224 ix86_delegitimize_address (rtx x)
13225 {
13226   rtx orig_x = delegitimize_mem_from_attrs (x);
13227   /* addend is NULL or some rtx if x is something+GOTOFF where
13228      something doesn't include the PIC register.  */
13229   rtx addend = NULL_RTX;
13230   /* reg_addend is NULL or a multiple of some register.  */
13231   rtx reg_addend = NULL_RTX;
13232   /* const_addend is NULL or a const_int.  */
13233   rtx const_addend = NULL_RTX;
13234   /* This is the result, or NULL.  */
13235   rtx result = NULL_RTX;
13236
13237   x = orig_x;
13238
13239   if (MEM_P (x))
13240     x = XEXP (x, 0);
13241
13242   if (TARGET_64BIT)
13243     {
13244       if (GET_CODE (x) != CONST
13245           || GET_CODE (XEXP (x, 0)) != UNSPEC
13246           || (XINT (XEXP (x, 0), 1) != UNSPEC_GOTPCREL
13247               && XINT (XEXP (x, 0), 1) != UNSPEC_PCREL)
13248           || (!MEM_P (orig_x) && XINT (XEXP (x, 0), 1) != UNSPEC_PCREL))
13249         return ix86_delegitimize_tls_address (orig_x);
13250       x = XVECEXP (XEXP (x, 0), 0, 0);
13251       if (GET_MODE (orig_x) != GET_MODE (x) && MEM_P (orig_x))
13252         {
13253           x = simplify_gen_subreg (GET_MODE (orig_x), x,
13254                                    GET_MODE (x), 0);
13255           if (x == NULL_RTX)
13256             return orig_x;
13257         }
13258       return x;
13259     }
13260
13261   if (GET_CODE (x) != PLUS
13262       || GET_CODE (XEXP (x, 1)) != CONST)
13263     return ix86_delegitimize_tls_address (orig_x);
13264
13265   if (ix86_pic_register_p (XEXP (x, 0)))
13266     /* %ebx + GOT/GOTOFF */
13267     ;
13268   else if (GET_CODE (XEXP (x, 0)) == PLUS)
13269     {
13270       /* %ebx + %reg * scale + GOT/GOTOFF */
13271       reg_addend = XEXP (x, 0);
13272       if (ix86_pic_register_p (XEXP (reg_addend, 0)))
13273         reg_addend = XEXP (reg_addend, 1);
13274       else if (ix86_pic_register_p (XEXP (reg_addend, 1)))
13275         reg_addend = XEXP (reg_addend, 0);
13276       else
13277         {
13278           reg_addend = NULL_RTX;
13279           addend = XEXP (x, 0);
13280         }
13281     }
13282   else
13283     addend = XEXP (x, 0);
13284
13285   x = XEXP (XEXP (x, 1), 0);
13286   if (GET_CODE (x) == PLUS
13287       && CONST_INT_P (XEXP (x, 1)))
13288     {
13289       const_addend = XEXP (x, 1);
13290       x = XEXP (x, 0);
13291     }
13292
13293   if (GET_CODE (x) == UNSPEC
13294       && ((XINT (x, 1) == UNSPEC_GOT && MEM_P (orig_x) && !addend)
13295           || (XINT (x, 1) == UNSPEC_GOTOFF && !MEM_P (orig_x))))
13296     result = XVECEXP (x, 0, 0);
13297
13298   if (TARGET_MACHO && darwin_local_data_pic (x)
13299       && !MEM_P (orig_x))
13300     result = XVECEXP (x, 0, 0);
13301
13302   if (! result)
13303     return ix86_delegitimize_tls_address (orig_x);
13304
13305   if (const_addend)
13306     result = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, result, const_addend));
13307   if (reg_addend)
13308     result = gen_rtx_PLUS (Pmode, reg_addend, result);
13309   if (addend)
13310     {
13311       /* If the rest of original X doesn't involve the PIC register, add
13312          addend and subtract pic_offset_table_rtx.  This can happen e.g.
13313          for code like:
13314          leal (%ebx, %ecx, 4), %ecx
13315          ...
13316          movl foo@GOTOFF(%ecx), %edx
13317          in which case we return (%ecx - %ebx) + foo.  */
13318       if (pic_offset_table_rtx)
13319         result = gen_rtx_PLUS (Pmode, gen_rtx_MINUS (Pmode, copy_rtx (addend),
13320                                                      pic_offset_table_rtx),
13321                                result);
13322       else
13323         return orig_x;
13324     }
13325   if (GET_MODE (orig_x) != Pmode && MEM_P (orig_x))
13326     {
13327       result = simplify_gen_subreg (GET_MODE (orig_x), result, Pmode, 0);
13328       if (result == NULL_RTX)
13329         return orig_x;
13330     }
13331   return result;
13332 }
13333
13334 /* If X is a machine specific address (i.e. a symbol or label being
13335    referenced as a displacement from the GOT implemented using an
13336    UNSPEC), then return the base term.  Otherwise return X.  */
13337
13338 rtx
13339 ix86_find_base_term (rtx x)
13340 {
13341   rtx term;
13342
13343   if (TARGET_64BIT)
13344     {
13345       if (GET_CODE (x) != CONST)
13346         return x;
13347       term = XEXP (x, 0);
13348       if (GET_CODE (term) == PLUS
13349           && (CONST_INT_P (XEXP (term, 1))
13350               || GET_CODE (XEXP (term, 1)) == CONST_DOUBLE))
13351         term = XEXP (term, 0);
13352       if (GET_CODE (term) != UNSPEC
13353           || (XINT (term, 1) != UNSPEC_GOTPCREL
13354               && XINT (term, 1) != UNSPEC_PCREL))
13355         return x;
13356
13357       return XVECEXP (term, 0, 0);
13358     }
13359
13360   return ix86_delegitimize_address (x);
13361 }
13362 \f
13363 static void
13364 put_condition_code (enum rtx_code code, enum machine_mode mode, int reverse,
13365                     int fp, FILE *file)
13366 {
13367   const char *suffix;
13368
13369   if (mode == CCFPmode || mode == CCFPUmode)
13370     {
13371       code = ix86_fp_compare_code_to_integer (code);
13372       mode = CCmode;
13373     }
13374   if (reverse)
13375     code = reverse_condition (code);
13376
13377   switch (code)
13378     {
13379     case EQ:
13380       switch (mode)
13381         {
13382         case CCAmode:
13383           suffix = "a";
13384           break;
13385
13386         case CCCmode:
13387           suffix = "c";
13388           break;
13389
13390         case CCOmode:
13391           suffix = "o";
13392           break;
13393
13394         case CCSmode:
13395           suffix = "s";
13396           break;
13397
13398         default:
13399           suffix = "e";
13400         }
13401       break;
13402     case NE:
13403       switch (mode)
13404         {
13405         case CCAmode:
13406           suffix = "na";
13407           break;
13408
13409         case CCCmode:
13410           suffix = "nc";
13411           break;
13412
13413         case CCOmode:
13414           suffix = "no";
13415           break;
13416
13417         case CCSmode:
13418           suffix = "ns";
13419           break;
13420
13421         default:
13422           suffix = "ne";
13423         }
13424       break;
13425     case GT:
13426       gcc_assert (mode == CCmode || mode == CCNOmode || mode == CCGCmode);
13427       suffix = "g";
13428       break;
13429     case GTU:
13430       /* ??? Use "nbe" instead of "a" for fcmov lossage on some assemblers.
13431          Those same assemblers have the same but opposite lossage on cmov.  */
13432       if (mode == CCmode)
13433         suffix = fp ? "nbe" : "a";
13434       else if (mode == CCCmode)
13435         suffix = "b";
13436       else
13437         gcc_unreachable ();
13438       break;
13439     case LT:
13440       switch (mode)
13441         {
13442         case CCNOmode:
13443         case CCGOCmode:
13444           suffix = "s";
13445           break;
13446
13447         case CCmode:
13448         case CCGCmode:
13449           suffix = "l";
13450           break;
13451
13452         default:
13453           gcc_unreachable ();
13454         }
13455       break;
13456     case LTU:
13457       gcc_assert (mode == CCmode || mode == CCCmode);
13458       suffix = "b";
13459       break;
13460     case GE:
13461       switch (mode)
13462         {
13463         case CCNOmode:
13464         case CCGOCmode:
13465           suffix = "ns";
13466           break;
13467
13468         case CCmode:
13469         case CCGCmode:
13470           suffix = "ge";
13471           break;
13472
13473         default:
13474           gcc_unreachable ();
13475         }
13476       break;
13477     case GEU:
13478       /* ??? As above.  */
13479       gcc_assert (mode == CCmode || mode == CCCmode);
13480       suffix = fp ? "nb" : "ae";
13481       break;
13482     case LE:
13483       gcc_assert (mode == CCmode || mode == CCGCmode || mode == CCNOmode);
13484       suffix = "le";
13485       break;
13486     case LEU:
13487       /* ??? As above.  */
13488       if (mode == CCmode)
13489         suffix = "be";
13490       else if (mode == CCCmode)
13491         suffix = fp ? "nb" : "ae";
13492       else
13493         gcc_unreachable ();
13494       break;
13495     case UNORDERED:
13496       suffix = fp ? "u" : "p";
13497       break;
13498     case ORDERED:
13499       suffix = fp ? "nu" : "np";
13500       break;
13501     default:
13502       gcc_unreachable ();
13503     }
13504   fputs (suffix, file);
13505 }
13506
13507 /* Print the name of register X to FILE based on its machine mode and number.
13508    If CODE is 'w', pretend the mode is HImode.
13509    If CODE is 'b', pretend the mode is QImode.
13510    If CODE is 'k', pretend the mode is SImode.
13511    If CODE is 'q', pretend the mode is DImode.
13512    If CODE is 'x', pretend the mode is V4SFmode.
13513    If CODE is 't', pretend the mode is V8SFmode.
13514    If CODE is 'h', pretend the reg is the 'high' byte register.
13515    If CODE is 'y', print "st(0)" instead of "st", if the reg is stack op.
13516    If CODE is 'd', duplicate the operand for AVX instruction.
13517  */
13518
13519 void
13520 print_reg (rtx x, int code, FILE *file)
13521 {
13522   const char *reg;
13523   bool duplicated = code == 'd' && TARGET_AVX;
13524
13525   gcc_assert (x == pc_rtx
13526               || (REGNO (x) != ARG_POINTER_REGNUM
13527                   && REGNO (x) != FRAME_POINTER_REGNUM
13528                   && REGNO (x) != FLAGS_REG
13529                   && REGNO (x) != FPSR_REG
13530                   && REGNO (x) != FPCR_REG));
13531
13532   if (ASSEMBLER_DIALECT == ASM_ATT)
13533     putc ('%', file);
13534
13535   if (x == pc_rtx)
13536     {
13537       gcc_assert (TARGET_64BIT);
13538       fputs ("rip", file);
13539       return;
13540     }
13541
13542   if (code == 'w' || MMX_REG_P (x))
13543     code = 2;
13544   else if (code == 'b')
13545     code = 1;
13546   else if (code == 'k')
13547     code = 4;
13548   else if (code == 'q')
13549     code = 8;
13550   else if (code == 'y')
13551     code = 3;
13552   else if (code == 'h')
13553     code = 0;
13554   else if (code == 'x')
13555     code = 16;
13556   else if (code == 't')
13557     code = 32;
13558   else
13559     code = GET_MODE_SIZE (GET_MODE (x));
13560
13561   /* Irritatingly, AMD extended registers use different naming convention
13562      from the normal registers: "r%d[bwd]"  */
13563   if (REX_INT_REG_P (x))
13564     {
13565       gcc_assert (TARGET_64BIT);
13566       putc ('r', file);
13567       fprint_ul (file, REGNO (x) - FIRST_REX_INT_REG + 8);
13568       switch (code)
13569         {
13570           case 0:
13571             error ("extended registers have no high halves");
13572             break;
13573           case 1:
13574             putc ('b', file);
13575             break;
13576           case 2:
13577             putc ('w', file);
13578             break;
13579           case 4:
13580             putc ('d', file);
13581             break;
13582           case 8:
13583             /* no suffix */
13584             break;
13585           default:
13586             error ("unsupported operand size for extended register");
13587             break;
13588         }
13589       return;
13590     }
13591
13592   reg = NULL;
13593   switch (code)
13594     {
13595     case 3:
13596       if (STACK_TOP_P (x))
13597         {
13598           reg = "st(0)";
13599           break;
13600         }
13601       /* FALLTHRU */
13602     case 8:
13603     case 4:
13604     case 12:
13605       if (! ANY_FP_REG_P (x))
13606         putc (code == 8 && TARGET_64BIT ? 'r' : 'e', file);
13607       /* FALLTHRU */
13608     case 16:
13609     case 2:
13610     normal:
13611       reg = hi_reg_name[REGNO (x)];
13612       break;
13613     case 1:
13614       if (REGNO (x) >= ARRAY_SIZE (qi_reg_name))
13615         goto normal;
13616       reg = qi_reg_name[REGNO (x)];
13617       break;
13618     case 0:
13619       if (REGNO (x) >= ARRAY_SIZE (qi_high_reg_name))
13620         goto normal;
13621       reg = qi_high_reg_name[REGNO (x)];
13622       break;
13623     case 32:
13624       if (SSE_REG_P (x))
13625         {
13626           gcc_assert (!duplicated);
13627           putc ('y', file);
13628           fputs (hi_reg_name[REGNO (x)] + 1, file);
13629           return;
13630         }
13631       break;
13632     default:
13633       gcc_unreachable ();
13634     }
13635
13636   fputs (reg, file);
13637   if (duplicated)
13638     {
13639       if (ASSEMBLER_DIALECT == ASM_ATT)
13640         fprintf (file, ", %%%s", reg);
13641       else
13642         fprintf (file, ", %s", reg);
13643     }
13644 }
13645
13646 /* Locate some local-dynamic symbol still in use by this function
13647    so that we can print its name in some tls_local_dynamic_base
13648    pattern.  */
13649
13650 static int
13651 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
13652 {
13653   rtx x = *px;
13654
13655   if (GET_CODE (x) == SYMBOL_REF
13656       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
13657     {
13658       cfun->machine->some_ld_name = XSTR (x, 0);
13659       return 1;
13660     }
13661
13662   return 0;
13663 }
13664
13665 static const char *
13666 get_some_local_dynamic_name (void)
13667 {
13668   rtx insn;
13669
13670   if (cfun->machine->some_ld_name)
13671     return cfun->machine->some_ld_name;
13672
13673   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
13674     if (NONDEBUG_INSN_P (insn)
13675         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
13676       return cfun->machine->some_ld_name;
13677
13678   return NULL;
13679 }
13680
13681 /* Meaning of CODE:
13682    L,W,B,Q,S,T -- print the opcode suffix for specified size of operand.
13683    C -- print opcode suffix for set/cmov insn.
13684    c -- like C, but print reversed condition
13685    F,f -- likewise, but for floating-point.
13686    O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
13687         otherwise nothing
13688    R -- print the prefix for register names.
13689    z -- print the opcode suffix for the size of the current operand.
13690    Z -- likewise, with special suffixes for x87 instructions.
13691    * -- print a star (in certain assembler syntax)
13692    A -- print an absolute memory reference.
13693    w -- print the operand as if it's a "word" (HImode) even if it isn't.
13694    s -- print a shift double count, followed by the assemblers argument
13695         delimiter.
13696    b -- print the QImode name of the register for the indicated operand.
13697         %b0 would print %al if operands[0] is reg 0.
13698    w --  likewise, print the HImode name of the register.
13699    k --  likewise, print the SImode name of the register.
13700    q --  likewise, print the DImode name of the register.
13701    x --  likewise, print the V4SFmode name of the register.
13702    t --  likewise, print the V8SFmode name of the register.
13703    h -- print the QImode name for a "high" register, either ah, bh, ch or dh.
13704    y -- print "st(0)" instead of "st" as a register.
13705    d -- print duplicated register operand for AVX instruction.
13706    D -- print condition for SSE cmp instruction.
13707    P -- if PIC, print an @PLT suffix.
13708    p -- print raw symbol name.
13709    X -- don't print any sort of PIC '@' suffix for a symbol.
13710    & -- print some in-use local-dynamic symbol name.
13711    H -- print a memory address offset by 8; used for sse high-parts
13712    Y -- print condition for XOP pcom* instruction.
13713    + -- print a branch hint as 'cs' or 'ds' prefix
13714    ; -- print a semicolon (after prefixes due to bug in older gas).
13715    ~ -- print "i" if TARGET_AVX2, "f" otherwise.
13716    @ -- print a segment register of thread base pointer load
13717  */
13718
13719 void
13720 ix86_print_operand (FILE *file, rtx x, int code)
13721 {
13722   if (code)
13723     {
13724       switch (code)
13725         {
13726         case '*':
13727           if (ASSEMBLER_DIALECT == ASM_ATT)
13728             putc ('*', file);
13729           return;
13730
13731         case '&':
13732           {
13733             const char *name = get_some_local_dynamic_name ();
13734             if (name == NULL)
13735               output_operand_lossage ("'%%&' used without any "
13736                                       "local dynamic TLS references");
13737             else
13738               assemble_name (file, name);
13739             return;
13740           }
13741
13742         case 'A':
13743           switch (ASSEMBLER_DIALECT)
13744             {
13745             case ASM_ATT:
13746               putc ('*', file);
13747               break;
13748
13749             case ASM_INTEL:
13750               /* Intel syntax. For absolute addresses, registers should not
13751                  be surrounded by braces.  */
13752               if (!REG_P (x))
13753                 {
13754                   putc ('[', file);
13755                   ix86_print_operand (file, x, 0);
13756                   putc (']', file);
13757                   return;
13758                 }
13759               break;
13760
13761             default:
13762               gcc_unreachable ();
13763             }
13764
13765           ix86_print_operand (file, x, 0);
13766           return;
13767
13768
13769         case 'L':
13770           if (ASSEMBLER_DIALECT == ASM_ATT)
13771             putc ('l', file);
13772           return;
13773
13774         case 'W':
13775           if (ASSEMBLER_DIALECT == ASM_ATT)
13776             putc ('w', file);
13777           return;
13778
13779         case 'B':
13780           if (ASSEMBLER_DIALECT == ASM_ATT)
13781             putc ('b', file);
13782           return;
13783
13784         case 'Q':
13785           if (ASSEMBLER_DIALECT == ASM_ATT)
13786             putc ('l', file);
13787           return;
13788
13789         case 'S':
13790           if (ASSEMBLER_DIALECT == ASM_ATT)
13791             putc ('s', file);
13792           return;
13793
13794         case 'T':
13795           if (ASSEMBLER_DIALECT == ASM_ATT)
13796             putc ('t', file);
13797           return;
13798
13799         case 'z':
13800           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13801             {
13802               /* Opcodes don't get size suffixes if using Intel opcodes.  */
13803               if (ASSEMBLER_DIALECT == ASM_INTEL)
13804                 return;
13805
13806               switch (GET_MODE_SIZE (GET_MODE (x)))
13807                 {
13808                 case 1:
13809                   putc ('b', file);
13810                   return;
13811
13812                 case 2:
13813                   putc ('w', file);
13814                   return;
13815
13816                 case 4:
13817                   putc ('l', file);
13818                   return;
13819
13820                 case 8:
13821                   putc ('q', file);
13822                   return;
13823
13824                 default:
13825                   output_operand_lossage
13826                     ("invalid operand size for operand code '%c'", code);
13827                   return;
13828                 }
13829             }
13830
13831           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13832             warning
13833               (0, "non-integer operand used with operand code '%c'", code);
13834           /* FALLTHRU */
13835
13836         case 'Z':
13837           /* 387 opcodes don't get size suffixes if using Intel opcodes.  */
13838           if (ASSEMBLER_DIALECT == ASM_INTEL)
13839             return;
13840
13841           if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
13842             {
13843               switch (GET_MODE_SIZE (GET_MODE (x)))
13844                 {
13845                 case 2:
13846 #ifdef HAVE_AS_IX86_FILDS
13847                   putc ('s', file);
13848 #endif
13849                   return;
13850
13851                 case 4:
13852                   putc ('l', file);
13853                   return;
13854
13855                 case 8:
13856 #ifdef HAVE_AS_IX86_FILDQ
13857                   putc ('q', file);
13858 #else
13859                   fputs ("ll", file);
13860 #endif
13861                   return;
13862
13863                 default:
13864                   break;
13865                 }
13866             }
13867           else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
13868             {
13869               /* 387 opcodes don't get size suffixes
13870                  if the operands are registers.  */
13871               if (STACK_REG_P (x))
13872                 return;
13873
13874               switch (GET_MODE_SIZE (GET_MODE (x)))
13875                 {
13876                 case 4:
13877                   putc ('s', file);
13878                   return;
13879
13880                 case 8:
13881                   putc ('l', file);
13882                   return;
13883
13884                 case 12:
13885                 case 16:
13886                   putc ('t', file);
13887                   return;
13888
13889                 default:
13890                   break;
13891                 }
13892             }
13893           else
13894             {
13895               output_operand_lossage
13896                 ("invalid operand type used with operand code '%c'", code);
13897               return;
13898             }
13899
13900           output_operand_lossage
13901             ("invalid operand size for operand code '%c'", code);
13902           return;
13903
13904         case 'd':
13905         case 'b':
13906         case 'w':
13907         case 'k':
13908         case 'q':
13909         case 'h':
13910         case 't':
13911         case 'y':
13912         case 'x':
13913         case 'X':
13914         case 'P':
13915         case 'p':
13916           break;
13917
13918         case 's':
13919           if (CONST_INT_P (x) || ! SHIFT_DOUBLE_OMITS_COUNT)
13920             {
13921               ix86_print_operand (file, x, 0);
13922               fputs (", ", file);
13923             }
13924           return;
13925
13926         case 'D':
13927           /* Little bit of braindamage here.  The SSE compare instructions
13928              does use completely different names for the comparisons that the
13929              fp conditional moves.  */
13930           if (TARGET_AVX)
13931             {
13932               switch (GET_CODE (x))
13933                 {
13934                 case EQ:
13935                   fputs ("eq", file);
13936                   break;
13937                 case UNEQ:
13938                   fputs ("eq_us", file);
13939                   break;
13940                 case LT:
13941                   fputs ("lt", file);
13942                   break;
13943                 case UNLT:
13944                   fputs ("nge", file);
13945                   break;
13946                 case LE:
13947                   fputs ("le", file);
13948                   break;
13949                 case UNLE:
13950                   fputs ("ngt", file);
13951                   break;
13952                 case UNORDERED:
13953                   fputs ("unord", file);
13954                   break;
13955                 case NE:
13956                   fputs ("neq", file);
13957                   break;
13958                 case LTGT:
13959                   fputs ("neq_oq", file);
13960                   break;
13961                 case GE:
13962                   fputs ("ge", file);
13963                   break;
13964                 case UNGE:
13965                   fputs ("nlt", file);
13966                   break;
13967                 case GT:
13968                   fputs ("gt", file);
13969                   break;
13970                 case UNGT:
13971                   fputs ("nle", file);
13972                   break;
13973                 case ORDERED:
13974                   fputs ("ord", file);
13975                   break;
13976                 default:
13977                   output_operand_lossage ("operand is not a condition code, "
13978                                           "invalid operand code 'D'");
13979                   return;
13980                 }
13981             }
13982           else
13983             {
13984               switch (GET_CODE (x))
13985                 {
13986                 case EQ:
13987                 case UNEQ:
13988                   fputs ("eq", file);
13989                   break;
13990                 case LT:
13991                 case UNLT:
13992                   fputs ("lt", file);
13993                   break;
13994                 case LE:
13995                 case UNLE:
13996                   fputs ("le", file);
13997                   break;
13998                 case UNORDERED:
13999                   fputs ("unord", file);
14000                   break;
14001                 case NE:
14002                 case LTGT:
14003                   fputs ("neq", file);
14004                   break;
14005                 case UNGE:
14006                 case GE:
14007                   fputs ("nlt", file);
14008                   break;
14009                 case UNGT:
14010                 case GT:
14011                   fputs ("nle", file);
14012                   break;
14013                 case ORDERED:
14014                   fputs ("ord", file);
14015                   break;
14016                 default:
14017                   output_operand_lossage ("operand is not a condition code, "
14018                                           "invalid operand code 'D'");
14019                   return;
14020                 }
14021             }
14022           return;
14023         case 'O':
14024 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
14025           if (ASSEMBLER_DIALECT == ASM_ATT)
14026             {
14027               switch (GET_MODE (x))
14028                 {
14029                 case HImode: putc ('w', file); break;
14030                 case SImode:
14031                 case SFmode: putc ('l', file); break;
14032                 case DImode:
14033                 case DFmode: putc ('q', file); break;
14034                 default: gcc_unreachable ();
14035                 }
14036               putc ('.', file);
14037             }
14038 #endif
14039           return;
14040         case 'C':
14041           if (!COMPARISON_P (x))
14042             {
14043               output_operand_lossage ("operand is neither a constant nor a "
14044                                       "condition code, invalid operand code "
14045                                       "'C'");
14046               return;
14047             }
14048           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 0, file);
14049           return;
14050         case 'F':
14051           if (!COMPARISON_P (x))
14052             {
14053               output_operand_lossage ("operand is neither a constant nor a "
14054                                       "condition code, invalid operand code "
14055                                       "'F'");
14056               return;
14057             }
14058 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
14059           if (ASSEMBLER_DIALECT == ASM_ATT)
14060             putc ('.', file);
14061 #endif
14062           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 0, 1, file);
14063           return;
14064
14065           /* Like above, but reverse condition */
14066         case 'c':
14067           /* Check to see if argument to %c is really a constant
14068              and not a condition code which needs to be reversed.  */
14069           if (!COMPARISON_P (x))
14070             {
14071               output_operand_lossage ("operand is neither a constant nor a "
14072                                       "condition code, invalid operand "
14073                                       "code 'c'");
14074               return;
14075             }
14076           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 0, file);
14077           return;
14078         case 'f':
14079           if (!COMPARISON_P (x))
14080             {
14081               output_operand_lossage ("operand is neither a constant nor a "
14082                                       "condition code, invalid operand "
14083                                       "code 'f'");
14084               return;
14085             }
14086 #ifdef HAVE_AS_IX86_CMOV_SUN_SYNTAX
14087           if (ASSEMBLER_DIALECT == ASM_ATT)
14088             putc ('.', file);
14089 #endif
14090           put_condition_code (GET_CODE (x), GET_MODE (XEXP (x, 0)), 1, 1, file);
14091           return;
14092
14093         case 'H':
14094           /* It doesn't actually matter what mode we use here, as we're
14095              only going to use this for printing.  */
14096           x = adjust_address_nv (x, DImode, 8);
14097           break;
14098
14099         case '+':
14100           {
14101             rtx x;
14102
14103             if (!optimize
14104                 || optimize_function_for_size_p (cfun) || !TARGET_BRANCH_PREDICTION_HINTS)
14105               return;
14106
14107             x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
14108             if (x)
14109               {
14110                 int pred_val = INTVAL (XEXP (x, 0));
14111
14112                 if (pred_val < REG_BR_PROB_BASE * 45 / 100
14113                     || pred_val > REG_BR_PROB_BASE * 55 / 100)
14114                   {
14115                     int taken = pred_val > REG_BR_PROB_BASE / 2;
14116                     int cputaken = final_forward_branch_p (current_output_insn) == 0;
14117
14118                     /* Emit hints only in the case default branch prediction
14119                        heuristics would fail.  */
14120                     if (taken != cputaken)
14121                       {
14122                         /* We use 3e (DS) prefix for taken branches and
14123                            2e (CS) prefix for not taken branches.  */
14124                         if (taken)
14125                           fputs ("ds ; ", file);
14126                         else
14127                           fputs ("cs ; ", file);
14128                       }
14129                   }
14130               }
14131             return;
14132           }
14133
14134         case 'Y':
14135           switch (GET_CODE (x))
14136             {
14137             case NE:
14138               fputs ("neq", file);
14139               break;
14140             case EQ:
14141               fputs ("eq", file);
14142               break;
14143             case GE:
14144             case GEU:
14145               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "ge" : "unlt", file);
14146               break;
14147             case GT:
14148             case GTU:
14149               fputs (INTEGRAL_MODE_P (GET_MODE (x)) ? "gt" : "unle", file);
14150               break;
14151             case LE:
14152             case LEU:
14153               fputs ("le", file);
14154               break;
14155             case LT:
14156             case LTU:
14157               fputs ("lt", file);
14158               break;
14159             case UNORDERED:
14160               fputs ("unord", file);
14161               break;
14162             case ORDERED:
14163               fputs ("ord", file);
14164               break;
14165             case UNEQ:
14166               fputs ("ueq", file);
14167               break;
14168             case UNGE:
14169               fputs ("nlt", file);
14170               break;
14171             case UNGT:
14172               fputs ("nle", file);
14173               break;
14174             case UNLE:
14175               fputs ("ule", file);
14176               break;
14177             case UNLT:
14178               fputs ("ult", file);
14179               break;
14180             case LTGT:
14181               fputs ("une", file);
14182               break;
14183             default:
14184               output_operand_lossage ("operand is not a condition code, "
14185                                       "invalid operand code 'Y'");
14186               return;
14187             }
14188           return;
14189
14190         case ';':
14191 #ifndef HAVE_AS_IX86_REP_LOCK_PREFIX
14192           putc (';', file);
14193 #endif
14194           return;
14195
14196         case '@':
14197           if (ASSEMBLER_DIALECT == ASM_ATT)
14198             putc ('%', file);
14199
14200           /* The kernel uses a different segment register for performance
14201              reasons; a system call would not have to trash the userspace
14202              segment register, which would be expensive.  */
14203           if (TARGET_64BIT && ix86_cmodel != CM_KERNEL)
14204             fputs ("fs", file);
14205           else
14206             fputs ("gs", file);
14207           return;
14208
14209         case '~':
14210           putc (TARGET_AVX2 ? 'i' : 'f', file);
14211           return;
14212
14213         default:
14214             output_operand_lossage ("invalid operand code '%c'", code);
14215         }
14216     }
14217
14218   if (REG_P (x))
14219     print_reg (x, code, file);
14220
14221   else if (MEM_P (x))
14222     {
14223       /* No `byte ptr' prefix for call instructions or BLKmode operands.  */
14224       if (ASSEMBLER_DIALECT == ASM_INTEL && code != 'X' && code != 'P'
14225           && GET_MODE (x) != BLKmode)
14226         {
14227           const char * size;
14228           switch (GET_MODE_SIZE (GET_MODE (x)))
14229             {
14230             case 1: size = "BYTE"; break;
14231             case 2: size = "WORD"; break;
14232             case 4: size = "DWORD"; break;
14233             case 8: size = "QWORD"; break;
14234             case 12: size = "TBYTE"; break;
14235             case 16:
14236               if (GET_MODE (x) == XFmode)
14237                 size = "TBYTE";
14238               else
14239                 size = "XMMWORD";
14240               break;
14241             case 32: size = "YMMWORD"; break;
14242             default:
14243               gcc_unreachable ();
14244             }
14245
14246           /* Check for explicit size override (codes 'b', 'w', 'k',
14247              'q' and 'x')  */
14248           if (code == 'b')
14249             size = "BYTE";
14250           else if (code == 'w')
14251             size = "WORD";
14252           else if (code == 'k')
14253             size = "DWORD";
14254           else if (code == 'q')
14255             size = "QWORD";
14256           else if (code == 'x')
14257             size = "XMMWORD";
14258
14259           fputs (size, file);
14260           fputs (" PTR ", file);
14261         }
14262
14263       x = XEXP (x, 0);
14264       /* Avoid (%rip) for call operands.  */
14265       if (CONSTANT_ADDRESS_P (x) && code == 'P'
14266           && !CONST_INT_P (x))
14267         output_addr_const (file, x);
14268       else if (this_is_asm_operands && ! address_operand (x, VOIDmode))
14269         output_operand_lossage ("invalid constraints for operand");
14270       else
14271         output_address (x);
14272     }
14273
14274   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == SFmode)
14275     {
14276       REAL_VALUE_TYPE r;
14277       long l;
14278
14279       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14280       REAL_VALUE_TO_TARGET_SINGLE (r, l);
14281
14282       if (ASSEMBLER_DIALECT == ASM_ATT)
14283         putc ('$', file);
14284       /* Sign extend 32bit SFmode immediate to 8 bytes.  */
14285       if (code == 'q')
14286         fprintf (file, "0x%08llx", (unsigned long long) (int) l);
14287       else
14288         fprintf (file, "0x%08x", (unsigned int) l);
14289     }
14290
14291   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == DFmode)
14292     {
14293       REAL_VALUE_TYPE r;
14294       long l[2];
14295
14296       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
14297       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
14298
14299       if (ASSEMBLER_DIALECT == ASM_ATT)
14300         putc ('$', file);
14301       fprintf (file, "0x%lx%08lx", l[1] & 0xffffffff, l[0] & 0xffffffff);
14302     }
14303
14304   /* These float cases don't actually occur as immediate operands.  */
14305   else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == XFmode)
14306     {
14307       char dstr[30];
14308
14309       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (x), sizeof (dstr), 0, 1);
14310       fputs (dstr, file);
14311     }
14312
14313   else
14314     {
14315       /* We have patterns that allow zero sets of memory, for instance.
14316          In 64-bit mode, we should probably support all 8-byte vectors,
14317          since we can in fact encode that into an immediate.  */
14318       if (GET_CODE (x) == CONST_VECTOR)
14319         {
14320           gcc_assert (x == CONST0_RTX (GET_MODE (x)));
14321           x = const0_rtx;
14322         }
14323
14324       if (code != 'P' && code != 'p')
14325         {
14326           if (CONST_INT_P (x) || GET_CODE (x) == CONST_DOUBLE)
14327             {
14328               if (ASSEMBLER_DIALECT == ASM_ATT)
14329                 putc ('$', file);
14330             }
14331           else if (GET_CODE (x) == CONST || GET_CODE (x) == SYMBOL_REF
14332                    || GET_CODE (x) == LABEL_REF)
14333             {
14334               if (ASSEMBLER_DIALECT == ASM_ATT)
14335                 putc ('$', file);
14336               else
14337                 fputs ("OFFSET FLAT:", file);
14338             }
14339         }
14340       if (CONST_INT_P (x))
14341         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
14342       else if (flag_pic || MACHOPIC_INDIRECT)
14343         output_pic_addr_const (file, x, code);
14344       else
14345         output_addr_const (file, x);
14346     }
14347 }
14348
14349 static bool
14350 ix86_print_operand_punct_valid_p (unsigned char code)
14351 {
14352   return (code == '@' || code == '*' || code == '+'
14353           || code == '&' || code == ';' || code == '~');
14354 }
14355 \f
14356 /* Print a memory operand whose address is ADDR.  */
14357
14358 static void
14359 ix86_print_operand_address (FILE *file, rtx addr)
14360 {
14361   struct ix86_address parts;
14362   rtx base, index, disp;
14363   int scale;
14364   int ok;
14365   bool vsib = false;
14366
14367   if (GET_CODE (addr) == UNSPEC && XINT (addr, 1) == UNSPEC_VSIBADDR)
14368     {
14369       ok = ix86_decompose_address (XVECEXP (addr, 0, 0), &parts);
14370       gcc_assert (parts.index == NULL_RTX);
14371       parts.index = XVECEXP (addr, 0, 1);
14372       parts.scale = INTVAL (XVECEXP (addr, 0, 2));
14373       addr = XVECEXP (addr, 0, 0);
14374       vsib = true;
14375     }
14376   else
14377     ok = ix86_decompose_address (addr, &parts);
14378
14379   gcc_assert (ok);
14380
14381   if (parts.base && GET_CODE (parts.base) == SUBREG)
14382     {
14383       rtx tmp = SUBREG_REG (parts.base);
14384       parts.base = simplify_subreg (GET_MODE (parts.base),
14385                                     tmp, GET_MODE (tmp), 0);
14386     }
14387
14388   if (parts.index && GET_CODE (parts.index) == SUBREG)
14389     {
14390       rtx tmp = SUBREG_REG (parts.index);
14391       parts.index = simplify_subreg (GET_MODE (parts.index),
14392                                      tmp, GET_MODE (tmp), 0);
14393     }
14394
14395   base = parts.base;
14396   index = parts.index;
14397   disp = parts.disp;
14398   scale = parts.scale;
14399
14400   switch (parts.seg)
14401     {
14402     case SEG_DEFAULT:
14403       break;
14404     case SEG_FS:
14405     case SEG_GS:
14406       if (ASSEMBLER_DIALECT == ASM_ATT)
14407         putc ('%', file);
14408       fputs ((parts.seg == SEG_FS ? "fs:" : "gs:"), file);
14409       break;
14410     default:
14411       gcc_unreachable ();
14412     }
14413
14414   /* Use one byte shorter RIP relative addressing for 64bit mode.  */
14415   if (TARGET_64BIT && !base && !index)
14416     {
14417       rtx symbol = disp;
14418
14419       if (GET_CODE (disp) == CONST
14420           && GET_CODE (XEXP (disp, 0)) == PLUS
14421           && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14422         symbol = XEXP (XEXP (disp, 0), 0);
14423
14424       if (GET_CODE (symbol) == LABEL_REF
14425           || (GET_CODE (symbol) == SYMBOL_REF
14426               && SYMBOL_REF_TLS_MODEL (symbol) == 0))
14427         base = pc_rtx;
14428     }
14429   if (!base && !index)
14430     {
14431       /* Displacement only requires special attention.  */
14432
14433       if (CONST_INT_P (disp))
14434         {
14435           if (ASSEMBLER_DIALECT == ASM_INTEL && parts.seg == SEG_DEFAULT)
14436             fputs ("ds:", file);
14437           fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (disp));
14438         }
14439       else if (flag_pic)
14440         output_pic_addr_const (file, disp, 0);
14441       else
14442         output_addr_const (file, disp);
14443     }
14444   else
14445     {
14446       int code = 0;
14447
14448       /* Print SImode registers for zero-extended addresses to force
14449          addr32 prefix.  Otherwise print DImode registers to avoid it.  */
14450       if (TARGET_64BIT)
14451         code = ((GET_CODE (addr) == ZERO_EXTEND
14452                  || GET_CODE (addr) == AND)
14453                 ? 'l'
14454                 : 'q');
14455
14456       if (ASSEMBLER_DIALECT == ASM_ATT)
14457         {
14458           if (disp)
14459             {
14460               if (flag_pic)
14461                 output_pic_addr_const (file, disp, 0);
14462               else if (GET_CODE (disp) == LABEL_REF)
14463                 output_asm_label (disp);
14464               else
14465                 output_addr_const (file, disp);
14466             }
14467
14468           putc ('(', file);
14469           if (base)
14470             print_reg (base, code, file);
14471           if (index)
14472             {
14473               putc (',', file);
14474               print_reg (index, vsib ? 0 : code, file);
14475               if (scale != 1 || vsib)
14476                 fprintf (file, ",%d", scale);
14477             }
14478           putc (')', file);
14479         }
14480       else
14481         {
14482           rtx offset = NULL_RTX;
14483
14484           if (disp)
14485             {
14486               /* Pull out the offset of a symbol; print any symbol itself.  */
14487               if (GET_CODE (disp) == CONST
14488                   && GET_CODE (XEXP (disp, 0)) == PLUS
14489                   && CONST_INT_P (XEXP (XEXP (disp, 0), 1)))
14490                 {
14491                   offset = XEXP (XEXP (disp, 0), 1);
14492                   disp = gen_rtx_CONST (VOIDmode,
14493                                         XEXP (XEXP (disp, 0), 0));
14494                 }
14495
14496               if (flag_pic)
14497                 output_pic_addr_const (file, disp, 0);
14498               else if (GET_CODE (disp) == LABEL_REF)
14499                 output_asm_label (disp);
14500               else if (CONST_INT_P (disp))
14501                 offset = disp;
14502               else
14503                 output_addr_const (file, disp);
14504             }
14505
14506           putc ('[', file);
14507           if (base)
14508             {
14509               print_reg (base, code, file);
14510               if (offset)
14511                 {
14512                   if (INTVAL (offset) >= 0)
14513                     putc ('+', file);
14514                   fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14515                 }
14516             }
14517           else if (offset)
14518             fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (offset));
14519           else
14520             putc ('0', file);
14521
14522           if (index)
14523             {
14524               putc ('+', file);
14525               print_reg (index, vsib ? 0 : code, file);
14526               if (scale != 1 || vsib)
14527                 fprintf (file, "*%d", scale);
14528             }
14529           putc (']', file);
14530         }
14531     }
14532 }
14533
14534 /* Implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA.  */
14535
14536 static bool
14537 i386_asm_output_addr_const_extra (FILE *file, rtx x)
14538 {
14539   rtx op;
14540
14541   if (GET_CODE (x) != UNSPEC)
14542     return false;
14543
14544   op = XVECEXP (x, 0, 0);
14545   switch (XINT (x, 1))
14546     {
14547     case UNSPEC_GOTTPOFF:
14548       output_addr_const (file, op);
14549       /* FIXME: This might be @TPOFF in Sun ld.  */
14550       fputs ("@gottpoff", file);
14551       break;
14552     case UNSPEC_TPOFF:
14553       output_addr_const (file, op);
14554       fputs ("@tpoff", file);
14555       break;
14556     case UNSPEC_NTPOFF:
14557       output_addr_const (file, op);
14558       if (TARGET_64BIT)
14559         fputs ("@tpoff", file);
14560       else
14561         fputs ("@ntpoff", file);
14562       break;
14563     case UNSPEC_DTPOFF:
14564       output_addr_const (file, op);
14565       fputs ("@dtpoff", file);
14566       break;
14567     case UNSPEC_GOTNTPOFF:
14568       output_addr_const (file, op);
14569       if (TARGET_64BIT)
14570         fputs (ASSEMBLER_DIALECT == ASM_ATT ?
14571                "@gottpoff(%rip)" : "@gottpoff[rip]", file);
14572       else
14573         fputs ("@gotntpoff", file);
14574       break;
14575     case UNSPEC_INDNTPOFF:
14576       output_addr_const (file, op);
14577       fputs ("@indntpoff", file);
14578       break;
14579 #if TARGET_MACHO
14580     case UNSPEC_MACHOPIC_OFFSET:
14581       output_addr_const (file, op);
14582       putc ('-', file);
14583       machopic_output_function_base_name (file);
14584       break;
14585 #endif
14586
14587     case UNSPEC_STACK_CHECK:
14588       {
14589         int offset;
14590
14591         gcc_assert (flag_split_stack);
14592
14593 #ifdef TARGET_THREAD_SPLIT_STACK_OFFSET
14594         offset = TARGET_THREAD_SPLIT_STACK_OFFSET;
14595 #else
14596         gcc_unreachable ();
14597 #endif
14598
14599         fprintf (file, "%s:%d", TARGET_64BIT ? "%fs" : "%gs", offset);
14600       }
14601       break;
14602
14603     default:
14604       return false;
14605     }
14606
14607   return true;
14608 }
14609 \f
14610 /* Split one or more double-mode RTL references into pairs of half-mode
14611    references.  The RTL can be REG, offsettable MEM, integer constant, or
14612    CONST_DOUBLE.  "operands" is a pointer to an array of double-mode RTLs to
14613    split and "num" is its length.  lo_half and hi_half are output arrays
14614    that parallel "operands".  */
14615
14616 void
14617 split_double_mode (enum machine_mode mode, rtx operands[],
14618                    int num, rtx lo_half[], rtx hi_half[])
14619 {
14620   enum machine_mode half_mode;
14621   unsigned int byte;
14622
14623   switch (mode)
14624     {
14625     case TImode:
14626       half_mode = DImode;
14627       break;
14628     case DImode:
14629       half_mode = SImode;
14630       break;
14631     default:
14632       gcc_unreachable ();
14633     }
14634
14635   byte = GET_MODE_SIZE (half_mode);
14636
14637   while (num--)
14638     {
14639       rtx op = operands[num];
14640
14641       /* simplify_subreg refuse to split volatile memory addresses,
14642          but we still have to handle it.  */
14643       if (MEM_P (op))
14644         {
14645           lo_half[num] = adjust_address (op, half_mode, 0);
14646           hi_half[num] = adjust_address (op, half_mode, byte);
14647         }
14648       else
14649         {
14650           lo_half[num] = simplify_gen_subreg (half_mode, op,
14651                                               GET_MODE (op) == VOIDmode
14652                                               ? mode : GET_MODE (op), 0);
14653           hi_half[num] = simplify_gen_subreg (half_mode, op,
14654                                               GET_MODE (op) == VOIDmode
14655                                               ? mode : GET_MODE (op), byte);
14656         }
14657     }
14658 }
14659 \f
14660 /* Output code to perform a 387 binary operation in INSN, one of PLUS,
14661    MINUS, MULT or DIV.  OPERANDS are the insn operands, where operands[3]
14662    is the expression of the binary operation.  The output may either be
14663    emitted here, or returned to the caller, like all output_* functions.
14664
14665    There is no guarantee that the operands are the same mode, as they
14666    might be within FLOAT or FLOAT_EXTEND expressions.  */
14667
14668 #ifndef SYSV386_COMPAT
14669 /* Set to 1 for compatibility with brain-damaged assemblers.  No-one
14670    wants to fix the assemblers because that causes incompatibility
14671    with gcc.  No-one wants to fix gcc because that causes
14672    incompatibility with assemblers...  You can use the option of
14673    -DSYSV386_COMPAT=0 if you recompile both gcc and gas this way.  */
14674 #define SYSV386_COMPAT 1
14675 #endif
14676
14677 const char *
14678 output_387_binary_op (rtx insn, rtx *operands)
14679 {
14680   static char buf[40];
14681   const char *p;
14682   const char *ssep;
14683   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]) || SSE_REG_P (operands[2]);
14684
14685 #ifdef ENABLE_CHECKING
14686   /* Even if we do not want to check the inputs, this documents input
14687      constraints.  Which helps in understanding the following code.  */
14688   if (STACK_REG_P (operands[0])
14689       && ((REG_P (operands[1])
14690            && REGNO (operands[0]) == REGNO (operands[1])
14691            && (STACK_REG_P (operands[2]) || MEM_P (operands[2])))
14692           || (REG_P (operands[2])
14693               && REGNO (operands[0]) == REGNO (operands[2])
14694               && (STACK_REG_P (operands[1]) || MEM_P (operands[1]))))
14695       && (STACK_TOP_P (operands[1]) || STACK_TOP_P (operands[2])))
14696     ; /* ok */
14697   else
14698     gcc_assert (is_sse);
14699 #endif
14700
14701   switch (GET_CODE (operands[3]))
14702     {
14703     case PLUS:
14704       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14705           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14706         p = "fiadd";
14707       else
14708         p = "fadd";
14709       ssep = "vadd";
14710       break;
14711
14712     case MINUS:
14713       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14714           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14715         p = "fisub";
14716       else
14717         p = "fsub";
14718       ssep = "vsub";
14719       break;
14720
14721     case MULT:
14722       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14723           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14724         p = "fimul";
14725       else
14726         p = "fmul";
14727       ssep = "vmul";
14728       break;
14729
14730     case DIV:
14731       if (GET_MODE_CLASS (GET_MODE (operands[1])) == MODE_INT
14732           || GET_MODE_CLASS (GET_MODE (operands[2])) == MODE_INT)
14733         p = "fidiv";
14734       else
14735         p = "fdiv";
14736       ssep = "vdiv";
14737       break;
14738
14739     default:
14740       gcc_unreachable ();
14741     }
14742
14743   if (is_sse)
14744    {
14745      if (TARGET_AVX)
14746        {
14747          strcpy (buf, ssep);
14748          if (GET_MODE (operands[0]) == SFmode)
14749            strcat (buf, "ss\t{%2, %1, %0|%0, %1, %2}");
14750          else
14751            strcat (buf, "sd\t{%2, %1, %0|%0, %1, %2}");
14752        }
14753      else
14754        {
14755          strcpy (buf, ssep + 1);
14756          if (GET_MODE (operands[0]) == SFmode)
14757            strcat (buf, "ss\t{%2, %0|%0, %2}");
14758          else
14759            strcat (buf, "sd\t{%2, %0|%0, %2}");
14760        }
14761       return buf;
14762    }
14763   strcpy (buf, p);
14764
14765   switch (GET_CODE (operands[3]))
14766     {
14767     case MULT:
14768     case PLUS:
14769       if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
14770         {
14771           rtx temp = operands[2];
14772           operands[2] = operands[1];
14773           operands[1] = temp;
14774         }
14775
14776       /* know operands[0] == operands[1].  */
14777
14778       if (MEM_P (operands[2]))
14779         {
14780           p = "%Z2\t%2";
14781           break;
14782         }
14783
14784       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14785         {
14786           if (STACK_TOP_P (operands[0]))
14787             /* How is it that we are storing to a dead operand[2]?
14788                Well, presumably operands[1] is dead too.  We can't
14789                store the result to st(0) as st(0) gets popped on this
14790                instruction.  Instead store to operands[2] (which I
14791                think has to be st(1)).  st(1) will be popped later.
14792                gcc <= 2.8.1 didn't have this check and generated
14793                assembly code that the Unixware assembler rejected.  */
14794             p = "p\t{%0, %2|%2, %0}";   /* st(1) = st(0) op st(1); pop */
14795           else
14796             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14797           break;
14798         }
14799
14800       if (STACK_TOP_P (operands[0]))
14801         p = "\t{%y2, %0|%0, %y2}";      /* st(0) = st(0) op st(r2) */
14802       else
14803         p = "\t{%2, %0|%0, %2}";        /* st(r1) = st(r1) op st(0) */
14804       break;
14805
14806     case MINUS:
14807     case DIV:
14808       if (MEM_P (operands[1]))
14809         {
14810           p = "r%Z1\t%1";
14811           break;
14812         }
14813
14814       if (MEM_P (operands[2]))
14815         {
14816           p = "%Z2\t%2";
14817           break;
14818         }
14819
14820       if (find_regno_note (insn, REG_DEAD, REGNO (operands[2])))
14821         {
14822 #if SYSV386_COMPAT
14823           /* The SystemV/386 SVR3.2 assembler, and probably all AT&T
14824              derived assemblers, confusingly reverse the direction of
14825              the operation for fsub{r} and fdiv{r} when the
14826              destination register is not st(0).  The Intel assembler
14827              doesn't have this brain damage.  Read !SYSV386_COMPAT to
14828              figure out what the hardware really does.  */
14829           if (STACK_TOP_P (operands[0]))
14830             p = "{p\t%0, %2|rp\t%2, %0}";
14831           else
14832             p = "{rp\t%2, %0|p\t%0, %2}";
14833 #else
14834           if (STACK_TOP_P (operands[0]))
14835             /* As above for fmul/fadd, we can't store to st(0).  */
14836             p = "rp\t{%0, %2|%2, %0}";  /* st(1) = st(0) op st(1); pop */
14837           else
14838             p = "p\t{%2, %0|%0, %2}";   /* st(r1) = st(r1) op st(0); pop */
14839 #endif
14840           break;
14841         }
14842
14843       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
14844         {
14845 #if SYSV386_COMPAT
14846           if (STACK_TOP_P (operands[0]))
14847             p = "{rp\t%0, %1|p\t%1, %0}";
14848           else
14849             p = "{p\t%1, %0|rp\t%0, %1}";
14850 #else
14851           if (STACK_TOP_P (operands[0]))
14852             p = "p\t{%0, %1|%1, %0}";   /* st(1) = st(1) op st(0); pop */
14853           else
14854             p = "rp\t{%1, %0|%0, %1}";  /* st(r2) = st(0) op st(r2); pop */
14855 #endif
14856           break;
14857         }
14858
14859       if (STACK_TOP_P (operands[0]))
14860         {
14861           if (STACK_TOP_P (operands[1]))
14862             p = "\t{%y2, %0|%0, %y2}";  /* st(0) = st(0) op st(r2) */
14863           else
14864             p = "r\t{%y1, %0|%0, %y1}"; /* st(0) = st(r1) op st(0) */
14865           break;
14866         }
14867       else if (STACK_TOP_P (operands[1]))
14868         {
14869 #if SYSV386_COMPAT
14870           p = "{\t%1, %0|r\t%0, %1}";
14871 #else
14872           p = "r\t{%1, %0|%0, %1}";     /* st(r2) = st(0) op st(r2) */
14873 #endif
14874         }
14875       else
14876         {
14877 #if SYSV386_COMPAT
14878           p = "{r\t%2, %0|\t%0, %2}";
14879 #else
14880           p = "\t{%2, %0|%0, %2}";      /* st(r1) = st(r1) op st(0) */
14881 #endif
14882         }
14883       break;
14884
14885     default:
14886       gcc_unreachable ();
14887     }
14888
14889   strcat (buf, p);
14890   return buf;
14891 }
14892
14893 /* Return needed mode for entity in optimize_mode_switching pass.  */
14894
14895 int
14896 ix86_mode_needed (int entity, rtx insn)
14897 {
14898   enum attr_i387_cw mode;
14899
14900   /* The mode UNINITIALIZED is used to store control word after a
14901      function call or ASM pattern.  The mode ANY specify that function
14902      has no requirements on the control word and make no changes in the
14903      bits we are interested in.  */
14904
14905   if (CALL_P (insn)
14906       || (NONJUMP_INSN_P (insn)
14907           && (asm_noperands (PATTERN (insn)) >= 0
14908               || GET_CODE (PATTERN (insn)) == ASM_INPUT)))
14909     return I387_CW_UNINITIALIZED;
14910
14911   if (recog_memoized (insn) < 0)
14912     return I387_CW_ANY;
14913
14914   mode = get_attr_i387_cw (insn);
14915
14916   switch (entity)
14917     {
14918     case I387_TRUNC:
14919       if (mode == I387_CW_TRUNC)
14920         return mode;
14921       break;
14922
14923     case I387_FLOOR:
14924       if (mode == I387_CW_FLOOR)
14925         return mode;
14926       break;
14927
14928     case I387_CEIL:
14929       if (mode == I387_CW_CEIL)
14930         return mode;
14931       break;
14932
14933     case I387_MASK_PM:
14934       if (mode == I387_CW_MASK_PM)
14935         return mode;
14936       break;
14937
14938     default:
14939       gcc_unreachable ();
14940     }
14941
14942   return I387_CW_ANY;
14943 }
14944
14945 /* Output code to initialize control word copies used by trunc?f?i and
14946    rounding patterns.  CURRENT_MODE is set to current control word,
14947    while NEW_MODE is set to new control word.  */
14948
14949 void
14950 emit_i387_cw_initialization (int mode)
14951 {
14952   rtx stored_mode = assign_386_stack_local (HImode, SLOT_CW_STORED);
14953   rtx new_mode;
14954
14955   enum ix86_stack_slot slot;
14956
14957   rtx reg = gen_reg_rtx (HImode);
14958
14959   emit_insn (gen_x86_fnstcw_1 (stored_mode));
14960   emit_move_insn (reg, copy_rtx (stored_mode));
14961
14962   if (TARGET_64BIT || TARGET_PARTIAL_REG_STALL
14963       || optimize_function_for_size_p (cfun))
14964     {
14965       switch (mode)
14966         {
14967         case I387_CW_TRUNC:
14968           /* round toward zero (truncate) */
14969           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0c00)));
14970           slot = SLOT_CW_TRUNC;
14971           break;
14972
14973         case I387_CW_FLOOR:
14974           /* round down toward -oo */
14975           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14976           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0400)));
14977           slot = SLOT_CW_FLOOR;
14978           break;
14979
14980         case I387_CW_CEIL:
14981           /* round up toward +oo */
14982           emit_insn (gen_andhi3 (reg, reg, GEN_INT (~0x0c00)));
14983           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0800)));
14984           slot = SLOT_CW_CEIL;
14985           break;
14986
14987         case I387_CW_MASK_PM:
14988           /* mask precision exception for nearbyint() */
14989           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
14990           slot = SLOT_CW_MASK_PM;
14991           break;
14992
14993         default:
14994           gcc_unreachable ();
14995         }
14996     }
14997   else
14998     {
14999       switch (mode)
15000         {
15001         case I387_CW_TRUNC:
15002           /* round toward zero (truncate) */
15003           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0xc)));
15004           slot = SLOT_CW_TRUNC;
15005           break;
15006
15007         case I387_CW_FLOOR:
15008           /* round down toward -oo */
15009           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x4)));
15010           slot = SLOT_CW_FLOOR;
15011           break;
15012
15013         case I387_CW_CEIL:
15014           /* round up toward +oo */
15015           emit_insn (gen_movsi_insv_1 (reg, GEN_INT (0x8)));
15016           slot = SLOT_CW_CEIL;
15017           break;
15018
15019         case I387_CW_MASK_PM:
15020           /* mask precision exception for nearbyint() */
15021           emit_insn (gen_iorhi3 (reg, reg, GEN_INT (0x0020)));
15022           slot = SLOT_CW_MASK_PM;
15023           break;
15024
15025         default:
15026           gcc_unreachable ();
15027         }
15028     }
15029
15030   gcc_assert (slot < MAX_386_STACK_LOCALS);
15031
15032   new_mode = assign_386_stack_local (HImode, slot);
15033   emit_move_insn (new_mode, reg);
15034 }
15035
15036 /* Output code for INSN to convert a float to a signed int.  OPERANDS
15037    are the insn operands.  The output may be [HSD]Imode and the input
15038    operand may be [SDX]Fmode.  */
15039
15040 const char *
15041 output_fix_trunc (rtx insn, rtx *operands, bool fisttp)
15042 {
15043   int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
15044   int dimode_p = GET_MODE (operands[0]) == DImode;
15045   int round_mode = get_attr_i387_cw (insn);
15046
15047   /* Jump through a hoop or two for DImode, since the hardware has no
15048      non-popping instruction.  We used to do this a different way, but
15049      that was somewhat fragile and broke with post-reload splitters.  */
15050   if ((dimode_p || fisttp) && !stack_top_dies)
15051     output_asm_insn ("fld\t%y1", operands);
15052
15053   gcc_assert (STACK_TOP_P (operands[1]));
15054   gcc_assert (MEM_P (operands[0]));
15055   gcc_assert (GET_MODE (operands[1]) != TFmode);
15056
15057   if (fisttp)
15058       output_asm_insn ("fisttp%Z0\t%0", operands);
15059   else
15060     {
15061       if (round_mode != I387_CW_ANY)
15062         output_asm_insn ("fldcw\t%3", operands);
15063       if (stack_top_dies || dimode_p)
15064         output_asm_insn ("fistp%Z0\t%0", operands);
15065       else
15066         output_asm_insn ("fist%Z0\t%0", operands);
15067       if (round_mode != I387_CW_ANY)
15068         output_asm_insn ("fldcw\t%2", operands);
15069     }
15070
15071   return "";
15072 }
15073
15074 /* Output code for x87 ffreep insn.  The OPNO argument, which may only
15075    have the values zero or one, indicates the ffreep insn's operand
15076    from the OPERANDS array.  */
15077
15078 static const char *
15079 output_387_ffreep (rtx *operands ATTRIBUTE_UNUSED, int opno)
15080 {
15081   if (TARGET_USE_FFREEP)
15082 #ifdef HAVE_AS_IX86_FFREEP
15083     return opno ? "ffreep\t%y1" : "ffreep\t%y0";
15084 #else
15085     {
15086       static char retval[32];
15087       int regno = REGNO (operands[opno]);
15088
15089       gcc_assert (FP_REGNO_P (regno));
15090
15091       regno -= FIRST_STACK_REG;
15092
15093       snprintf (retval, sizeof (retval), ASM_SHORT "0xc%ddf", regno);
15094       return retval;
15095     }
15096 #endif
15097
15098   return opno ? "fstp\t%y1" : "fstp\t%y0";
15099 }
15100
15101
15102 /* Output code for INSN to compare OPERANDS.  EFLAGS_P is 1 when fcomi
15103    should be used.  UNORDERED_P is true when fucom should be used.  */
15104
15105 const char *
15106 output_fp_compare (rtx insn, rtx *operands, bool eflags_p, bool unordered_p)
15107 {
15108   int stack_top_dies;
15109   rtx cmp_op0, cmp_op1;
15110   int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]);
15111
15112   if (eflags_p)
15113     {
15114       cmp_op0 = operands[0];
15115       cmp_op1 = operands[1];
15116     }
15117   else
15118     {
15119       cmp_op0 = operands[1];
15120       cmp_op1 = operands[2];
15121     }
15122
15123   if (is_sse)
15124     {
15125       if (GET_MODE (operands[0]) == SFmode)
15126         if (unordered_p)
15127           return "%vucomiss\t{%1, %0|%0, %1}";
15128         else
15129           return "%vcomiss\t{%1, %0|%0, %1}";
15130       else
15131         if (unordered_p)
15132           return "%vucomisd\t{%1, %0|%0, %1}";
15133         else
15134           return "%vcomisd\t{%1, %0|%0, %1}";
15135     }
15136
15137   gcc_assert (STACK_TOP_P (cmp_op0));
15138
15139   stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
15140
15141   if (cmp_op1 == CONST0_RTX (GET_MODE (cmp_op1)))
15142     {
15143       if (stack_top_dies)
15144         {
15145           output_asm_insn ("ftst\n\tfnstsw\t%0", operands);
15146           return output_387_ffreep (operands, 1);
15147         }
15148       else
15149         return "ftst\n\tfnstsw\t%0";
15150     }
15151
15152   if (STACK_REG_P (cmp_op1)
15153       && stack_top_dies
15154       && find_regno_note (insn, REG_DEAD, REGNO (cmp_op1))
15155       && REGNO (cmp_op1) != FIRST_STACK_REG)
15156     {
15157       /* If both the top of the 387 stack dies, and the other operand
15158          is also a stack register that dies, then this must be a
15159          `fcompp' float compare */
15160
15161       if (eflags_p)
15162         {
15163           /* There is no double popping fcomi variant.  Fortunately,
15164              eflags is immune from the fstp's cc clobbering.  */
15165           if (unordered_p)
15166             output_asm_insn ("fucomip\t{%y1, %0|%0, %y1}", operands);
15167           else
15168             output_asm_insn ("fcomip\t{%y1, %0|%0, %y1}", operands);
15169           return output_387_ffreep (operands, 0);
15170         }
15171       else
15172         {
15173           if (unordered_p)
15174             return "fucompp\n\tfnstsw\t%0";
15175           else
15176             return "fcompp\n\tfnstsw\t%0";
15177         }
15178     }
15179   else
15180     {
15181       /* Encoded here as eflags_p | intmode | unordered_p | stack_top_dies.  */
15182
15183       static const char * const alt[16] =
15184       {
15185         "fcom%Z2\t%y2\n\tfnstsw\t%0",
15186         "fcomp%Z2\t%y2\n\tfnstsw\t%0",
15187         "fucom%Z2\t%y2\n\tfnstsw\t%0",
15188         "fucomp%Z2\t%y2\n\tfnstsw\t%0",
15189
15190         "ficom%Z2\t%y2\n\tfnstsw\t%0",
15191         "ficomp%Z2\t%y2\n\tfnstsw\t%0",
15192         NULL,
15193         NULL,
15194
15195         "fcomi\t{%y1, %0|%0, %y1}",
15196         "fcomip\t{%y1, %0|%0, %y1}",
15197         "fucomi\t{%y1, %0|%0, %y1}",
15198         "fucomip\t{%y1, %0|%0, %y1}",
15199
15200         NULL,
15201         NULL,
15202         NULL,
15203         NULL
15204       };
15205
15206       int mask;
15207       const char *ret;
15208
15209       mask  = eflags_p << 3;
15210       mask |= (GET_MODE_CLASS (GET_MODE (cmp_op1)) == MODE_INT) << 2;
15211       mask |= unordered_p << 1;
15212       mask |= stack_top_dies;
15213
15214       gcc_assert (mask < 16);
15215       ret = alt[mask];
15216       gcc_assert (ret);
15217
15218       return ret;
15219     }
15220 }
15221
15222 void
15223 ix86_output_addr_vec_elt (FILE *file, int value)
15224 {
15225   const char *directive = ASM_LONG;
15226
15227 #ifdef ASM_QUAD
15228   if (TARGET_LP64)
15229     directive = ASM_QUAD;
15230 #else
15231   gcc_assert (!TARGET_64BIT);
15232 #endif
15233
15234   fprintf (file, "%s%s%d\n", directive, LPREFIX, value);
15235 }
15236
15237 void
15238 ix86_output_addr_diff_elt (FILE *file, int value, int rel)
15239 {
15240   const char *directive = ASM_LONG;
15241
15242 #ifdef ASM_QUAD
15243   if (TARGET_64BIT && CASE_VECTOR_MODE == DImode)
15244     directive = ASM_QUAD;
15245 #else
15246   gcc_assert (!TARGET_64BIT);
15247 #endif
15248   /* We can't use @GOTOFF for text labels on VxWorks; see gotoff_operand.  */
15249   if (TARGET_64BIT || TARGET_VXWORKS_RTP)
15250     fprintf (file, "%s%s%d-%s%d\n",
15251              directive, LPREFIX, value, LPREFIX, rel);
15252   else if (HAVE_AS_GOTOFF_IN_DATA)
15253     fprintf (file, ASM_LONG "%s%d@GOTOFF\n", LPREFIX, value);
15254 #if TARGET_MACHO
15255   else if (TARGET_MACHO)
15256     {
15257       fprintf (file, ASM_LONG "%s%d-", LPREFIX, value);
15258       machopic_output_function_base_name (file);
15259       putc ('\n', file);
15260     }
15261 #endif
15262   else
15263     asm_fprintf (file, ASM_LONG "%U%s+[.-%s%d]\n",
15264                  GOT_SYMBOL_NAME, LPREFIX, value);
15265 }
15266 \f
15267 /* Generate either "mov $0, reg" or "xor reg, reg", as appropriate
15268    for the target.  */
15269
15270 void
15271 ix86_expand_clear (rtx dest)
15272 {
15273   rtx tmp;
15274
15275   /* We play register width games, which are only valid after reload.  */
15276   gcc_assert (reload_completed);
15277
15278   /* Avoid HImode and its attendant prefix byte.  */
15279   if (GET_MODE_SIZE (GET_MODE (dest)) < 4)
15280     dest = gen_rtx_REG (SImode, REGNO (dest));
15281   tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx);
15282
15283   /* This predicate should match that for movsi_xor and movdi_xor_rex64.  */
15284   if (!TARGET_USE_MOV0 || optimize_insn_for_speed_p ())
15285     {
15286       rtx clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
15287       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, clob));
15288     }
15289
15290   emit_insn (tmp);
15291 }
15292
15293 /* X is an unchanging MEM.  If it is a constant pool reference, return
15294    the constant pool rtx, else NULL.  */
15295
15296 rtx
15297 maybe_get_pool_constant (rtx x)
15298 {
15299   x = ix86_delegitimize_address (XEXP (x, 0));
15300
15301   if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
15302     return get_pool_constant (x);
15303
15304   return NULL_RTX;
15305 }
15306
15307 void
15308 ix86_expand_move (enum machine_mode mode, rtx operands[])
15309 {
15310   rtx op0, op1;
15311   enum tls_model model;
15312
15313   op0 = operands[0];
15314   op1 = operands[1];
15315
15316   if (GET_CODE (op1) == SYMBOL_REF)
15317     {
15318       model = SYMBOL_REF_TLS_MODEL (op1);
15319       if (model)
15320         {
15321           op1 = legitimize_tls_address (op1, model, true);
15322           op1 = force_operand (op1, op0);
15323           if (op1 == op0)
15324             return;
15325           if (GET_MODE (op1) != mode)
15326             op1 = convert_to_mode (mode, op1, 1);
15327         }
15328       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15329                && SYMBOL_REF_DLLIMPORT_P (op1))
15330         op1 = legitimize_dllimport_symbol (op1, false);
15331     }
15332   else if (GET_CODE (op1) == CONST
15333            && GET_CODE (XEXP (op1, 0)) == PLUS
15334            && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SYMBOL_REF)
15335     {
15336       rtx addend = XEXP (XEXP (op1, 0), 1);
15337       rtx symbol = XEXP (XEXP (op1, 0), 0);
15338       rtx tmp = NULL;
15339
15340       model = SYMBOL_REF_TLS_MODEL (symbol);
15341       if (model)
15342         tmp = legitimize_tls_address (symbol, model, true);
15343       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
15344                && SYMBOL_REF_DLLIMPORT_P (symbol))
15345         tmp = legitimize_dllimport_symbol (symbol, true);
15346
15347       if (tmp)
15348         {
15349           tmp = force_operand (tmp, NULL);
15350           tmp = expand_simple_binop (Pmode, PLUS, tmp, addend,
15351                                      op0, 1, OPTAB_DIRECT);
15352           if (tmp == op0)
15353             return;
15354           if (GET_MODE (tmp) != mode)
15355             op1 = convert_to_mode (mode, tmp, 1);
15356         }
15357     }
15358
15359   if ((flag_pic || MACHOPIC_INDIRECT)
15360       && symbolic_operand (op1, mode))
15361     {
15362       if (TARGET_MACHO && !TARGET_64BIT)
15363         {
15364 #if TARGET_MACHO
15365           /* dynamic-no-pic */
15366           if (MACHOPIC_INDIRECT)
15367             {
15368               rtx temp = ((reload_in_progress
15369                            || ((op0 && REG_P (op0))
15370                                && mode == Pmode))
15371                           ? op0 : gen_reg_rtx (Pmode));
15372               op1 = machopic_indirect_data_reference (op1, temp);
15373               if (MACHOPIC_PURE)
15374                 op1 = machopic_legitimize_pic_address (op1, mode,
15375                                                        temp == op1 ? 0 : temp);
15376             }
15377           if (op0 != op1 && GET_CODE (op0) != MEM)
15378             {
15379               rtx insn = gen_rtx_SET (VOIDmode, op0, op1);
15380               emit_insn (insn);
15381               return;
15382             }
15383           if (GET_CODE (op0) == MEM)
15384             op1 = force_reg (Pmode, op1);
15385           else
15386             {
15387               rtx temp = op0;
15388               if (GET_CODE (temp) != REG)
15389                 temp = gen_reg_rtx (Pmode);
15390               temp = legitimize_pic_address (op1, temp);
15391               if (temp == op0)
15392             return;
15393               op1 = temp;
15394             }
15395       /* dynamic-no-pic */
15396 #endif
15397         }
15398       else
15399         {
15400           if (MEM_P (op0))
15401             op1 = force_reg (mode, op1);
15402           else if (!(TARGET_64BIT && x86_64_movabs_operand (op1, DImode)))
15403             {
15404               rtx reg = can_create_pseudo_p () ? NULL_RTX : op0;
15405               op1 = legitimize_pic_address (op1, reg);
15406               if (op0 == op1)
15407                 return;
15408               if (GET_MODE (op1) != mode)
15409                 op1 = convert_to_mode (mode, op1, 1);
15410             }
15411         }
15412     }
15413   else
15414     {
15415       if (MEM_P (op0)
15416           && (PUSH_ROUNDING (GET_MODE_SIZE (mode)) != GET_MODE_SIZE (mode)
15417               || !push_operand (op0, mode))
15418           && MEM_P (op1))
15419         op1 = force_reg (mode, op1);
15420
15421       if (push_operand (op0, mode)
15422           && ! general_no_elim_operand (op1, mode))
15423         op1 = copy_to_mode_reg (mode, op1);
15424
15425       /* Force large constants in 64bit compilation into register
15426          to get them CSEed.  */
15427       if (can_create_pseudo_p ()
15428           && (mode == DImode) && TARGET_64BIT
15429           && immediate_operand (op1, mode)
15430           && !x86_64_zext_immediate_operand (op1, VOIDmode)
15431           && !register_operand (op0, mode)
15432           && optimize)
15433         op1 = copy_to_mode_reg (mode, op1);
15434
15435       if (can_create_pseudo_p ()
15436           && FLOAT_MODE_P (mode)
15437           && GET_CODE (op1) == CONST_DOUBLE)
15438         {
15439           /* If we are loading a floating point constant to a register,
15440              force the value to memory now, since we'll get better code
15441              out the back end.  */
15442
15443           op1 = validize_mem (force_const_mem (mode, op1));
15444           if (!register_operand (op0, mode))
15445             {
15446               rtx temp = gen_reg_rtx (mode);
15447               emit_insn (gen_rtx_SET (VOIDmode, temp, op1));
15448               emit_move_insn (op0, temp);
15449               return;
15450             }
15451         }
15452     }
15453
15454   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15455 }
15456
15457 void
15458 ix86_expand_vector_move (enum machine_mode mode, rtx operands[])
15459 {
15460   rtx op0 = operands[0], op1 = operands[1];
15461   unsigned int align = GET_MODE_ALIGNMENT (mode);
15462
15463   /* Force constants other than zero into memory.  We do not know how
15464      the instructions used to build constants modify the upper 64 bits
15465      of the register, once we have that information we may be able
15466      to handle some of them more efficiently.  */
15467   if (can_create_pseudo_p ()
15468       && register_operand (op0, mode)
15469       && (CONSTANT_P (op1)
15470           || (GET_CODE (op1) == SUBREG
15471               && CONSTANT_P (SUBREG_REG (op1))))
15472       && !standard_sse_constant_p (op1))
15473     op1 = validize_mem (force_const_mem (mode, op1));
15474
15475   /* We need to check memory alignment for SSE mode since attribute
15476      can make operands unaligned.  */
15477   if (can_create_pseudo_p ()
15478       && SSE_REG_MODE_P (mode)
15479       && ((MEM_P (op0) && (MEM_ALIGN (op0) < align))
15480           || (MEM_P (op1) && (MEM_ALIGN (op1) < align))))
15481     {
15482       rtx tmp[2];
15483
15484       /* ix86_expand_vector_move_misalign() does not like constants ... */
15485       if (CONSTANT_P (op1)
15486           || (GET_CODE (op1) == SUBREG
15487               && CONSTANT_P (SUBREG_REG (op1))))
15488         op1 = validize_mem (force_const_mem (mode, op1));
15489
15490       /* ... nor both arguments in memory.  */
15491       if (!register_operand (op0, mode)
15492           && !register_operand (op1, mode))
15493         op1 = force_reg (mode, op1);
15494
15495       tmp[0] = op0; tmp[1] = op1;
15496       ix86_expand_vector_move_misalign (mode, tmp);
15497       return;
15498     }
15499
15500   /* Make operand1 a register if it isn't already.  */
15501   if (can_create_pseudo_p ()
15502       && !register_operand (op0, mode)
15503       && !register_operand (op1, mode))
15504     {
15505       emit_move_insn (op0, force_reg (GET_MODE (op0), op1));
15506       return;
15507     }
15508
15509   emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
15510 }
15511
15512 /* Split 32-byte AVX unaligned load and store if needed.  */
15513
15514 static void
15515 ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
15516 {
15517   rtx m;
15518   rtx (*extract) (rtx, rtx, rtx);
15519   rtx (*move_unaligned) (rtx, rtx);
15520   enum machine_mode mode;
15521
15522   switch (GET_MODE (op0))
15523     {
15524     default:
15525       gcc_unreachable ();
15526     case V32QImode:
15527       extract = gen_avx_vextractf128v32qi;
15528       move_unaligned = gen_avx_movdqu256;
15529       mode = V16QImode;
15530       break;
15531     case V8SFmode:
15532       extract = gen_avx_vextractf128v8sf;
15533       move_unaligned = gen_avx_movups256;
15534       mode = V4SFmode;
15535       break;
15536     case V4DFmode:
15537       extract = gen_avx_vextractf128v4df;
15538       move_unaligned = gen_avx_movupd256;
15539       mode = V2DFmode;
15540       break;
15541     }
15542
15543   if (MEM_P (op1) && TARGET_AVX256_SPLIT_UNALIGNED_LOAD)
15544     {
15545       rtx r = gen_reg_rtx (mode);
15546       m = adjust_address (op1, mode, 0);
15547       emit_move_insn (r, m);
15548       m = adjust_address (op1, mode, 16);
15549       r = gen_rtx_VEC_CONCAT (GET_MODE (op0), r, m);
15550       emit_move_insn (op0, r);
15551     }
15552   else if (MEM_P (op0) && TARGET_AVX256_SPLIT_UNALIGNED_STORE)
15553     {
15554       m = adjust_address (op0, mode, 0);
15555       emit_insn (extract (m, op1, const0_rtx));
15556       m = adjust_address (op0, mode, 16);
15557       emit_insn (extract (m, op1, const1_rtx));
15558     }
15559   else
15560     emit_insn (move_unaligned (op0, op1));
15561 }
15562
15563 /* Implement the movmisalign patterns for SSE.  Non-SSE modes go
15564    straight to ix86_expand_vector_move.  */
15565 /* Code generation for scalar reg-reg moves of single and double precision data:
15566      if (x86_sse_partial_reg_dependency == true | x86_sse_split_regs == true)
15567        movaps reg, reg
15568      else
15569        movss reg, reg
15570      if (x86_sse_partial_reg_dependency == true)
15571        movapd reg, reg
15572      else
15573        movsd reg, reg
15574
15575    Code generation for scalar loads of double precision data:
15576      if (x86_sse_split_regs == true)
15577        movlpd mem, reg      (gas syntax)
15578      else
15579        movsd mem, reg
15580
15581    Code generation for unaligned packed loads of single precision data
15582    (x86_sse_unaligned_move_optimal overrides x86_sse_partial_reg_dependency):
15583      if (x86_sse_unaligned_move_optimal)
15584        movups mem, reg
15585
15586      if (x86_sse_partial_reg_dependency == true)
15587        {
15588          xorps  reg, reg
15589          movlps mem, reg
15590          movhps mem+8, reg
15591        }
15592      else
15593        {
15594          movlps mem, reg
15595          movhps mem+8, reg
15596        }
15597
15598    Code generation for unaligned packed loads of double precision data
15599    (x86_sse_unaligned_move_optimal overrides x86_sse_split_regs):
15600      if (x86_sse_unaligned_move_optimal)
15601        movupd mem, reg
15602
15603      if (x86_sse_split_regs == true)
15604        {
15605          movlpd mem, reg
15606          movhpd mem+8, reg
15607        }
15608      else
15609        {
15610          movsd  mem, reg
15611          movhpd mem+8, reg
15612        }
15613  */
15614
15615 void
15616 ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[])
15617 {
15618   rtx op0, op1, m;
15619
15620   op0 = operands[0];
15621   op1 = operands[1];
15622
15623   if (TARGET_AVX)
15624     {
15625       switch (GET_MODE_CLASS (mode))
15626         {
15627         case MODE_VECTOR_INT:
15628         case MODE_INT:
15629           switch (GET_MODE_SIZE (mode))
15630             {
15631             case 16:
15632               /*  If we're optimizing for size, movups is the smallest.  */
15633               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15634                 {
15635                   op0 = gen_lowpart (V4SFmode, op0);
15636                   op1 = gen_lowpart (V4SFmode, op1);
15637                   emit_insn (gen_sse_movups (op0, op1));
15638                   return;
15639                 }
15640               op0 = gen_lowpart (V16QImode, op0);
15641               op1 = gen_lowpart (V16QImode, op1);
15642               emit_insn (gen_sse2_movdqu (op0, op1));
15643               break;
15644             case 32:
15645               op0 = gen_lowpart (V32QImode, op0);
15646               op1 = gen_lowpart (V32QImode, op1);
15647               ix86_avx256_split_vector_move_misalign (op0, op1);
15648               break;
15649             default:
15650               gcc_unreachable ();
15651             }
15652           break;
15653         case MODE_VECTOR_FLOAT:
15654           op0 = gen_lowpart (mode, op0);
15655           op1 = gen_lowpart (mode, op1);
15656
15657           switch (mode)
15658             {
15659             case V4SFmode:
15660               emit_insn (gen_sse_movups (op0, op1));
15661               break;
15662             case V8SFmode:
15663               ix86_avx256_split_vector_move_misalign (op0, op1);
15664               break;
15665             case V2DFmode:
15666               if (TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15667                 {
15668                   op0 = gen_lowpart (V4SFmode, op0);
15669                   op1 = gen_lowpart (V4SFmode, op1);
15670                   emit_insn (gen_sse_movups (op0, op1));
15671                   return;
15672                 }
15673               emit_insn (gen_sse2_movupd (op0, op1));
15674               break;
15675             case V4DFmode:
15676               ix86_avx256_split_vector_move_misalign (op0, op1);
15677               break;
15678             default:
15679               gcc_unreachable ();
15680             }
15681           break;
15682
15683         default:
15684           gcc_unreachable ();
15685         }
15686
15687       return;
15688     }
15689
15690   if (MEM_P (op1))
15691     {
15692       /* If we're optimizing for size, movups is the smallest.  */
15693       if (optimize_insn_for_size_p ()
15694           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15695         {
15696           op0 = gen_lowpart (V4SFmode, op0);
15697           op1 = gen_lowpart (V4SFmode, op1);
15698           emit_insn (gen_sse_movups (op0, op1));
15699           return;
15700         }
15701
15702       /* ??? If we have typed data, then it would appear that using
15703          movdqu is the only way to get unaligned data loaded with
15704          integer type.  */
15705       if (TARGET_SSE2 && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15706         {
15707           op0 = gen_lowpart (V16QImode, op0);
15708           op1 = gen_lowpart (V16QImode, op1);
15709           emit_insn (gen_sse2_movdqu (op0, op1));
15710           return;
15711         }
15712
15713       if (TARGET_SSE2 && mode == V2DFmode)
15714         {
15715           rtx zero;
15716
15717           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15718             {
15719               op0 = gen_lowpart (V2DFmode, op0);
15720               op1 = gen_lowpart (V2DFmode, op1);
15721               emit_insn (gen_sse2_movupd (op0, op1));
15722               return;
15723             }
15724
15725           /* When SSE registers are split into halves, we can avoid
15726              writing to the top half twice.  */
15727           if (TARGET_SSE_SPLIT_REGS)
15728             {
15729               emit_clobber (op0);
15730               zero = op0;
15731             }
15732           else
15733             {
15734               /* ??? Not sure about the best option for the Intel chips.
15735                  The following would seem to satisfy; the register is
15736                  entirely cleared, breaking the dependency chain.  We
15737                  then store to the upper half, with a dependency depth
15738                  of one.  A rumor has it that Intel recommends two movsd
15739                  followed by an unpacklpd, but this is unconfirmed.  And
15740                  given that the dependency depth of the unpacklpd would
15741                  still be one, I'm not sure why this would be better.  */
15742               zero = CONST0_RTX (V2DFmode);
15743             }
15744
15745           m = adjust_address (op1, DFmode, 0);
15746           emit_insn (gen_sse2_loadlpd (op0, zero, m));
15747           m = adjust_address (op1, DFmode, 8);
15748           emit_insn (gen_sse2_loadhpd (op0, op0, m));
15749         }
15750       else
15751         {
15752           if (TARGET_SSE_UNALIGNED_LOAD_OPTIMAL)
15753             {
15754               op0 = gen_lowpart (V4SFmode, op0);
15755               op1 = gen_lowpart (V4SFmode, op1);
15756               emit_insn (gen_sse_movups (op0, op1));
15757               return;
15758             }
15759
15760           if (TARGET_SSE_PARTIAL_REG_DEPENDENCY)
15761             emit_move_insn (op0, CONST0_RTX (mode));
15762           else
15763             emit_clobber (op0);
15764
15765           if (mode != V4SFmode)
15766             op0 = gen_lowpart (V4SFmode, op0);
15767           m = adjust_address (op1, V2SFmode, 0);
15768           emit_insn (gen_sse_loadlps (op0, op0, m));
15769           m = adjust_address (op1, V2SFmode, 8);
15770           emit_insn (gen_sse_loadhps (op0, op0, m));
15771         }
15772     }
15773   else if (MEM_P (op0))
15774     {
15775       /* If we're optimizing for size, movups is the smallest.  */
15776       if (optimize_insn_for_size_p ()
15777           || TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL)
15778         {
15779           op0 = gen_lowpart (V4SFmode, op0);
15780           op1 = gen_lowpart (V4SFmode, op1);
15781           emit_insn (gen_sse_movups (op0, op1));
15782           return;
15783         }
15784
15785       /* ??? Similar to above, only less clear because of quote
15786          typeless stores unquote.  */
15787       if (TARGET_SSE2 && !TARGET_SSE_TYPELESS_STORES
15788           && GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
15789         {
15790           op0 = gen_lowpart (V16QImode, op0);
15791           op1 = gen_lowpart (V16QImode, op1);
15792           emit_insn (gen_sse2_movdqu (op0, op1));
15793           return;
15794         }
15795
15796       if (TARGET_SSE2 && mode == V2DFmode)
15797         {
15798           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15799             {
15800               op0 = gen_lowpart (V2DFmode, op0);
15801               op1 = gen_lowpart (V2DFmode, op1);
15802               emit_insn (gen_sse2_movupd (op0, op1));
15803             }
15804           else
15805             {
15806               m = adjust_address (op0, DFmode, 0);
15807               emit_insn (gen_sse2_storelpd (m, op1));
15808               m = adjust_address (op0, DFmode, 8);
15809               emit_insn (gen_sse2_storehpd (m, op1));
15810             }
15811         }
15812       else
15813         {
15814           if (mode != V4SFmode)
15815             op1 = gen_lowpart (V4SFmode, op1);
15816
15817           if (TARGET_SSE_UNALIGNED_STORE_OPTIMAL)
15818             {
15819               op0 = gen_lowpart (V4SFmode, op0);
15820               emit_insn (gen_sse_movups (op0, op1));
15821             }
15822           else
15823             {
15824               m = adjust_address (op0, V2SFmode, 0);
15825               emit_insn (gen_sse_storelps (m, op1));
15826               m = adjust_address (op0, V2SFmode, 8);
15827               emit_insn (gen_sse_storehps (m, op1));
15828             }
15829         }
15830     }
15831   else
15832     gcc_unreachable ();
15833 }
15834
15835 /* Expand a push in MODE.  This is some mode for which we do not support
15836    proper push instructions, at least from the registers that we expect
15837    the value to live in.  */
15838
15839 void
15840 ix86_expand_push (enum machine_mode mode, rtx x)
15841 {
15842   rtx tmp;
15843
15844   tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
15845                              GEN_INT (-GET_MODE_SIZE (mode)),
15846                              stack_pointer_rtx, 1, OPTAB_DIRECT);
15847   if (tmp != stack_pointer_rtx)
15848     emit_move_insn (stack_pointer_rtx, tmp);
15849
15850   tmp = gen_rtx_MEM (mode, stack_pointer_rtx);
15851
15852   /* When we push an operand onto stack, it has to be aligned at least
15853      at the function argument boundary.  However since we don't have
15854      the argument type, we can't determine the actual argument
15855      boundary.  */
15856   emit_move_insn (tmp, x);
15857 }
15858
15859 /* Helper function of ix86_fixup_binary_operands to canonicalize
15860    operand order.  Returns true if the operands should be swapped.  */
15861
15862 static bool
15863 ix86_swap_binary_operands_p (enum rtx_code code, enum machine_mode mode,
15864                              rtx operands[])
15865 {
15866   rtx dst = operands[0];
15867   rtx src1 = operands[1];
15868   rtx src2 = operands[2];
15869
15870   /* If the operation is not commutative, we can't do anything.  */
15871   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH)
15872     return false;
15873
15874   /* Highest priority is that src1 should match dst.  */
15875   if (rtx_equal_p (dst, src1))
15876     return false;
15877   if (rtx_equal_p (dst, src2))
15878     return true;
15879
15880   /* Next highest priority is that immediate constants come second.  */
15881   if (immediate_operand (src2, mode))
15882     return false;
15883   if (immediate_operand (src1, mode))
15884     return true;
15885
15886   /* Lowest priority is that memory references should come second.  */
15887   if (MEM_P (src2))
15888     return false;
15889   if (MEM_P (src1))
15890     return true;
15891
15892   return false;
15893 }
15894
15895
15896 /* Fix up OPERANDS to satisfy ix86_binary_operator_ok.  Return the
15897    destination to use for the operation.  If different from the true
15898    destination in operands[0], a copy operation will be required.  */
15899
15900 rtx
15901 ix86_fixup_binary_operands (enum rtx_code code, enum machine_mode mode,
15902                             rtx operands[])
15903 {
15904   rtx dst = operands[0];
15905   rtx src1 = operands[1];
15906   rtx src2 = operands[2];
15907
15908   /* Canonicalize operand order.  */
15909   if (ix86_swap_binary_operands_p (code, mode, operands))
15910     {
15911       rtx temp;
15912
15913       /* It is invalid to swap operands of different modes.  */
15914       gcc_assert (GET_MODE (src1) == GET_MODE (src2));
15915
15916       temp = src1;
15917       src1 = src2;
15918       src2 = temp;
15919     }
15920
15921   /* Both source operands cannot be in memory.  */
15922   if (MEM_P (src1) && MEM_P (src2))
15923     {
15924       /* Optimization: Only read from memory once.  */
15925       if (rtx_equal_p (src1, src2))
15926         {
15927           src2 = force_reg (mode, src2);
15928           src1 = src2;
15929         }
15930       else
15931         src2 = force_reg (mode, src2);
15932     }
15933
15934   /* If the destination is memory, and we do not have matching source
15935      operands, do things in registers.  */
15936   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
15937     dst = gen_reg_rtx (mode);
15938
15939   /* Source 1 cannot be a constant.  */
15940   if (CONSTANT_P (src1))
15941     src1 = force_reg (mode, src1);
15942
15943   /* Source 1 cannot be a non-matching memory.  */
15944   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
15945     src1 = force_reg (mode, src1);
15946
15947   /* Improve address combine.  */
15948   if (code == PLUS
15949       && GET_MODE_CLASS (mode) == MODE_INT
15950       && MEM_P (src2))
15951     src2 = force_reg (mode, src2);
15952
15953   operands[1] = src1;
15954   operands[2] = src2;
15955   return dst;
15956 }
15957
15958 /* Similarly, but assume that the destination has already been
15959    set up properly.  */
15960
15961 void
15962 ix86_fixup_binary_operands_no_copy (enum rtx_code code,
15963                                     enum machine_mode mode, rtx operands[])
15964 {
15965   rtx dst = ix86_fixup_binary_operands (code, mode, operands);
15966   gcc_assert (dst == operands[0]);
15967 }
15968
15969 /* Attempt to expand a binary operator.  Make the expansion closer to the
15970    actual machine, then just general_operand, which will allow 3 separate
15971    memory references (one output, two input) in a single insn.  */
15972
15973 void
15974 ix86_expand_binary_operator (enum rtx_code code, enum machine_mode mode,
15975                              rtx operands[])
15976 {
15977   rtx src1, src2, dst, op, clob;
15978
15979   dst = ix86_fixup_binary_operands (code, mode, operands);
15980   src1 = operands[1];
15981   src2 = operands[2];
15982
15983  /* Emit the instruction.  */
15984
15985   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, src1, src2));
15986   if (reload_in_progress)
15987     {
15988       /* Reload doesn't know about the flags register, and doesn't know that
15989          it doesn't want to clobber it.  We can only do this with PLUS.  */
15990       gcc_assert (code == PLUS);
15991       emit_insn (op);
15992     }
15993   else if (reload_completed
15994            && code == PLUS
15995            && !rtx_equal_p (dst, src1))
15996     {
15997       /* This is going to be an LEA; avoid splitting it later.  */
15998       emit_insn (op);
15999     }
16000   else
16001     {
16002       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16003       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
16004     }
16005
16006   /* Fix up the destination if needed.  */
16007   if (dst != operands[0])
16008     emit_move_insn (operands[0], dst);
16009 }
16010
16011 /* Return TRUE or FALSE depending on whether the binary operator meets the
16012    appropriate constraints.  */
16013
16014 bool
16015 ix86_binary_operator_ok (enum rtx_code code, enum machine_mode mode,
16016                          rtx operands[3])
16017 {
16018   rtx dst = operands[0];
16019   rtx src1 = operands[1];
16020   rtx src2 = operands[2];
16021
16022   /* Both source operands cannot be in memory.  */
16023   if (MEM_P (src1) && MEM_P (src2))
16024     return false;
16025
16026   /* Canonicalize operand order for commutative operators.  */
16027   if (ix86_swap_binary_operands_p (code, mode, operands))
16028     {
16029       rtx temp = src1;
16030       src1 = src2;
16031       src2 = temp;
16032     }
16033
16034   /* If the destination is memory, we must have a matching source operand.  */
16035   if (MEM_P (dst) && !rtx_equal_p (dst, src1))
16036       return false;
16037
16038   /* Source 1 cannot be a constant.  */
16039   if (CONSTANT_P (src1))
16040     return false;
16041
16042   /* Source 1 cannot be a non-matching memory.  */
16043   if (MEM_P (src1) && !rtx_equal_p (dst, src1))
16044     /* Support "andhi/andsi/anddi" as a zero-extending move.  */
16045     return (code == AND
16046             && (mode == HImode
16047                 || mode == SImode
16048                 || (TARGET_64BIT && mode == DImode))
16049             && satisfies_constraint_L (src2));
16050
16051   return true;
16052 }
16053
16054 /* Attempt to expand a unary operator.  Make the expansion closer to the
16055    actual machine, then just general_operand, which will allow 2 separate
16056    memory references (one output, one input) in a single insn.  */
16057
16058 void
16059 ix86_expand_unary_operator (enum rtx_code code, enum machine_mode mode,
16060                             rtx operands[])
16061 {
16062   int matching_memory;
16063   rtx src, dst, op, clob;
16064
16065   dst = operands[0];
16066   src = operands[1];
16067
16068   /* If the destination is memory, and we do not have matching source
16069      operands, do things in registers.  */
16070   matching_memory = 0;
16071   if (MEM_P (dst))
16072     {
16073       if (rtx_equal_p (dst, src))
16074         matching_memory = 1;
16075       else
16076         dst = gen_reg_rtx (mode);
16077     }
16078
16079   /* When source operand is memory, destination must match.  */
16080   if (MEM_P (src) && !matching_memory)
16081     src = force_reg (mode, src);
16082
16083   /* Emit the instruction.  */
16084
16085   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_e (code, mode, src));
16086   if (reload_in_progress || code == NOT)
16087     {
16088       /* Reload doesn't know about the flags register, and doesn't know that
16089          it doesn't want to clobber it.  */
16090       gcc_assert (code == NOT);
16091       emit_insn (op);
16092     }
16093   else
16094     {
16095       clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16096       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
16097     }
16098
16099   /* Fix up the destination if needed.  */
16100   if (dst != operands[0])
16101     emit_move_insn (operands[0], dst);
16102 }
16103
16104 /* Split 32bit/64bit divmod with 8bit unsigned divmod if dividend and
16105    divisor are within the range [0-255].  */
16106
16107 void
16108 ix86_split_idivmod (enum machine_mode mode, rtx operands[],
16109                     bool signed_p)
16110 {
16111   rtx end_label, qimode_label;
16112   rtx insn, div, mod;
16113   rtx scratch, tmp0, tmp1, tmp2;
16114   rtx (*gen_divmod4_1) (rtx, rtx, rtx, rtx);
16115   rtx (*gen_zero_extend) (rtx, rtx);
16116   rtx (*gen_test_ccno_1) (rtx, rtx);
16117
16118   switch (mode)
16119     {
16120     case SImode:
16121       gen_divmod4_1 = signed_p ? gen_divmodsi4_1 : gen_udivmodsi4_1;
16122       gen_test_ccno_1 = gen_testsi_ccno_1;
16123       gen_zero_extend = gen_zero_extendqisi2;
16124       break;
16125     case DImode:
16126       gen_divmod4_1 = signed_p ? gen_divmoddi4_1 : gen_udivmoddi4_1;
16127       gen_test_ccno_1 = gen_testdi_ccno_1;
16128       gen_zero_extend = gen_zero_extendqidi2;
16129       break;
16130     default:
16131       gcc_unreachable ();
16132     }
16133
16134   end_label = gen_label_rtx ();
16135   qimode_label = gen_label_rtx ();
16136
16137   scratch = gen_reg_rtx (mode);
16138
16139   /* Use 8bit unsigned divimod if dividend and divisor are within
16140      the range [0-255].  */
16141   emit_move_insn (scratch, operands[2]);
16142   scratch = expand_simple_binop (mode, IOR, scratch, operands[3],
16143                                  scratch, 1, OPTAB_DIRECT);
16144   emit_insn (gen_test_ccno_1 (scratch, GEN_INT (-0x100)));
16145   tmp0 = gen_rtx_REG (CCNOmode, FLAGS_REG);
16146   tmp0 = gen_rtx_EQ (VOIDmode, tmp0, const0_rtx);
16147   tmp0 = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp0,
16148                                gen_rtx_LABEL_REF (VOIDmode, qimode_label),
16149                                pc_rtx);
16150   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp0));
16151   predict_jump (REG_BR_PROB_BASE * 50 / 100);
16152   JUMP_LABEL (insn) = qimode_label;
16153
16154   /* Generate original signed/unsigned divimod.  */
16155   div = gen_divmod4_1 (operands[0], operands[1],
16156                        operands[2], operands[3]);
16157   emit_insn (div);
16158
16159   /* Branch to the end.  */
16160   emit_jump_insn (gen_jump (end_label));
16161   emit_barrier ();
16162
16163   /* Generate 8bit unsigned divide.  */
16164   emit_label (qimode_label);
16165   /* Don't use operands[0] for result of 8bit divide since not all
16166      registers support QImode ZERO_EXTRACT.  */
16167   tmp0 = simplify_gen_subreg (HImode, scratch, mode, 0);
16168   tmp1 = simplify_gen_subreg (HImode, operands[2], mode, 0);
16169   tmp2 = simplify_gen_subreg (QImode, operands[3], mode, 0);
16170   emit_insn (gen_udivmodhiqi3 (tmp0, tmp1, tmp2));
16171
16172   if (signed_p)
16173     {
16174       div = gen_rtx_DIV (SImode, operands[2], operands[3]);
16175       mod = gen_rtx_MOD (SImode, operands[2], operands[3]);
16176     }
16177   else
16178     {
16179       div = gen_rtx_UDIV (SImode, operands[2], operands[3]);
16180       mod = gen_rtx_UMOD (SImode, operands[2], operands[3]);
16181     }
16182
16183   /* Extract remainder from AH.  */
16184   tmp1 = gen_rtx_ZERO_EXTRACT (mode, tmp0, GEN_INT (8), GEN_INT (8));
16185   if (REG_P (operands[1]))
16186     insn = emit_move_insn (operands[1], tmp1);
16187   else
16188     {
16189       /* Need a new scratch register since the old one has result
16190          of 8bit divide.  */
16191       scratch = gen_reg_rtx (mode);
16192       emit_move_insn (scratch, tmp1);
16193       insn = emit_move_insn (operands[1], scratch);
16194     }
16195   set_unique_reg_note (insn, REG_EQUAL, mod);
16196
16197   /* Zero extend quotient from AL.  */
16198   tmp1 = gen_lowpart (QImode, tmp0);
16199   insn = emit_insn (gen_zero_extend (operands[0], tmp1));
16200   set_unique_reg_note (insn, REG_EQUAL, div);
16201
16202   emit_label (end_label);
16203 }
16204
16205 #define LEA_MAX_STALL (3)
16206 #define LEA_SEARCH_THRESHOLD (LEA_MAX_STALL << 1)
16207
16208 /* Increase given DISTANCE in half-cycles according to
16209    dependencies between PREV and NEXT instructions.
16210    Add 1 half-cycle if there is no dependency and
16211    go to next cycle if there is some dependecy.  */
16212
16213 static unsigned int
16214 increase_distance (rtx prev, rtx next, unsigned int distance)
16215 {
16216   df_ref *use_rec;
16217   df_ref *def_rec;
16218
16219   if (!prev || !next)
16220     return distance + (distance & 1) + 2;
16221
16222   if (!DF_INSN_USES (next) || !DF_INSN_DEFS (prev))
16223     return distance + 1;
16224
16225   for (use_rec = DF_INSN_USES (next); *use_rec; use_rec++)
16226     for (def_rec = DF_INSN_DEFS (prev); *def_rec; def_rec++)
16227       if (!DF_REF_IS_ARTIFICIAL (*def_rec)
16228           && DF_REF_REGNO (*use_rec) == DF_REF_REGNO (*def_rec))
16229         return distance + (distance & 1) + 2;
16230
16231   return distance + 1;
16232 }
16233
16234 /* Function checks if instruction INSN defines register number
16235    REGNO1 or REGNO2.  */
16236
16237 static bool
16238 insn_defines_reg (unsigned int regno1, unsigned int regno2,
16239                   rtx insn)
16240 {
16241   df_ref *def_rec;
16242
16243   for (def_rec = DF_INSN_DEFS (insn); *def_rec; def_rec++)
16244     if (DF_REF_REG_DEF_P (*def_rec)
16245         && !DF_REF_IS_ARTIFICIAL (*def_rec)
16246         && (regno1 == DF_REF_REGNO (*def_rec)
16247             || regno2 == DF_REF_REGNO (*def_rec)))
16248       {
16249         return true;
16250       }
16251
16252   return false;
16253 }
16254
16255 /* Function checks if instruction INSN uses register number
16256    REGNO as a part of address expression.  */
16257
16258 static bool
16259 insn_uses_reg_mem (unsigned int regno, rtx insn)
16260 {
16261   df_ref *use_rec;
16262
16263   for (use_rec = DF_INSN_USES (insn); *use_rec; use_rec++)
16264     if (DF_REF_REG_MEM_P (*use_rec) && regno == DF_REF_REGNO (*use_rec))
16265       return true;
16266
16267   return false;
16268 }
16269
16270 /* Search backward for non-agu definition of register number REGNO1
16271    or register number REGNO2 in basic block starting from instruction
16272    START up to head of basic block or instruction INSN.
16273
16274    Function puts true value into *FOUND var if definition was found
16275    and false otherwise.
16276
16277    Distance in half-cycles between START and found instruction or head
16278    of BB is added to DISTANCE and returned.  */
16279
16280 static int
16281 distance_non_agu_define_in_bb (unsigned int regno1, unsigned int regno2,
16282                                rtx insn, int distance,
16283                                rtx start, bool *found)
16284 {
16285   basic_block bb = start ? BLOCK_FOR_INSN (start) : NULL;
16286   rtx prev = start;
16287   rtx next = NULL;
16288
16289   *found = false;
16290
16291   while (prev
16292          && prev != insn
16293          && distance < LEA_SEARCH_THRESHOLD)
16294     {
16295       if (NONDEBUG_INSN_P (prev) && NONJUMP_INSN_P (prev))
16296         {
16297           distance = increase_distance (prev, next, distance);
16298           if (insn_defines_reg (regno1, regno2, prev))
16299             {
16300               if (recog_memoized (prev) < 0
16301                   || get_attr_type (prev) != TYPE_LEA)
16302                 {
16303                   *found = true;
16304                   return distance;
16305                 }
16306             }
16307
16308           next = prev;
16309         }
16310       if (prev == BB_HEAD (bb))
16311         break;
16312
16313       prev = PREV_INSN (prev);
16314     }
16315
16316   return distance;
16317 }
16318
16319 /* Search backward for non-agu definition of register number REGNO1
16320    or register number REGNO2 in INSN's basic block until
16321    1. Pass LEA_SEARCH_THRESHOLD instructions, or
16322    2. Reach neighbour BBs boundary, or
16323    3. Reach agu definition.
16324    Returns the distance between the non-agu definition point and INSN.
16325    If no definition point, returns -1.  */
16326
16327 static int
16328 distance_non_agu_define (unsigned int regno1, unsigned int regno2,
16329                          rtx insn)
16330 {
16331   basic_block bb = BLOCK_FOR_INSN (insn);
16332   int distance = 0;
16333   bool found = false;
16334
16335   if (insn != BB_HEAD (bb))
16336     distance = distance_non_agu_define_in_bb (regno1, regno2, insn,
16337                                               distance, PREV_INSN (insn),
16338                                               &found);
16339
16340   if (!found && distance < LEA_SEARCH_THRESHOLD)
16341     {
16342       edge e;
16343       edge_iterator ei;
16344       bool simple_loop = false;
16345
16346       FOR_EACH_EDGE (e, ei, bb->preds)
16347         if (e->src == bb)
16348           {
16349             simple_loop = true;
16350             break;
16351           }
16352
16353       if (simple_loop)
16354         distance = distance_non_agu_define_in_bb (regno1, regno2,
16355                                                   insn, distance,
16356                                                   BB_END (bb), &found);
16357       else
16358         {
16359           int shortest_dist = -1;
16360           bool found_in_bb = false;
16361
16362           FOR_EACH_EDGE (e, ei, bb->preds)
16363             {
16364               int bb_dist
16365                 = distance_non_agu_define_in_bb (regno1, regno2,
16366                                                  insn, distance,
16367                                                  BB_END (e->src),
16368                                                  &found_in_bb);
16369               if (found_in_bb)
16370                 {
16371                   if (shortest_dist < 0)
16372                     shortest_dist = bb_dist;
16373                   else if (bb_dist > 0)
16374                     shortest_dist = MIN (bb_dist, shortest_dist);
16375
16376                   found = true;
16377                 }
16378             }
16379
16380           distance = shortest_dist;
16381         }
16382     }
16383
16384   /* get_attr_type may modify recog data.  We want to make sure
16385      that recog data is valid for instruction INSN, on which
16386      distance_non_agu_define is called.  INSN is unchanged here.  */
16387   extract_insn_cached (insn);
16388
16389   if (!found)
16390     return -1;
16391
16392   return distance >> 1;
16393 }
16394
16395 /* Return the distance in half-cycles between INSN and the next
16396    insn that uses register number REGNO in memory address added
16397    to DISTANCE.  Return -1 if REGNO0 is set.
16398
16399    Put true value into *FOUND if register usage was found and
16400    false otherwise.
16401    Put true value into *REDEFINED if register redefinition was
16402    found and false otherwise.  */
16403
16404 static int
16405 distance_agu_use_in_bb (unsigned int regno,
16406                         rtx insn, int distance, rtx start,
16407                         bool *found, bool *redefined)
16408 {
16409   basic_block bb = start ? BLOCK_FOR_INSN (start) : NULL;
16410   rtx next = start;
16411   rtx prev = NULL;
16412
16413   *found = false;
16414   *redefined = false;
16415
16416   while (next
16417          && next != insn
16418          && distance < LEA_SEARCH_THRESHOLD)
16419     {
16420       if (NONDEBUG_INSN_P (next) && NONJUMP_INSN_P (next))
16421         {
16422           distance = increase_distance(prev, next, distance);
16423           if (insn_uses_reg_mem (regno, next))
16424             {
16425               /* Return DISTANCE if OP0 is used in memory
16426                  address in NEXT.  */
16427               *found = true;
16428               return distance;
16429             }
16430
16431           if (insn_defines_reg (regno, INVALID_REGNUM, next))
16432             {
16433               /* Return -1 if OP0 is set in NEXT.  */
16434               *redefined = true;
16435               return -1;
16436             }
16437
16438           prev = next;
16439         }
16440
16441       if (next == BB_END (bb))
16442         break;
16443
16444       next = NEXT_INSN (next);
16445     }
16446
16447   return distance;
16448 }
16449
16450 /* Return the distance between INSN and the next insn that uses
16451    register number REGNO0 in memory address.  Return -1 if no such
16452    a use is found within LEA_SEARCH_THRESHOLD or REGNO0 is set.  */
16453
16454 static int
16455 distance_agu_use (unsigned int regno0, rtx insn)
16456 {
16457   basic_block bb = BLOCK_FOR_INSN (insn);
16458   int distance = 0;
16459   bool found = false;
16460   bool redefined = false;
16461
16462   if (insn != BB_END (bb))
16463     distance = distance_agu_use_in_bb (regno0, insn, distance,
16464                                        NEXT_INSN (insn),
16465                                        &found, &redefined);
16466
16467   if (!found && !redefined && distance < LEA_SEARCH_THRESHOLD)
16468     {
16469       edge e;
16470       edge_iterator ei;
16471       bool simple_loop = false;
16472
16473       FOR_EACH_EDGE (e, ei, bb->succs)
16474         if (e->dest == bb)
16475           {
16476             simple_loop = true;
16477             break;
16478           }
16479
16480       if (simple_loop)
16481         distance = distance_agu_use_in_bb (regno0, insn,
16482                                            distance, BB_HEAD (bb),
16483                                            &found, &redefined);
16484       else
16485         {
16486           int shortest_dist = -1;
16487           bool found_in_bb = false;
16488           bool redefined_in_bb = false;
16489
16490           FOR_EACH_EDGE (e, ei, bb->succs)
16491             {
16492               int bb_dist
16493                 = distance_agu_use_in_bb (regno0, insn,
16494                                           distance, BB_HEAD (e->dest),
16495                                           &found_in_bb, &redefined_in_bb);
16496               if (found_in_bb)
16497                 {
16498                   if (shortest_dist < 0)
16499                     shortest_dist = bb_dist;
16500                   else if (bb_dist > 0)
16501                     shortest_dist = MIN (bb_dist, shortest_dist);
16502
16503                   found = true;
16504                 }
16505             }
16506
16507           distance = shortest_dist;
16508         }
16509     }
16510
16511   if (!found || redefined)
16512     return -1;
16513
16514   return distance >> 1;
16515 }
16516
16517 /* Define this macro to tune LEA priority vs ADD, it take effect when
16518    there is a dilemma of choicing LEA or ADD
16519    Negative value: ADD is more preferred than LEA
16520    Zero: Netrual
16521    Positive value: LEA is more preferred than ADD*/
16522 #define IX86_LEA_PRIORITY 0
16523
16524 /* Return true if usage of lea INSN has performance advantage
16525    over a sequence of instructions.  Instructions sequence has
16526    SPLIT_COST cycles higher latency than lea latency.  */
16527
16528 bool
16529 ix86_lea_outperforms (rtx insn, unsigned int regno0, unsigned int regno1,
16530                       unsigned int regno2, unsigned int split_cost)
16531 {
16532   int dist_define, dist_use;
16533
16534   dist_define = distance_non_agu_define (regno1, regno2, insn);
16535   dist_use = distance_agu_use (regno0, insn);
16536
16537   if (dist_define < 0 || dist_define >= LEA_MAX_STALL)
16538     {
16539       /* If there is no non AGU operand definition, no AGU
16540          operand usage and split cost is 0 then both lea
16541          and non lea variants have same priority.  Currently
16542          we prefer lea for 64 bit code and non lea on 32 bit
16543          code.  */
16544       if (dist_use < 0 && split_cost == 0)
16545         return TARGET_64BIT || IX86_LEA_PRIORITY;
16546       else
16547         return true;
16548     }
16549
16550   /* With longer definitions distance lea is more preferable.
16551      Here we change it to take into account splitting cost and
16552      lea priority.  */
16553   dist_define += split_cost + IX86_LEA_PRIORITY;
16554
16555   /* If there is no use in memory addess then we just check
16556      that split cost does not exceed AGU stall.  */
16557   if (dist_use < 0)
16558     return dist_define >= LEA_MAX_STALL;
16559
16560   /* If this insn has both backward non-agu dependence and forward
16561      agu dependence, the one with short distance takes effect.  */
16562   return dist_define >= dist_use;
16563 }
16564
16565 /* Return true if it is legal to clobber flags by INSN and
16566    false otherwise.  */
16567
16568 static bool
16569 ix86_ok_to_clobber_flags (rtx insn)
16570 {
16571   basic_block bb = BLOCK_FOR_INSN (insn);
16572   df_ref *use;
16573   bitmap live;
16574
16575   while (insn)
16576     {
16577       if (NONDEBUG_INSN_P (insn))
16578         {
16579           for (use = DF_INSN_USES (insn); *use; use++)
16580             if (DF_REF_REG_USE_P (*use) && DF_REF_REGNO (*use) == FLAGS_REG)
16581               return false;
16582
16583           if (insn_defines_reg (FLAGS_REG, INVALID_REGNUM, insn))
16584             return true;
16585         }
16586
16587       if (insn == BB_END (bb))
16588         break;
16589
16590       insn = NEXT_INSN (insn);
16591     }
16592
16593   live = df_get_live_out(bb);
16594   return !REGNO_REG_SET_P (live, FLAGS_REG);
16595 }
16596
16597 /* Return true if we need to split op0 = op1 + op2 into a sequence of
16598    move and add to avoid AGU stalls.  */
16599
16600 bool
16601 ix86_avoid_lea_for_add (rtx insn, rtx operands[])
16602 {
16603   unsigned int regno0 = true_regnum (operands[0]);
16604   unsigned int regno1 = true_regnum (operands[1]);
16605   unsigned int regno2 = true_regnum (operands[2]);
16606
16607   /* Check if we need to optimize.  */
16608   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16609     return false;
16610
16611   /* Check it is correct to split here.  */
16612   if (!ix86_ok_to_clobber_flags(insn))
16613     return false;
16614
16615   /* We need to split only adds with non destructive
16616      destination operand.  */
16617   if (regno0 == regno1 || regno0 == regno2)
16618     return false;
16619   else
16620     return !ix86_lea_outperforms (insn, regno0, regno1, regno2, 1);
16621 }
16622
16623 /* Return true if we should emit lea instruction instead of mov
16624    instruction.  */
16625
16626 bool
16627 ix86_use_lea_for_mov (rtx insn, rtx operands[])
16628 {
16629   unsigned int regno0;
16630   unsigned int regno1;
16631
16632   /* Check if we need to optimize.  */
16633   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16634     return false;
16635
16636   /* Use lea for reg to reg moves only.  */
16637   if (!REG_P (operands[0]) || !REG_P (operands[1]))
16638     return false;
16639
16640   regno0 = true_regnum (operands[0]);
16641   regno1 = true_regnum (operands[1]);
16642
16643   return ix86_lea_outperforms (insn, regno0, regno1, -1, 0);
16644 }
16645
16646 /* Return true if we need to split lea into a sequence of
16647    instructions to avoid AGU stalls. */
16648
16649 bool
16650 ix86_avoid_lea_for_addr (rtx insn, rtx operands[])
16651 {
16652   unsigned int regno0 = true_regnum (operands[0]) ;
16653   unsigned int regno1 = -1;
16654   unsigned int regno2 = -1;
16655   unsigned int split_cost = 0;
16656   struct ix86_address parts;
16657   int ok;
16658
16659   /* Check we need to optimize.  */
16660   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16661     return false;
16662
16663   /* Check it is correct to split here.  */
16664   if (!ix86_ok_to_clobber_flags(insn))
16665     return false;
16666
16667   ok = ix86_decompose_address (operands[1], &parts);
16668   gcc_assert (ok);
16669
16670   /* We should not split into add if non legitimate pic
16671      operand is used as displacement. */
16672   if (parts.disp && flag_pic && !LEGITIMATE_PIC_OPERAND_P (parts.disp))
16673     return false;
16674
16675   if (parts.base)
16676     regno1 = true_regnum (parts.base);
16677   if (parts.index)
16678     regno2 = true_regnum (parts.index);
16679
16680   /* Compute how many cycles we will add to execution time
16681      if split lea into a sequence of instructions.  */
16682   if (parts.base || parts.index)
16683     {
16684       /* Have to use mov instruction if non desctructive
16685          destination form is used.  */
16686       if (regno1 != regno0 && regno2 != regno0)
16687         split_cost += 1;
16688
16689       /* Have to add index to base if both exist.  */
16690       if (parts.base && parts.index)
16691         split_cost += 1;
16692
16693       /* Have to use shift and adds if scale is 2 or greater.  */
16694       if (parts.scale > 1)
16695         {
16696           if (regno0 != regno1)
16697             split_cost += 1;
16698           else if (regno2 == regno0)
16699             split_cost += 4;
16700           else
16701             split_cost += parts.scale;
16702         }
16703
16704       /* Have to use add instruction with immediate if
16705          disp is non zero.  */
16706       if (parts.disp && parts.disp != const0_rtx)
16707         split_cost += 1;
16708
16709       /* Subtract the price of lea.  */
16710       split_cost -= 1;
16711     }
16712
16713   return !ix86_lea_outperforms (insn, regno0, regno1, regno2, split_cost);
16714 }
16715
16716 /* Emit x86 binary operand CODE in mode MODE, where the first operand
16717    matches destination.  RTX includes clobber of FLAGS_REG.  */
16718
16719 static void
16720 ix86_emit_binop (enum rtx_code code, enum machine_mode mode,
16721                  rtx dst, rtx src)
16722 {
16723   rtx op, clob;
16724
16725   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, dst, src));
16726   clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
16727
16728   emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
16729 }
16730
16731 /* Split lea instructions into a sequence of instructions
16732    which are executed on ALU to avoid AGU stalls.
16733    It is assumed that it is allowed to clobber flags register
16734    at lea position.  */
16735
16736 extern void
16737 ix86_split_lea_for_addr (rtx operands[], enum machine_mode mode)
16738 {
16739   unsigned int regno0 = true_regnum (operands[0]) ;
16740   unsigned int regno1 = INVALID_REGNUM;
16741   unsigned int regno2 = INVALID_REGNUM;
16742   struct ix86_address parts;
16743   rtx tmp;
16744   int ok, adds;
16745
16746   ok = ix86_decompose_address (operands[1], &parts);
16747   gcc_assert (ok);
16748
16749   if (parts.base)
16750     {
16751       if (GET_MODE (parts.base) != mode)
16752         parts.base = gen_rtx_SUBREG (mode, parts.base, 0);
16753       regno1 = true_regnum (parts.base);
16754     }
16755
16756   if (parts.index)
16757     {
16758       if (GET_MODE (parts.index) != mode)
16759         parts.index = gen_rtx_SUBREG (mode, parts.index, 0);
16760       regno2 = true_regnum (parts.index);
16761     }
16762
16763   if (parts.scale > 1)
16764     {
16765       /* Case r1 = r1 + ...  */
16766       if (regno1 == regno0)
16767         {
16768           /* If we have a case r1 = r1 + C * r1 then we
16769              should use multiplication which is very
16770              expensive.  Assume cost model is wrong if we
16771              have such case here.  */
16772           gcc_assert (regno2 != regno0);
16773
16774           for (adds = parts.scale; adds > 0; adds--)
16775             ix86_emit_binop (PLUS, mode, operands[0], parts.index);
16776         }
16777       else
16778         {
16779           /* r1 = r2 + r3 * C case.  Need to move r3 into r1.  */
16780           if (regno0 != regno2)
16781             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.index));
16782
16783           /* Use shift for scaling.  */
16784           ix86_emit_binop (ASHIFT, mode, operands[0],
16785                            GEN_INT (exact_log2 (parts.scale)));
16786
16787           if (parts.base)
16788             ix86_emit_binop (PLUS, mode, operands[0], parts.base);
16789
16790           if (parts.disp && parts.disp != const0_rtx)
16791             ix86_emit_binop (PLUS, mode, operands[0], parts.disp);
16792         }
16793     }
16794   else if (!parts.base && !parts.index)
16795     {
16796       gcc_assert(parts.disp);
16797       emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.disp));
16798     }
16799   else
16800     {
16801       if (!parts.base)
16802         {
16803           if (regno0 != regno2)
16804             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.index));
16805         }
16806       else if (!parts.index)
16807         {
16808           if (regno0 != regno1)
16809             emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.base));
16810         }
16811       else
16812         {
16813           if (regno0 == regno1)
16814             tmp = parts.index;
16815           else if (regno0 == regno2)
16816             tmp = parts.base;
16817           else
16818             {
16819               emit_insn (gen_rtx_SET (VOIDmode, operands[0], parts.base));
16820               tmp = parts.index;
16821             }
16822
16823           ix86_emit_binop (PLUS, mode, operands[0], tmp);
16824         }
16825
16826       if (parts.disp && parts.disp != const0_rtx)
16827         ix86_emit_binop (PLUS, mode, operands[0], parts.disp);
16828     }
16829 }
16830
16831 /* Return true if it is ok to optimize an ADD operation to LEA
16832    operation to avoid flag register consumation.  For most processors,
16833    ADD is faster than LEA.  For the processors like ATOM, if the
16834    destination register of LEA holds an actual address which will be
16835    used soon, LEA is better and otherwise ADD is better.  */
16836
16837 bool
16838 ix86_lea_for_add_ok (rtx insn, rtx operands[])
16839 {
16840   unsigned int regno0 = true_regnum (operands[0]);
16841   unsigned int regno1 = true_regnum (operands[1]);
16842   unsigned int regno2 = true_regnum (operands[2]);
16843
16844   /* If a = b + c, (a!=b && a!=c), must use lea form. */
16845   if (regno0 != regno1 && regno0 != regno2)
16846     return true;
16847
16848   if (!TARGET_OPT_AGU || optimize_function_for_size_p (cfun))
16849     return false;
16850
16851   return ix86_lea_outperforms (insn, regno0, regno1, regno2, 0);
16852 }
16853
16854 /* Return true if destination reg of SET_BODY is shift count of
16855    USE_BODY.  */
16856
16857 static bool
16858 ix86_dep_by_shift_count_body (const_rtx set_body, const_rtx use_body)
16859 {
16860   rtx set_dest;
16861   rtx shift_rtx;
16862   int i;
16863
16864   /* Retrieve destination of SET_BODY.  */
16865   switch (GET_CODE (set_body))
16866     {
16867     case SET:
16868       set_dest = SET_DEST (set_body);
16869       if (!set_dest || !REG_P (set_dest))
16870         return false;
16871       break;
16872     case PARALLEL:
16873       for (i = XVECLEN (set_body, 0) - 1; i >= 0; i--)
16874         if (ix86_dep_by_shift_count_body (XVECEXP (set_body, 0, i),
16875                                           use_body))
16876           return true;
16877     default:
16878       return false;
16879       break;
16880     }
16881
16882   /* Retrieve shift count of USE_BODY.  */
16883   switch (GET_CODE (use_body))
16884     {
16885     case SET:
16886       shift_rtx = XEXP (use_body, 1);
16887       break;
16888     case PARALLEL:
16889       for (i = XVECLEN (use_body, 0) - 1; i >= 0; i--)
16890         if (ix86_dep_by_shift_count_body (set_body,
16891                                           XVECEXP (use_body, 0, i)))
16892           return true;
16893     default:
16894       return false;
16895       break;
16896     }
16897
16898   if (shift_rtx
16899       && (GET_CODE (shift_rtx) == ASHIFT
16900           || GET_CODE (shift_rtx) == LSHIFTRT
16901           || GET_CODE (shift_rtx) == ASHIFTRT
16902           || GET_CODE (shift_rtx) == ROTATE
16903           || GET_CODE (shift_rtx) == ROTATERT))
16904     {
16905       rtx shift_count = XEXP (shift_rtx, 1);
16906
16907       /* Return true if shift count is dest of SET_BODY.  */
16908       if (REG_P (shift_count)
16909           && true_regnum (set_dest) == true_regnum (shift_count))
16910         return true;
16911     }
16912
16913   return false;
16914 }
16915
16916 /* Return true if destination reg of SET_INSN is shift count of
16917    USE_INSN.  */
16918
16919 bool
16920 ix86_dep_by_shift_count (const_rtx set_insn, const_rtx use_insn)
16921 {
16922   return ix86_dep_by_shift_count_body (PATTERN (set_insn),
16923                                        PATTERN (use_insn));
16924 }
16925
16926 /* Return TRUE or FALSE depending on whether the unary operator meets the
16927    appropriate constraints.  */
16928
16929 bool
16930 ix86_unary_operator_ok (enum rtx_code code ATTRIBUTE_UNUSED,
16931                         enum machine_mode mode ATTRIBUTE_UNUSED,
16932                         rtx operands[2] ATTRIBUTE_UNUSED)
16933 {
16934   /* If one of operands is memory, source and destination must match.  */
16935   if ((MEM_P (operands[0])
16936        || MEM_P (operands[1]))
16937       && ! rtx_equal_p (operands[0], operands[1]))
16938     return false;
16939   return true;
16940 }
16941
16942 /* Return TRUE if the operands to a vec_interleave_{high,low}v2df
16943    are ok, keeping in mind the possible movddup alternative.  */
16944
16945 bool
16946 ix86_vec_interleave_v2df_operator_ok (rtx operands[3], bool high)
16947 {
16948   if (MEM_P (operands[0]))
16949     return rtx_equal_p (operands[0], operands[1 + high]);
16950   if (MEM_P (operands[1]) && MEM_P (operands[2]))
16951     return TARGET_SSE3 && rtx_equal_p (operands[1], operands[2]);
16952   return true;
16953 }
16954
16955 /* Post-reload splitter for converting an SF or DFmode value in an
16956    SSE register into an unsigned SImode.  */
16957
16958 void
16959 ix86_split_convert_uns_si_sse (rtx operands[])
16960 {
16961   enum machine_mode vecmode;
16962   rtx value, large, zero_or_two31, input, two31, x;
16963
16964   large = operands[1];
16965   zero_or_two31 = operands[2];
16966   input = operands[3];
16967   two31 = operands[4];
16968   vecmode = GET_MODE (large);
16969   value = gen_rtx_REG (vecmode, REGNO (operands[0]));
16970
16971   /* Load up the value into the low element.  We must ensure that the other
16972      elements are valid floats -- zero is the easiest such value.  */
16973   if (MEM_P (input))
16974     {
16975       if (vecmode == V4SFmode)
16976         emit_insn (gen_vec_setv4sf_0 (value, CONST0_RTX (V4SFmode), input));
16977       else
16978         emit_insn (gen_sse2_loadlpd (value, CONST0_RTX (V2DFmode), input));
16979     }
16980   else
16981     {
16982       input = gen_rtx_REG (vecmode, REGNO (input));
16983       emit_move_insn (value, CONST0_RTX (vecmode));
16984       if (vecmode == V4SFmode)
16985         emit_insn (gen_sse_movss (value, value, input));
16986       else
16987         emit_insn (gen_sse2_movsd (value, value, input));
16988     }
16989
16990   emit_move_insn (large, two31);
16991   emit_move_insn (zero_or_two31, MEM_P (two31) ? large : two31);
16992
16993   x = gen_rtx_fmt_ee (LE, vecmode, large, value);
16994   emit_insn (gen_rtx_SET (VOIDmode, large, x));
16995
16996   x = gen_rtx_AND (vecmode, zero_or_two31, large);
16997   emit_insn (gen_rtx_SET (VOIDmode, zero_or_two31, x));
16998
16999   x = gen_rtx_MINUS (vecmode, value, zero_or_two31);
17000   emit_insn (gen_rtx_SET (VOIDmode, value, x));
17001
17002   large = gen_rtx_REG (V4SImode, REGNO (large));
17003   emit_insn (gen_ashlv4si3 (large, large, GEN_INT (31)));
17004
17005   x = gen_rtx_REG (V4SImode, REGNO (value));
17006   if (vecmode == V4SFmode)
17007     emit_insn (gen_fix_truncv4sfv4si2 (x, value));
17008   else
17009     emit_insn (gen_sse2_cvttpd2dq (x, value));
17010   value = x;
17011
17012   emit_insn (gen_xorv4si3 (value, value, large));
17013 }
17014
17015 /* Convert an unsigned DImode value into a DFmode, using only SSE.
17016    Expects the 64-bit DImode to be supplied in a pair of integral
17017    registers.  Requires SSE2; will use SSE3 if available.  For x86_32,
17018    -mfpmath=sse, !optimize_size only.  */
17019
17020 void
17021 ix86_expand_convert_uns_didf_sse (rtx target, rtx input)
17022 {
17023   REAL_VALUE_TYPE bias_lo_rvt, bias_hi_rvt;
17024   rtx int_xmm, fp_xmm;
17025   rtx biases, exponents;
17026   rtx x;
17027
17028   int_xmm = gen_reg_rtx (V4SImode);
17029   if (TARGET_INTER_UNIT_MOVES)
17030     emit_insn (gen_movdi_to_sse (int_xmm, input));
17031   else if (TARGET_SSE_SPLIT_REGS)
17032     {
17033       emit_clobber (int_xmm);
17034       emit_move_insn (gen_lowpart (DImode, int_xmm), input);
17035     }
17036   else
17037     {
17038       x = gen_reg_rtx (V2DImode);
17039       ix86_expand_vector_init_one_nonzero (false, V2DImode, x, input, 0);
17040       emit_move_insn (int_xmm, gen_lowpart (V4SImode, x));
17041     }
17042
17043   x = gen_rtx_CONST_VECTOR (V4SImode,
17044                             gen_rtvec (4, GEN_INT (0x43300000UL),
17045                                        GEN_INT (0x45300000UL),
17046                                        const0_rtx, const0_rtx));
17047   exponents = validize_mem (force_const_mem (V4SImode, x));
17048
17049   /* int_xmm = {0x45300000UL, fp_xmm/hi, 0x43300000, fp_xmm/lo } */
17050   emit_insn (gen_vec_interleave_lowv4si (int_xmm, int_xmm, exponents));
17051
17052   /* Concatenating (juxtaposing) (0x43300000UL ## fp_value_low_xmm)
17053      yields a valid DF value equal to (0x1.0p52 + double(fp_value_lo_xmm)).
17054      Similarly (0x45300000UL ## fp_value_hi_xmm) yields
17055      (0x1.0p84 + double(fp_value_hi_xmm)).
17056      Note these exponents differ by 32.  */
17057
17058   fp_xmm = copy_to_mode_reg (V2DFmode, gen_lowpart (V2DFmode, int_xmm));
17059
17060   /* Subtract off those 0x1.0p52 and 0x1.0p84 biases, to produce values
17061      in [0,2**32-1] and [0]+[2**32,2**64-1] respectively.  */
17062   real_ldexp (&bias_lo_rvt, &dconst1, 52);
17063   real_ldexp (&bias_hi_rvt, &dconst1, 84);
17064   biases = const_double_from_real_value (bias_lo_rvt, DFmode);
17065   x = const_double_from_real_value (bias_hi_rvt, DFmode);
17066   biases = gen_rtx_CONST_VECTOR (V2DFmode, gen_rtvec (2, biases, x));
17067   biases = validize_mem (force_const_mem (V2DFmode, biases));
17068   emit_insn (gen_subv2df3 (fp_xmm, fp_xmm, biases));
17069
17070   /* Add the upper and lower DFmode values together.  */
17071   if (TARGET_SSE3)
17072     emit_insn (gen_sse3_haddv2df3 (fp_xmm, fp_xmm, fp_xmm));
17073   else
17074     {
17075       x = copy_to_mode_reg (V2DFmode, fp_xmm);
17076       emit_insn (gen_vec_interleave_highv2df (fp_xmm, fp_xmm, fp_xmm));
17077       emit_insn (gen_addv2df3 (fp_xmm, fp_xmm, x));
17078     }
17079
17080   ix86_expand_vector_extract (false, target, fp_xmm, 0);
17081 }
17082
17083 /* Not used, but eases macroization of patterns.  */
17084 void
17085 ix86_expand_convert_uns_sixf_sse (rtx target ATTRIBUTE_UNUSED,
17086                                   rtx input ATTRIBUTE_UNUSED)
17087 {
17088   gcc_unreachable ();
17089 }
17090
17091 /* Convert an unsigned SImode value into a DFmode.  Only currently used
17092    for SSE, but applicable anywhere.  */
17093
17094 void
17095 ix86_expand_convert_uns_sidf_sse (rtx target, rtx input)
17096 {
17097   REAL_VALUE_TYPE TWO31r;
17098   rtx x, fp;
17099
17100   x = expand_simple_binop (SImode, PLUS, input, GEN_INT (-2147483647 - 1),
17101                            NULL, 1, OPTAB_DIRECT);
17102
17103   fp = gen_reg_rtx (DFmode);
17104   emit_insn (gen_floatsidf2 (fp, x));
17105
17106   real_ldexp (&TWO31r, &dconst1, 31);
17107   x = const_double_from_real_value (TWO31r, DFmode);
17108
17109   x = expand_simple_binop (DFmode, PLUS, fp, x, target, 0, OPTAB_DIRECT);
17110   if (x != target)
17111     emit_move_insn (target, x);
17112 }
17113
17114 /* Convert a signed DImode value into a DFmode.  Only used for SSE in
17115    32-bit mode; otherwise we have a direct convert instruction.  */
17116
17117 void
17118 ix86_expand_convert_sign_didf_sse (rtx target, rtx input)
17119 {
17120   REAL_VALUE_TYPE TWO32r;
17121   rtx fp_lo, fp_hi, x;
17122
17123   fp_lo = gen_reg_rtx (DFmode);
17124   fp_hi = gen_reg_rtx (DFmode);
17125
17126   emit_insn (gen_floatsidf2 (fp_hi, gen_highpart (SImode, input)));
17127
17128   real_ldexp (&TWO32r, &dconst1, 32);
17129   x = const_double_from_real_value (TWO32r, DFmode);
17130   fp_hi = expand_simple_binop (DFmode, MULT, fp_hi, x, fp_hi, 0, OPTAB_DIRECT);
17131
17132   ix86_expand_convert_uns_sidf_sse (fp_lo, gen_lowpart (SImode, input));
17133
17134   x = expand_simple_binop (DFmode, PLUS, fp_hi, fp_lo, target,
17135                            0, OPTAB_DIRECT);
17136   if (x != target)
17137     emit_move_insn (target, x);
17138 }
17139
17140 /* Convert an unsigned SImode value into a SFmode, using only SSE.
17141    For x86_32, -mfpmath=sse, !optimize_size only.  */
17142 void
17143 ix86_expand_convert_uns_sisf_sse (rtx target, rtx input)
17144 {
17145   REAL_VALUE_TYPE ONE16r;
17146   rtx fp_hi, fp_lo, int_hi, int_lo, x;
17147
17148   real_ldexp (&ONE16r, &dconst1, 16);
17149   x = const_double_from_real_value (ONE16r, SFmode);
17150   int_lo = expand_simple_binop (SImode, AND, input, GEN_INT(0xffff),
17151                                       NULL, 0, OPTAB_DIRECT);
17152   int_hi = expand_simple_binop (SImode, LSHIFTRT, input, GEN_INT(16),
17153                                       NULL, 0, OPTAB_DIRECT);
17154   fp_hi = gen_reg_rtx (SFmode);
17155   fp_lo = gen_reg_rtx (SFmode);
17156   emit_insn (gen_floatsisf2 (fp_hi, int_hi));
17157   emit_insn (gen_floatsisf2 (fp_lo, int_lo));
17158   fp_hi = expand_simple_binop (SFmode, MULT, fp_hi, x, fp_hi,
17159                                0, OPTAB_DIRECT);
17160   fp_hi = expand_simple_binop (SFmode, PLUS, fp_hi, fp_lo, target,
17161                                0, OPTAB_DIRECT);
17162   if (!rtx_equal_p (target, fp_hi))
17163     emit_move_insn (target, fp_hi);
17164 }
17165
17166 /* floatunsv{4,8}siv{4,8}sf2 expander.  Expand code to convert
17167    a vector of unsigned ints VAL to vector of floats TARGET.  */
17168
17169 void
17170 ix86_expand_vector_convert_uns_vsivsf (rtx target, rtx val)
17171 {
17172   rtx tmp[8];
17173   REAL_VALUE_TYPE TWO16r;
17174   enum machine_mode intmode = GET_MODE (val);
17175   enum machine_mode fltmode = GET_MODE (target);
17176   rtx (*cvt) (rtx, rtx);
17177
17178   if (intmode == V4SImode)
17179     cvt = gen_floatv4siv4sf2;
17180   else
17181     cvt = gen_floatv8siv8sf2;
17182   tmp[0] = ix86_build_const_vector (intmode, 1, GEN_INT (0xffff));
17183   tmp[0] = force_reg (intmode, tmp[0]);
17184   tmp[1] = expand_simple_binop (intmode, AND, val, tmp[0], NULL_RTX, 1,
17185                                 OPTAB_DIRECT);
17186   tmp[2] = expand_simple_binop (intmode, LSHIFTRT, val, GEN_INT (16),
17187                                 NULL_RTX, 1, OPTAB_DIRECT);
17188   tmp[3] = gen_reg_rtx (fltmode);
17189   emit_insn (cvt (tmp[3], tmp[1]));
17190   tmp[4] = gen_reg_rtx (fltmode);
17191   emit_insn (cvt (tmp[4], tmp[2]));
17192   real_ldexp (&TWO16r, &dconst1, 16);
17193   tmp[5] = const_double_from_real_value (TWO16r, SFmode);
17194   tmp[5] = force_reg (fltmode, ix86_build_const_vector (fltmode, 1, tmp[5]));
17195   tmp[6] = expand_simple_binop (fltmode, MULT, tmp[4], tmp[5], NULL_RTX, 1,
17196                                 OPTAB_DIRECT);
17197   tmp[7] = expand_simple_binop (fltmode, PLUS, tmp[3], tmp[6], target, 1,
17198                                 OPTAB_DIRECT);
17199   if (tmp[7] != target)
17200     emit_move_insn (target, tmp[7]);
17201 }
17202
17203 /* Adjust a V*SFmode/V*DFmode value VAL so that *sfix_trunc* resp. fix_trunc*
17204    pattern can be used on it instead of *ufix_trunc* resp. fixuns_trunc*.
17205    This is done by doing just signed conversion if < 0x1p31, and otherwise by
17206    subtracting 0x1p31 first and xoring in 0x80000000 from *XORP afterwards.  */
17207
17208 rtx
17209 ix86_expand_adjust_ufix_to_sfix_si (rtx val, rtx *xorp)
17210 {
17211   REAL_VALUE_TYPE TWO31r;
17212   rtx two31r, tmp[4];
17213   enum machine_mode mode = GET_MODE (val);
17214   enum machine_mode scalarmode = GET_MODE_INNER (mode);
17215   enum machine_mode intmode = GET_MODE_SIZE (mode) == 32 ? V8SImode : V4SImode;
17216   rtx (*cmp) (rtx, rtx, rtx, rtx);
17217   int i;
17218
17219   for (i = 0; i < 3; i++)
17220     tmp[i] = gen_reg_rtx (mode);
17221   real_ldexp (&TWO31r, &dconst1, 31);
17222   two31r = const_double_from_real_value (TWO31r, scalarmode);
17223   two31r = ix86_build_const_vector (mode, 1, two31r);
17224   two31r = force_reg (mode, two31r);
17225   switch (mode)
17226     {
17227     case V8SFmode: cmp = gen_avx_maskcmpv8sf3; break;
17228     case V4SFmode: cmp = gen_sse_maskcmpv4sf3; break;
17229     case V4DFmode: cmp = gen_avx_maskcmpv4df3; break;
17230     case V2DFmode: cmp = gen_sse2_maskcmpv2df3; break;
17231     default: gcc_unreachable ();
17232     }
17233   tmp[3] = gen_rtx_LE (mode, two31r, val);
17234   emit_insn (cmp (tmp[0], two31r, val, tmp[3]));
17235   tmp[1] = expand_simple_binop (mode, AND, tmp[0], two31r, tmp[1],
17236                                 0, OPTAB_DIRECT);
17237   if (intmode == V4SImode || TARGET_AVX2)
17238     *xorp = expand_simple_binop (intmode, ASHIFT,
17239                                  gen_lowpart (intmode, tmp[0]),
17240                                  GEN_INT (31), NULL_RTX, 0,
17241                                  OPTAB_DIRECT);
17242   else
17243     {
17244       rtx two31 = GEN_INT ((unsigned HOST_WIDE_INT) 1 << 31);
17245       two31 = ix86_build_const_vector (intmode, 1, two31);
17246       *xorp = expand_simple_binop (intmode, AND,
17247                                    gen_lowpart (intmode, tmp[0]),
17248                                    two31, NULL_RTX, 0,
17249                                    OPTAB_DIRECT);
17250     }
17251   return expand_simple_binop (mode, MINUS, val, tmp[1], tmp[2],
17252                               0, OPTAB_DIRECT);
17253 }
17254
17255 /* A subroutine of ix86_build_signbit_mask.  If VECT is true,
17256    then replicate the value for all elements of the vector
17257    register.  */
17258
17259 rtx
17260 ix86_build_const_vector (enum machine_mode mode, bool vect, rtx value)
17261 {
17262   int i, n_elt;
17263   rtvec v;
17264   enum machine_mode scalar_mode;
17265
17266   switch (mode)
17267     {
17268     case V32QImode:
17269     case V16QImode:
17270     case V16HImode:
17271     case V8HImode:
17272     case V8SImode:
17273     case V4SImode:
17274     case V4DImode:
17275     case V2DImode:
17276       gcc_assert (vect);
17277     case V8SFmode:
17278     case V4SFmode:
17279     case V4DFmode:
17280     case V2DFmode:
17281       n_elt = GET_MODE_NUNITS (mode);
17282       v = rtvec_alloc (n_elt);
17283       scalar_mode = GET_MODE_INNER (mode);
17284
17285       RTVEC_ELT (v, 0) = value;
17286
17287       for (i = 1; i < n_elt; ++i)
17288         RTVEC_ELT (v, i) = vect ? value : CONST0_RTX (scalar_mode);
17289
17290       return gen_rtx_CONST_VECTOR (mode, v);
17291
17292     default:
17293       gcc_unreachable ();
17294     }
17295 }
17296
17297 /* A subroutine of ix86_expand_fp_absneg_operator, copysign expanders
17298    and ix86_expand_int_vcond.  Create a mask for the sign bit in MODE
17299    for an SSE register.  If VECT is true, then replicate the mask for
17300    all elements of the vector register.  If INVERT is true, then create
17301    a mask excluding the sign bit.  */
17302
17303 rtx
17304 ix86_build_signbit_mask (enum machine_mode mode, bool vect, bool invert)
17305 {
17306   enum machine_mode vec_mode, imode;
17307   HOST_WIDE_INT hi, lo;
17308   int shift = 63;
17309   rtx v;
17310   rtx mask;
17311
17312   /* Find the sign bit, sign extended to 2*HWI.  */
17313   switch (mode)
17314     {
17315     case V8SImode:
17316     case V4SImode:
17317     case V8SFmode:
17318     case V4SFmode:
17319       vec_mode = mode;
17320       mode = GET_MODE_INNER (mode);
17321       imode = SImode;
17322       lo = 0x80000000, hi = lo < 0;
17323       break;
17324
17325     case V4DImode:
17326     case V2DImode:
17327     case V4DFmode:
17328     case V2DFmode:
17329       vec_mode = mode;
17330       mode = GET_MODE_INNER (mode);
17331       imode = DImode;
17332       if (HOST_BITS_PER_WIDE_INT >= 64)
17333         lo = (HOST_WIDE_INT)1 << shift, hi = -1;
17334       else
17335         lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
17336       break;
17337
17338     case TImode:
17339     case TFmode:
17340       vec_mode = VOIDmode;
17341       if (HOST_BITS_PER_WIDE_INT >= 64)
17342         {
17343           imode = TImode;
17344           lo = 0, hi = (HOST_WIDE_INT)1 << shift;
17345         }
17346       else
17347         {
17348           rtvec vec;
17349
17350           imode = DImode;
17351           lo = 0, hi = (HOST_WIDE_INT)1 << (shift - HOST_BITS_PER_WIDE_INT);
17352
17353           if (invert)
17354             {
17355               lo = ~lo, hi = ~hi;
17356               v = constm1_rtx;
17357             }
17358           else
17359             v = const0_rtx;
17360
17361           mask = immed_double_const (lo, hi, imode);
17362
17363           vec = gen_rtvec (2, v, mask);
17364           v = gen_rtx_CONST_VECTOR (V2DImode, vec);
17365           v = copy_to_mode_reg (mode, gen_lowpart (mode, v));
17366
17367           return v;
17368         }
17369      break;
17370
17371     default:
17372       gcc_unreachable ();
17373     }
17374
17375   if (invert)
17376     lo = ~lo, hi = ~hi;
17377
17378   /* Force this value into the low part of a fp vector constant.  */
17379   mask = immed_double_const (lo, hi, imode);
17380   mask = gen_lowpart (mode, mask);
17381
17382   if (vec_mode == VOIDmode)
17383     return force_reg (mode, mask);
17384
17385   v = ix86_build_const_vector (vec_mode, vect, mask);
17386   return force_reg (vec_mode, v);
17387 }
17388
17389 /* Generate code for floating point ABS or NEG.  */
17390
17391 void
17392 ix86_expand_fp_absneg_operator (enum rtx_code code, enum machine_mode mode,
17393                                 rtx operands[])
17394 {
17395   rtx mask, set, dst, src;
17396   bool use_sse = false;
17397   bool vector_mode = VECTOR_MODE_P (mode);
17398   enum machine_mode vmode = mode;
17399
17400   if (vector_mode)
17401     use_sse = true;
17402   else if (mode == TFmode)
17403     use_sse = true;
17404   else if (TARGET_SSE_MATH)
17405     {
17406       use_sse = SSE_FLOAT_MODE_P (mode);
17407       if (mode == SFmode)
17408         vmode = V4SFmode;
17409       else if (mode == DFmode)
17410         vmode = V2DFmode;
17411     }
17412
17413   /* NEG and ABS performed with SSE use bitwise mask operations.
17414      Create the appropriate mask now.  */
17415   if (use_sse)
17416     mask = ix86_build_signbit_mask (vmode, vector_mode, code == ABS);
17417   else
17418     mask = NULL_RTX;
17419
17420   dst = operands[0];
17421   src = operands[1];
17422
17423   set = gen_rtx_fmt_e (code, mode, src);
17424   set = gen_rtx_SET (VOIDmode, dst, set);
17425
17426   if (mask)
17427     {
17428       rtx use, clob;
17429       rtvec par;
17430
17431       use = gen_rtx_USE (VOIDmode, mask);
17432       if (vector_mode)
17433         par = gen_rtvec (2, set, use);
17434       else
17435         {
17436           clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
17437           par = gen_rtvec (3, set, use, clob);
17438         }
17439       emit_insn (gen_rtx_PARALLEL (VOIDmode, par));
17440     }
17441   else
17442     emit_insn (set);
17443 }
17444
17445 /* Expand a copysign operation.  Special case operand 0 being a constant.  */
17446
17447 void
17448 ix86_expand_copysign (rtx operands[])
17449 {
17450   enum machine_mode mode, vmode;
17451   rtx dest, op0, op1, mask, nmask;
17452
17453   dest = operands[0];
17454   op0 = operands[1];
17455   op1 = operands[2];
17456
17457   mode = GET_MODE (dest);
17458
17459   if (mode == SFmode)
17460     vmode = V4SFmode;
17461   else if (mode == DFmode)
17462     vmode = V2DFmode;
17463   else
17464     vmode = mode;
17465
17466   if (GET_CODE (op0) == CONST_DOUBLE)
17467     {
17468       rtx (*copysign_insn)(rtx, rtx, rtx, rtx);
17469
17470       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
17471         op0 = simplify_unary_operation (ABS, mode, op0, mode);
17472
17473       if (mode == SFmode || mode == DFmode)
17474         {
17475           if (op0 == CONST0_RTX (mode))
17476             op0 = CONST0_RTX (vmode);
17477           else
17478             {
17479               rtx v = ix86_build_const_vector (vmode, false, op0);
17480
17481               op0 = force_reg (vmode, v);
17482             }
17483         }
17484       else if (op0 != CONST0_RTX (mode))
17485         op0 = force_reg (mode, op0);
17486
17487       mask = ix86_build_signbit_mask (vmode, 0, 0);
17488
17489       if (mode == SFmode)
17490         copysign_insn = gen_copysignsf3_const;
17491       else if (mode == DFmode)
17492         copysign_insn = gen_copysigndf3_const;
17493       else
17494         copysign_insn = gen_copysigntf3_const;
17495
17496         emit_insn (copysign_insn (dest, op0, op1, mask));
17497     }
17498   else
17499     {
17500       rtx (*copysign_insn)(rtx, rtx, rtx, rtx, rtx, rtx);
17501
17502       nmask = ix86_build_signbit_mask (vmode, 0, 1);
17503       mask = ix86_build_signbit_mask (vmode, 0, 0);
17504
17505       if (mode == SFmode)
17506         copysign_insn = gen_copysignsf3_var;
17507       else if (mode == DFmode)
17508         copysign_insn = gen_copysigndf3_var;
17509       else
17510         copysign_insn = gen_copysigntf3_var;
17511
17512       emit_insn (copysign_insn (dest, NULL_RTX, op0, op1, nmask, mask));
17513     }
17514 }
17515
17516 /* Deconstruct a copysign operation into bit masks.  Operand 0 is known to
17517    be a constant, and so has already been expanded into a vector constant.  */
17518
17519 void
17520 ix86_split_copysign_const (rtx operands[])
17521 {
17522   enum machine_mode mode, vmode;
17523   rtx dest, op0, mask, x;
17524
17525   dest = operands[0];
17526   op0 = operands[1];
17527   mask = operands[3];
17528
17529   mode = GET_MODE (dest);
17530   vmode = GET_MODE (mask);
17531
17532   dest = simplify_gen_subreg (vmode, dest, mode, 0);
17533   x = gen_rtx_AND (vmode, dest, mask);
17534   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17535
17536   if (op0 != CONST0_RTX (vmode))
17537     {
17538       x = gen_rtx_IOR (vmode, dest, op0);
17539       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17540     }
17541 }
17542
17543 /* Deconstruct a copysign operation into bit masks.  Operand 0 is variable,
17544    so we have to do two masks.  */
17545
17546 void
17547 ix86_split_copysign_var (rtx operands[])
17548 {
17549   enum machine_mode mode, vmode;
17550   rtx dest, scratch, op0, op1, mask, nmask, x;
17551
17552   dest = operands[0];
17553   scratch = operands[1];
17554   op0 = operands[2];
17555   op1 = operands[3];
17556   nmask = operands[4];
17557   mask = operands[5];
17558
17559   mode = GET_MODE (dest);
17560   vmode = GET_MODE (mask);
17561
17562   if (rtx_equal_p (op0, op1))
17563     {
17564       /* Shouldn't happen often (it's useless, obviously), but when it does
17565          we'd generate incorrect code if we continue below.  */
17566       emit_move_insn (dest, op0);
17567       return;
17568     }
17569
17570   if (REG_P (mask) && REGNO (dest) == REGNO (mask))     /* alternative 0 */
17571     {
17572       gcc_assert (REGNO (op1) == REGNO (scratch));
17573
17574       x = gen_rtx_AND (vmode, scratch, mask);
17575       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
17576
17577       dest = mask;
17578       op0 = simplify_gen_subreg (vmode, op0, mode, 0);
17579       x = gen_rtx_NOT (vmode, dest);
17580       x = gen_rtx_AND (vmode, x, op0);
17581       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17582     }
17583   else
17584     {
17585       if (REGNO (op1) == REGNO (scratch))               /* alternative 1,3 */
17586         {
17587           x = gen_rtx_AND (vmode, scratch, mask);
17588         }
17589       else                                              /* alternative 2,4 */
17590         {
17591           gcc_assert (REGNO (mask) == REGNO (scratch));
17592           op1 = simplify_gen_subreg (vmode, op1, mode, 0);
17593           x = gen_rtx_AND (vmode, scratch, op1);
17594         }
17595       emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
17596
17597       if (REGNO (op0) == REGNO (dest))                  /* alternative 1,2 */
17598         {
17599           dest = simplify_gen_subreg (vmode, op0, mode, 0);
17600           x = gen_rtx_AND (vmode, dest, nmask);
17601         }
17602       else                                              /* alternative 3,4 */
17603         {
17604           gcc_assert (REGNO (nmask) == REGNO (dest));
17605           dest = nmask;
17606           op0 = simplify_gen_subreg (vmode, op0, mode, 0);
17607           x = gen_rtx_AND (vmode, dest, op0);
17608         }
17609       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17610     }
17611
17612   x = gen_rtx_IOR (vmode, dest, scratch);
17613   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
17614 }
17615
17616 /* Return TRUE or FALSE depending on whether the first SET in INSN
17617    has source and destination with matching CC modes, and that the
17618    CC mode is at least as constrained as REQ_MODE.  */
17619
17620 bool
17621 ix86_match_ccmode (rtx insn, enum machine_mode req_mode)
17622 {
17623   rtx set;
17624   enum machine_mode set_mode;
17625
17626   set = PATTERN (insn);
17627   if (GET_CODE (set) == PARALLEL)
17628     set = XVECEXP (set, 0, 0);
17629   gcc_assert (GET_CODE (set) == SET);
17630   gcc_assert (GET_CODE (SET_SRC (set)) == COMPARE);
17631
17632   set_mode = GET_MODE (SET_DEST (set));
17633   switch (set_mode)
17634     {
17635     case CCNOmode:
17636       if (req_mode != CCNOmode
17637           && (req_mode != CCmode
17638               || XEXP (SET_SRC (set), 1) != const0_rtx))
17639         return false;
17640       break;
17641     case CCmode:
17642       if (req_mode == CCGCmode)
17643         return false;
17644       /* FALLTHRU */
17645     case CCGCmode:
17646       if (req_mode == CCGOCmode || req_mode == CCNOmode)
17647         return false;
17648       /* FALLTHRU */
17649     case CCGOCmode:
17650       if (req_mode == CCZmode)
17651         return false;
17652       /* FALLTHRU */
17653     case CCZmode:
17654       break;
17655
17656     case CCAmode:
17657     case CCCmode:
17658     case CCOmode:
17659     case CCSmode:
17660       if (set_mode != req_mode)
17661         return false;
17662       break;
17663
17664     default:
17665       gcc_unreachable ();
17666     }
17667
17668   return GET_MODE (SET_SRC (set)) == set_mode;
17669 }
17670
17671 /* Generate insn patterns to do an integer compare of OPERANDS.  */
17672
17673 static rtx
17674 ix86_expand_int_compare (enum rtx_code code, rtx op0, rtx op1)
17675 {
17676   enum machine_mode cmpmode;
17677   rtx tmp, flags;
17678
17679   cmpmode = SELECT_CC_MODE (code, op0, op1);
17680   flags = gen_rtx_REG (cmpmode, FLAGS_REG);
17681
17682   /* This is very simple, but making the interface the same as in the
17683      FP case makes the rest of the code easier.  */
17684   tmp = gen_rtx_COMPARE (cmpmode, op0, op1);
17685   emit_insn (gen_rtx_SET (VOIDmode, flags, tmp));
17686
17687   /* Return the test that should be put into the flags user, i.e.
17688      the bcc, scc, or cmov instruction.  */
17689   return gen_rtx_fmt_ee (code, VOIDmode, flags, const0_rtx);
17690 }
17691
17692 /* Figure out whether to use ordered or unordered fp comparisons.
17693    Return the appropriate mode to use.  */
17694
17695 enum machine_mode
17696 ix86_fp_compare_mode (enum rtx_code code ATTRIBUTE_UNUSED)
17697 {
17698   /* ??? In order to make all comparisons reversible, we do all comparisons
17699      non-trapping when compiling for IEEE.  Once gcc is able to distinguish
17700      all forms trapping and nontrapping comparisons, we can make inequality
17701      comparisons trapping again, since it results in better code when using
17702      FCOM based compares.  */
17703   return TARGET_IEEE_FP ? CCFPUmode : CCFPmode;
17704 }
17705
17706 enum machine_mode
17707 ix86_cc_mode (enum rtx_code code, rtx op0, rtx op1)
17708 {
17709   enum machine_mode mode = GET_MODE (op0);
17710
17711   if (SCALAR_FLOAT_MODE_P (mode))
17712     {
17713       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
17714       return ix86_fp_compare_mode (code);
17715     }
17716
17717   switch (code)
17718     {
17719       /* Only zero flag is needed.  */
17720     case EQ:                    /* ZF=0 */
17721     case NE:                    /* ZF!=0 */
17722       return CCZmode;
17723       /* Codes needing carry flag.  */
17724     case GEU:                   /* CF=0 */
17725     case LTU:                   /* CF=1 */
17726       /* Detect overflow checks.  They need just the carry flag.  */
17727       if (GET_CODE (op0) == PLUS
17728           && rtx_equal_p (op1, XEXP (op0, 0)))
17729         return CCCmode;
17730       else
17731         return CCmode;
17732     case GTU:                   /* CF=0 & ZF=0 */
17733     case LEU:                   /* CF=1 | ZF=1 */
17734       /* Detect overflow checks.  They need just the carry flag.  */
17735       if (GET_CODE (op0) == MINUS
17736           && rtx_equal_p (op1, XEXP (op0, 0)))
17737         return CCCmode;
17738       else
17739         return CCmode;
17740       /* Codes possibly doable only with sign flag when
17741          comparing against zero.  */
17742     case GE:                    /* SF=OF   or   SF=0 */
17743     case LT:                    /* SF<>OF  or   SF=1 */
17744       if (op1 == const0_rtx)
17745         return CCGOCmode;
17746       else
17747         /* For other cases Carry flag is not required.  */
17748         return CCGCmode;
17749       /* Codes doable only with sign flag when comparing
17750          against zero, but we miss jump instruction for it
17751          so we need to use relational tests against overflow
17752          that thus needs to be zero.  */
17753     case GT:                    /* ZF=0 & SF=OF */
17754     case LE:                    /* ZF=1 | SF<>OF */
17755       if (op1 == const0_rtx)
17756         return CCNOmode;
17757       else
17758         return CCGCmode;
17759       /* strcmp pattern do (use flags) and combine may ask us for proper
17760          mode.  */
17761     case USE:
17762       return CCmode;
17763     default:
17764       gcc_unreachable ();
17765     }
17766 }
17767
17768 /* Return the fixed registers used for condition codes.  */
17769
17770 static bool
17771 ix86_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
17772 {
17773   *p1 = FLAGS_REG;
17774   *p2 = FPSR_REG;
17775   return true;
17776 }
17777
17778 /* If two condition code modes are compatible, return a condition code
17779    mode which is compatible with both.  Otherwise, return
17780    VOIDmode.  */
17781
17782 static enum machine_mode
17783 ix86_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
17784 {
17785   if (m1 == m2)
17786     return m1;
17787
17788   if (GET_MODE_CLASS (m1) != MODE_CC || GET_MODE_CLASS (m2) != MODE_CC)
17789     return VOIDmode;
17790
17791   if ((m1 == CCGCmode && m2 == CCGOCmode)
17792       || (m1 == CCGOCmode && m2 == CCGCmode))
17793     return CCGCmode;
17794
17795   switch (m1)
17796     {
17797     default:
17798       gcc_unreachable ();
17799
17800     case CCmode:
17801     case CCGCmode:
17802     case CCGOCmode:
17803     case CCNOmode:
17804     case CCAmode:
17805     case CCCmode:
17806     case CCOmode:
17807     case CCSmode:
17808     case CCZmode:
17809       switch (m2)
17810         {
17811         default:
17812           return VOIDmode;
17813
17814         case CCmode:
17815         case CCGCmode:
17816         case CCGOCmode:
17817         case CCNOmode:
17818         case CCAmode:
17819         case CCCmode:
17820         case CCOmode:
17821         case CCSmode:
17822         case CCZmode:
17823           return CCmode;
17824         }
17825
17826     case CCFPmode:
17827     case CCFPUmode:
17828       /* These are only compatible with themselves, which we already
17829          checked above.  */
17830       return VOIDmode;
17831     }
17832 }
17833
17834
17835 /* Return a comparison we can do and that it is equivalent to
17836    swap_condition (code) apart possibly from orderedness.
17837    But, never change orderedness if TARGET_IEEE_FP, returning
17838    UNKNOWN in that case if necessary.  */
17839
17840 static enum rtx_code
17841 ix86_fp_swap_condition (enum rtx_code code)
17842 {
17843   switch (code)
17844     {
17845     case GT:                   /* GTU - CF=0 & ZF=0 */
17846       return TARGET_IEEE_FP ? UNKNOWN : UNLT;
17847     case GE:                   /* GEU - CF=0 */
17848       return TARGET_IEEE_FP ? UNKNOWN : UNLE;
17849     case UNLT:                 /* LTU - CF=1 */
17850       return TARGET_IEEE_FP ? UNKNOWN : GT;
17851     case UNLE:                 /* LEU - CF=1 | ZF=1 */
17852       return TARGET_IEEE_FP ? UNKNOWN : GE;
17853     default:
17854       return swap_condition (code);
17855     }
17856 }
17857
17858 /* Return cost of comparison CODE using the best strategy for performance.
17859    All following functions do use number of instructions as a cost metrics.
17860    In future this should be tweaked to compute bytes for optimize_size and
17861    take into account performance of various instructions on various CPUs.  */
17862
17863 static int
17864 ix86_fp_comparison_cost (enum rtx_code code)
17865 {
17866   int arith_cost;
17867
17868   /* The cost of code using bit-twiddling on %ah.  */
17869   switch (code)
17870     {
17871     case UNLE:
17872     case UNLT:
17873     case LTGT:
17874     case GT:
17875     case GE:
17876     case UNORDERED:
17877     case ORDERED:
17878     case UNEQ:
17879       arith_cost = 4;
17880       break;
17881     case LT:
17882     case NE:
17883     case EQ:
17884     case UNGE:
17885       arith_cost = TARGET_IEEE_FP ? 5 : 4;
17886       break;
17887     case LE:
17888     case UNGT:
17889       arith_cost = TARGET_IEEE_FP ? 6 : 4;
17890       break;
17891     default:
17892       gcc_unreachable ();
17893     }
17894
17895   switch (ix86_fp_comparison_strategy (code))
17896     {
17897     case IX86_FPCMP_COMI:
17898       return arith_cost > 4 ? 3 : 2;
17899     case IX86_FPCMP_SAHF:
17900       return arith_cost > 4 ? 4 : 3;
17901     default:
17902       return arith_cost;
17903     }
17904 }
17905
17906 /* Return strategy to use for floating-point.  We assume that fcomi is always
17907    preferrable where available, since that is also true when looking at size
17908    (2 bytes, vs. 3 for fnstsw+sahf and at least 5 for fnstsw+test).  */
17909
17910 enum ix86_fpcmp_strategy
17911 ix86_fp_comparison_strategy (enum rtx_code code ATTRIBUTE_UNUSED)
17912 {
17913   /* Do fcomi/sahf based test when profitable.  */
17914
17915   if (TARGET_CMOVE)
17916     return IX86_FPCMP_COMI;
17917
17918   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_function_for_size_p (cfun)))
17919     return IX86_FPCMP_SAHF;
17920
17921   return IX86_FPCMP_ARITH;
17922 }
17923
17924 /* Swap, force into registers, or otherwise massage the two operands
17925    to a fp comparison.  The operands are updated in place; the new
17926    comparison code is returned.  */
17927
17928 static enum rtx_code
17929 ix86_prepare_fp_compare_args (enum rtx_code code, rtx *pop0, rtx *pop1)
17930 {
17931   enum machine_mode fpcmp_mode = ix86_fp_compare_mode (code);
17932   rtx op0 = *pop0, op1 = *pop1;
17933   enum machine_mode op_mode = GET_MODE (op0);
17934   int is_sse = TARGET_SSE_MATH && SSE_FLOAT_MODE_P (op_mode);
17935
17936   /* All of the unordered compare instructions only work on registers.
17937      The same is true of the fcomi compare instructions.  The XFmode
17938      compare instructions require registers except when comparing
17939      against zero or when converting operand 1 from fixed point to
17940      floating point.  */
17941
17942   if (!is_sse
17943       && (fpcmp_mode == CCFPUmode
17944           || (op_mode == XFmode
17945               && ! (standard_80387_constant_p (op0) == 1
17946                     || standard_80387_constant_p (op1) == 1)
17947               && GET_CODE (op1) != FLOAT)
17948           || ix86_fp_comparison_strategy (code) == IX86_FPCMP_COMI))
17949     {
17950       op0 = force_reg (op_mode, op0);
17951       op1 = force_reg (op_mode, op1);
17952     }
17953   else
17954     {
17955       /* %%% We only allow op1 in memory; op0 must be st(0).  So swap
17956          things around if they appear profitable, otherwise force op0
17957          into a register.  */
17958
17959       if (standard_80387_constant_p (op0) == 0
17960           || (MEM_P (op0)
17961               && ! (standard_80387_constant_p (op1) == 0
17962                     || MEM_P (op1))))
17963         {
17964           enum rtx_code new_code = ix86_fp_swap_condition (code);
17965           if (new_code != UNKNOWN)
17966             {
17967               rtx tmp;
17968               tmp = op0, op0 = op1, op1 = tmp;
17969               code = new_code;
17970             }
17971         }
17972
17973       if (!REG_P (op0))
17974         op0 = force_reg (op_mode, op0);
17975
17976       if (CONSTANT_P (op1))
17977         {
17978           int tmp = standard_80387_constant_p (op1);
17979           if (tmp == 0)
17980             op1 = validize_mem (force_const_mem (op_mode, op1));
17981           else if (tmp == 1)
17982             {
17983               if (TARGET_CMOVE)
17984                 op1 = force_reg (op_mode, op1);
17985             }
17986           else
17987             op1 = force_reg (op_mode, op1);
17988         }
17989     }
17990
17991   /* Try to rearrange the comparison to make it cheaper.  */
17992   if (ix86_fp_comparison_cost (code)
17993       > ix86_fp_comparison_cost (swap_condition (code))
17994       && (REG_P (op1) || can_create_pseudo_p ()))
17995     {
17996       rtx tmp;
17997       tmp = op0, op0 = op1, op1 = tmp;
17998       code = swap_condition (code);
17999       if (!REG_P (op0))
18000         op0 = force_reg (op_mode, op0);
18001     }
18002
18003   *pop0 = op0;
18004   *pop1 = op1;
18005   return code;
18006 }
18007
18008 /* Convert comparison codes we use to represent FP comparison to integer
18009    code that will result in proper branch.  Return UNKNOWN if no such code
18010    is available.  */
18011
18012 enum rtx_code
18013 ix86_fp_compare_code_to_integer (enum rtx_code code)
18014 {
18015   switch (code)
18016     {
18017     case GT:
18018       return GTU;
18019     case GE:
18020       return GEU;
18021     case ORDERED:
18022     case UNORDERED:
18023       return code;
18024       break;
18025     case UNEQ:
18026       return EQ;
18027       break;
18028     case UNLT:
18029       return LTU;
18030       break;
18031     case UNLE:
18032       return LEU;
18033       break;
18034     case LTGT:
18035       return NE;
18036       break;
18037     default:
18038       return UNKNOWN;
18039     }
18040 }
18041
18042 /* Generate insn patterns to do a floating point compare of OPERANDS.  */
18043
18044 static rtx
18045 ix86_expand_fp_compare (enum rtx_code code, rtx op0, rtx op1, rtx scratch)
18046 {
18047   enum machine_mode fpcmp_mode, intcmp_mode;
18048   rtx tmp, tmp2;
18049
18050   fpcmp_mode = ix86_fp_compare_mode (code);
18051   code = ix86_prepare_fp_compare_args (code, &op0, &op1);
18052
18053   /* Do fcomi/sahf based test when profitable.  */
18054   switch (ix86_fp_comparison_strategy (code))
18055     {
18056     case IX86_FPCMP_COMI:
18057       intcmp_mode = fpcmp_mode;
18058       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
18059       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
18060                          tmp);
18061       emit_insn (tmp);
18062       break;
18063
18064     case IX86_FPCMP_SAHF:
18065       intcmp_mode = fpcmp_mode;
18066       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
18067       tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
18068                          tmp);
18069
18070       if (!scratch)
18071         scratch = gen_reg_rtx (HImode);
18072       tmp2 = gen_rtx_CLOBBER (VOIDmode, scratch);
18073       emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, tmp2)));
18074       break;
18075
18076     case IX86_FPCMP_ARITH:
18077       /* Sadness wrt reg-stack pops killing fpsr -- gotta get fnstsw first.  */
18078       tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
18079       tmp2 = gen_rtx_UNSPEC (HImode, gen_rtvec (1, tmp), UNSPEC_FNSTSW);
18080       if (!scratch)
18081         scratch = gen_reg_rtx (HImode);
18082       emit_insn (gen_rtx_SET (VOIDmode, scratch, tmp2));
18083
18084       /* In the unordered case, we have to check C2 for NaN's, which
18085          doesn't happen to work out to anything nice combination-wise.
18086          So do some bit twiddling on the value we've got in AH to come
18087          up with an appropriate set of condition codes.  */
18088
18089       intcmp_mode = CCNOmode;
18090       switch (code)
18091         {
18092         case GT:
18093         case UNGT:
18094           if (code == GT || !TARGET_IEEE_FP)
18095             {
18096               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
18097               code = EQ;
18098             }
18099           else
18100             {
18101               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18102               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
18103               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x44)));
18104               intcmp_mode = CCmode;
18105               code = GEU;
18106             }
18107           break;
18108         case LT:
18109         case UNLT:
18110           if (code == LT && TARGET_IEEE_FP)
18111             {
18112               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18113               emit_insn (gen_cmpqi_ext_3 (scratch, const1_rtx));
18114               intcmp_mode = CCmode;
18115               code = EQ;
18116             }
18117           else
18118             {
18119               emit_insn (gen_testqi_ext_ccno_0 (scratch, const1_rtx));
18120               code = NE;
18121             }
18122           break;
18123         case GE:
18124         case UNGE:
18125           if (code == GE || !TARGET_IEEE_FP)
18126             {
18127               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x05)));
18128               code = EQ;
18129             }
18130           else
18131             {
18132               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18133               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch, const1_rtx));
18134               code = NE;
18135             }
18136           break;
18137         case LE:
18138         case UNLE:
18139           if (code == LE && TARGET_IEEE_FP)
18140             {
18141               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18142               emit_insn (gen_addqi_ext_1 (scratch, scratch, constm1_rtx));
18143               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
18144               intcmp_mode = CCmode;
18145               code = LTU;
18146             }
18147           else
18148             {
18149               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x45)));
18150               code = NE;
18151             }
18152           break;
18153         case EQ:
18154         case UNEQ:
18155           if (code == EQ && TARGET_IEEE_FP)
18156             {
18157               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18158               emit_insn (gen_cmpqi_ext_3 (scratch, GEN_INT (0x40)));
18159               intcmp_mode = CCmode;
18160               code = EQ;
18161             }
18162           else
18163             {
18164               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
18165               code = NE;
18166             }
18167           break;
18168         case NE:
18169         case LTGT:
18170           if (code == NE && TARGET_IEEE_FP)
18171             {
18172               emit_insn (gen_andqi_ext_0 (scratch, scratch, GEN_INT (0x45)));
18173               emit_insn (gen_xorqi_cc_ext_1 (scratch, scratch,
18174                                              GEN_INT (0x40)));
18175               code = NE;
18176             }
18177           else
18178             {
18179               emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x40)));
18180               code = EQ;
18181             }
18182           break;
18183
18184         case UNORDERED:
18185           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
18186           code = NE;
18187           break;
18188         case ORDERED:
18189           emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x04)));
18190           code = EQ;
18191           break;
18192
18193         default:
18194           gcc_unreachable ();
18195         }
18196         break;
18197
18198     default:
18199       gcc_unreachable();
18200     }
18201
18202   /* Return the test that should be put into the flags user, i.e.
18203      the bcc, scc, or cmov instruction.  */
18204   return gen_rtx_fmt_ee (code, VOIDmode,
18205                          gen_rtx_REG (intcmp_mode, FLAGS_REG),
18206                          const0_rtx);
18207 }
18208
18209 static rtx
18210 ix86_expand_compare (enum rtx_code code, rtx op0, rtx op1)
18211 {
18212   rtx ret;
18213
18214   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
18215     ret = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
18216
18217   else if (SCALAR_FLOAT_MODE_P (GET_MODE (op0)))
18218     {
18219       gcc_assert (!DECIMAL_FLOAT_MODE_P (GET_MODE (op0)));
18220       ret = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
18221     }
18222   else
18223     ret = ix86_expand_int_compare (code, op0, op1);
18224
18225   return ret;
18226 }
18227
18228 void
18229 ix86_expand_branch (enum rtx_code code, rtx op0, rtx op1, rtx label)
18230 {
18231   enum machine_mode mode = GET_MODE (op0);
18232   rtx tmp;
18233
18234   switch (mode)
18235     {
18236     case SFmode:
18237     case DFmode:
18238     case XFmode:
18239     case QImode:
18240     case HImode:
18241     case SImode:
18242       simple:
18243       tmp = ix86_expand_compare (code, op0, op1);
18244       tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
18245                                   gen_rtx_LABEL_REF (VOIDmode, label),
18246                                   pc_rtx);
18247       emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
18248       return;
18249
18250     case DImode:
18251       if (TARGET_64BIT)
18252         goto simple;
18253     case TImode:
18254       /* Expand DImode branch into multiple compare+branch.  */
18255       {
18256         rtx lo[2], hi[2], label2;
18257         enum rtx_code code1, code2, code3;
18258         enum machine_mode submode;
18259
18260         if (CONSTANT_P (op0) && !CONSTANT_P (op1))
18261           {
18262             tmp = op0, op0 = op1, op1 = tmp;
18263             code = swap_condition (code);
18264           }
18265
18266         split_double_mode (mode, &op0, 1, lo+0, hi+0);
18267         split_double_mode (mode, &op1, 1, lo+1, hi+1);
18268
18269         submode = mode == DImode ? SImode : DImode;
18270
18271         /* When comparing for equality, we can use (hi0^hi1)|(lo0^lo1) to
18272            avoid two branches.  This costs one extra insn, so disable when
18273            optimizing for size.  */
18274
18275         if ((code == EQ || code == NE)
18276             && (!optimize_insn_for_size_p ()
18277                 || hi[1] == const0_rtx || lo[1] == const0_rtx))
18278           {
18279             rtx xor0, xor1;
18280
18281             xor1 = hi[0];
18282             if (hi[1] != const0_rtx)
18283               xor1 = expand_binop (submode, xor_optab, xor1, hi[1],
18284                                    NULL_RTX, 0, OPTAB_WIDEN);
18285
18286             xor0 = lo[0];
18287             if (lo[1] != const0_rtx)
18288               xor0 = expand_binop (submode, xor_optab, xor0, lo[1],
18289                                    NULL_RTX, 0, OPTAB_WIDEN);
18290
18291             tmp = expand_binop (submode, ior_optab, xor1, xor0,
18292                                 NULL_RTX, 0, OPTAB_WIDEN);
18293
18294             ix86_expand_branch (code, tmp, const0_rtx, label);
18295             return;
18296           }
18297
18298         /* Otherwise, if we are doing less-than or greater-or-equal-than,
18299            op1 is a constant and the low word is zero, then we can just
18300            examine the high word.  Similarly for low word -1 and
18301            less-or-equal-than or greater-than.  */
18302
18303         if (CONST_INT_P (hi[1]))
18304           switch (code)
18305             {
18306             case LT: case LTU: case GE: case GEU:
18307               if (lo[1] == const0_rtx)
18308                 {
18309                   ix86_expand_branch (code, hi[0], hi[1], label);
18310                   return;
18311                 }
18312               break;
18313             case LE: case LEU: case GT: case GTU:
18314               if (lo[1] == constm1_rtx)
18315                 {
18316                   ix86_expand_branch (code, hi[0], hi[1], label);
18317                   return;
18318                 }
18319               break;
18320             default:
18321               break;
18322             }
18323
18324         /* Otherwise, we need two or three jumps.  */
18325
18326         label2 = gen_label_rtx ();
18327
18328         code1 = code;
18329         code2 = swap_condition (code);
18330         code3 = unsigned_condition (code);
18331
18332         switch (code)
18333           {
18334           case LT: case GT: case LTU: case GTU:
18335             break;
18336
18337           case LE:   code1 = LT;  code2 = GT;  break;
18338           case GE:   code1 = GT;  code2 = LT;  break;
18339           case LEU:  code1 = LTU; code2 = GTU; break;
18340           case GEU:  code1 = GTU; code2 = LTU; break;
18341
18342           case EQ:   code1 = UNKNOWN; code2 = NE;  break;
18343           case NE:   code2 = UNKNOWN; break;
18344
18345           default:
18346             gcc_unreachable ();
18347           }
18348
18349         /*
18350          * a < b =>
18351          *    if (hi(a) < hi(b)) goto true;
18352          *    if (hi(a) > hi(b)) goto false;
18353          *    if (lo(a) < lo(b)) goto true;
18354          *  false:
18355          */
18356
18357         if (code1 != UNKNOWN)
18358           ix86_expand_branch (code1, hi[0], hi[1], label);
18359         if (code2 != UNKNOWN)
18360           ix86_expand_branch (code2, hi[0], hi[1], label2);
18361
18362         ix86_expand_branch (code3, lo[0], lo[1], label);
18363
18364         if (code2 != UNKNOWN)
18365           emit_label (label2);
18366         return;
18367       }
18368
18369     default:
18370       gcc_assert (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC);
18371       goto simple;
18372     }
18373 }
18374
18375 /* Split branch based on floating point condition.  */
18376 void
18377 ix86_split_fp_branch (enum rtx_code code, rtx op1, rtx op2,
18378                       rtx target1, rtx target2, rtx tmp, rtx pushed)
18379 {
18380   rtx condition;
18381   rtx i;
18382
18383   if (target2 != pc_rtx)
18384     {
18385       rtx tmp = target2;
18386       code = reverse_condition_maybe_unordered (code);
18387       target2 = target1;
18388       target1 = tmp;
18389     }
18390
18391   condition = ix86_expand_fp_compare (code, op1, op2,
18392                                       tmp);
18393
18394   /* Remove pushed operand from stack.  */
18395   if (pushed)
18396     ix86_free_from_memory (GET_MODE (pushed));
18397
18398   i = emit_jump_insn (gen_rtx_SET
18399                       (VOIDmode, pc_rtx,
18400                        gen_rtx_IF_THEN_ELSE (VOIDmode,
18401                                              condition, target1, target2)));
18402   if (split_branch_probability >= 0)
18403     add_reg_note (i, REG_BR_PROB, GEN_INT (split_branch_probability));
18404 }
18405
18406 void
18407 ix86_expand_setcc (rtx dest, enum rtx_code code, rtx op0, rtx op1)
18408 {
18409   rtx ret;
18410
18411   gcc_assert (GET_MODE (dest) == QImode);
18412
18413   ret = ix86_expand_compare (code, op0, op1);
18414   PUT_MODE (ret, QImode);
18415   emit_insn (gen_rtx_SET (VOIDmode, dest, ret));
18416 }
18417
18418 /* Expand comparison setting or clearing carry flag.  Return true when
18419    successful and set pop for the operation.  */
18420 static bool
18421 ix86_expand_carry_flag_compare (enum rtx_code code, rtx op0, rtx op1, rtx *pop)
18422 {
18423   enum machine_mode mode =
18424     GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
18425
18426   /* Do not handle double-mode compares that go through special path.  */
18427   if (mode == (TARGET_64BIT ? TImode : DImode))
18428     return false;
18429
18430   if (SCALAR_FLOAT_MODE_P (mode))
18431     {
18432       rtx compare_op, compare_seq;
18433
18434       gcc_assert (!DECIMAL_FLOAT_MODE_P (mode));
18435
18436       /* Shortcut:  following common codes never translate
18437          into carry flag compares.  */
18438       if (code == EQ || code == NE || code == UNEQ || code == LTGT
18439           || code == ORDERED || code == UNORDERED)
18440         return false;
18441
18442       /* These comparisons require zero flag; swap operands so they won't.  */
18443       if ((code == GT || code == UNLE || code == LE || code == UNGT)
18444           && !TARGET_IEEE_FP)
18445         {
18446           rtx tmp = op0;
18447           op0 = op1;
18448           op1 = tmp;
18449           code = swap_condition (code);
18450         }
18451
18452       /* Try to expand the comparison and verify that we end up with
18453          carry flag based comparison.  This fails to be true only when
18454          we decide to expand comparison using arithmetic that is not
18455          too common scenario.  */
18456       start_sequence ();
18457       compare_op = ix86_expand_fp_compare (code, op0, op1, NULL_RTX);
18458       compare_seq = get_insns ();
18459       end_sequence ();
18460
18461       if (GET_MODE (XEXP (compare_op, 0)) == CCFPmode
18462           || GET_MODE (XEXP (compare_op, 0)) == CCFPUmode)
18463         code = ix86_fp_compare_code_to_integer (GET_CODE (compare_op));
18464       else
18465         code = GET_CODE (compare_op);
18466
18467       if (code != LTU && code != GEU)
18468         return false;
18469
18470       emit_insn (compare_seq);
18471       *pop = compare_op;
18472       return true;
18473     }
18474
18475   if (!INTEGRAL_MODE_P (mode))
18476     return false;
18477
18478   switch (code)
18479     {
18480     case LTU:
18481     case GEU:
18482       break;
18483
18484     /* Convert a==0 into (unsigned)a<1.  */
18485     case EQ:
18486     case NE:
18487       if (op1 != const0_rtx)
18488         return false;
18489       op1 = const1_rtx;
18490       code = (code == EQ ? LTU : GEU);
18491       break;
18492
18493     /* Convert a>b into b<a or a>=b-1.  */
18494     case GTU:
18495     case LEU:
18496       if (CONST_INT_P (op1))
18497         {
18498           op1 = gen_int_mode (INTVAL (op1) + 1, GET_MODE (op0));
18499           /* Bail out on overflow.  We still can swap operands but that
18500              would force loading of the constant into register.  */
18501           if (op1 == const0_rtx
18502               || !x86_64_immediate_operand (op1, GET_MODE (op1)))
18503             return false;
18504           code = (code == GTU ? GEU : LTU);
18505         }
18506       else
18507         {
18508           rtx tmp = op1;
18509           op1 = op0;
18510           op0 = tmp;
18511           code = (code == GTU ? LTU : GEU);
18512         }
18513       break;
18514
18515     /* Convert a>=0 into (unsigned)a<0x80000000.  */
18516     case LT:
18517     case GE:
18518       if (mode == DImode || op1 != const0_rtx)
18519         return false;
18520       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
18521       code = (code == LT ? GEU : LTU);
18522       break;
18523     case LE:
18524     case GT:
18525       if (mode == DImode || op1 != constm1_rtx)
18526         return false;
18527       op1 = gen_int_mode (1 << (GET_MODE_BITSIZE (mode) - 1), mode);
18528       code = (code == LE ? GEU : LTU);
18529       break;
18530
18531     default:
18532       return false;
18533     }
18534   /* Swapping operands may cause constant to appear as first operand.  */
18535   if (!nonimmediate_operand (op0, VOIDmode))
18536     {
18537       if (!can_create_pseudo_p ())
18538         return false;
18539       op0 = force_reg (mode, op0);
18540     }
18541   *pop = ix86_expand_compare (code, op0, op1);
18542   gcc_assert (GET_CODE (*pop) == LTU || GET_CODE (*pop) == GEU);
18543   return true;
18544 }
18545
18546 bool
18547 ix86_expand_int_movcc (rtx operands[])
18548 {
18549   enum rtx_code code = GET_CODE (operands[1]), compare_code;
18550   rtx compare_seq, compare_op;
18551   enum machine_mode mode = GET_MODE (operands[0]);
18552   bool sign_bit_compare_p = false;
18553   rtx op0 = XEXP (operands[1], 0);
18554   rtx op1 = XEXP (operands[1], 1);
18555
18556   start_sequence ();
18557   compare_op = ix86_expand_compare (code, op0, op1);
18558   compare_seq = get_insns ();
18559   end_sequence ();
18560
18561   compare_code = GET_CODE (compare_op);
18562
18563   if ((op1 == const0_rtx && (code == GE || code == LT))
18564       || (op1 == constm1_rtx && (code == GT || code == LE)))
18565     sign_bit_compare_p = true;
18566
18567   /* Don't attempt mode expansion here -- if we had to expand 5 or 6
18568      HImode insns, we'd be swallowed in word prefix ops.  */
18569
18570   if ((mode != HImode || TARGET_FAST_PREFIX)
18571       && (mode != (TARGET_64BIT ? TImode : DImode))
18572       && CONST_INT_P (operands[2])
18573       && CONST_INT_P (operands[3]))
18574     {
18575       rtx out = operands[0];
18576       HOST_WIDE_INT ct = INTVAL (operands[2]);
18577       HOST_WIDE_INT cf = INTVAL (operands[3]);
18578       HOST_WIDE_INT diff;
18579
18580       diff = ct - cf;
18581       /*  Sign bit compares are better done using shifts than we do by using
18582           sbb.  */
18583       if (sign_bit_compare_p
18584           || ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
18585         {
18586           /* Detect overlap between destination and compare sources.  */
18587           rtx tmp = out;
18588
18589           if (!sign_bit_compare_p)
18590             {
18591               rtx flags;
18592               bool fpcmp = false;
18593
18594               compare_code = GET_CODE (compare_op);
18595
18596               flags = XEXP (compare_op, 0);
18597
18598               if (GET_MODE (flags) == CCFPmode
18599                   || GET_MODE (flags) == CCFPUmode)
18600                 {
18601                   fpcmp = true;
18602                   compare_code
18603                     = ix86_fp_compare_code_to_integer (compare_code);
18604                 }
18605
18606               /* To simplify rest of code, restrict to the GEU case.  */
18607               if (compare_code == LTU)
18608                 {
18609                   HOST_WIDE_INT tmp = ct;
18610                   ct = cf;
18611                   cf = tmp;
18612                   compare_code = reverse_condition (compare_code);
18613                   code = reverse_condition (code);
18614                 }
18615               else
18616                 {
18617                   if (fpcmp)
18618                     PUT_CODE (compare_op,
18619                               reverse_condition_maybe_unordered
18620                                 (GET_CODE (compare_op)));
18621                   else
18622                     PUT_CODE (compare_op,
18623                               reverse_condition (GET_CODE (compare_op)));
18624                 }
18625               diff = ct - cf;
18626
18627               if (reg_overlap_mentioned_p (out, op0)
18628                   || reg_overlap_mentioned_p (out, op1))
18629                 tmp = gen_reg_rtx (mode);
18630
18631               if (mode == DImode)
18632                 emit_insn (gen_x86_movdicc_0_m1 (tmp, flags, compare_op));
18633               else
18634                 emit_insn (gen_x86_movsicc_0_m1 (gen_lowpart (SImode, tmp),
18635                                                  flags, compare_op));
18636             }
18637           else
18638             {
18639               if (code == GT || code == GE)
18640                 code = reverse_condition (code);
18641               else
18642                 {
18643                   HOST_WIDE_INT tmp = ct;
18644                   ct = cf;
18645                   cf = tmp;
18646                   diff = ct - cf;
18647                 }
18648               tmp = emit_store_flag (tmp, code, op0, op1, VOIDmode, 0, -1);
18649             }
18650
18651           if (diff == 1)
18652             {
18653               /*
18654                * cmpl op0,op1
18655                * sbbl dest,dest
18656                * [addl dest, ct]
18657                *
18658                * Size 5 - 8.
18659                */
18660               if (ct)
18661                 tmp = expand_simple_binop (mode, PLUS,
18662                                            tmp, GEN_INT (ct),
18663                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18664             }
18665           else if (cf == -1)
18666             {
18667               /*
18668                * cmpl op0,op1
18669                * sbbl dest,dest
18670                * orl $ct, dest
18671                *
18672                * Size 8.
18673                */
18674               tmp = expand_simple_binop (mode, IOR,
18675                                          tmp, GEN_INT (ct),
18676                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
18677             }
18678           else if (diff == -1 && ct)
18679             {
18680               /*
18681                * cmpl op0,op1
18682                * sbbl dest,dest
18683                * notl dest
18684                * [addl dest, cf]
18685                *
18686                * Size 8 - 11.
18687                */
18688               tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
18689               if (cf)
18690                 tmp = expand_simple_binop (mode, PLUS,
18691                                            copy_rtx (tmp), GEN_INT (cf),
18692                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18693             }
18694           else
18695             {
18696               /*
18697                * cmpl op0,op1
18698                * sbbl dest,dest
18699                * [notl dest]
18700                * andl cf - ct, dest
18701                * [addl dest, ct]
18702                *
18703                * Size 8 - 11.
18704                */
18705
18706               if (cf == 0)
18707                 {
18708                   cf = ct;
18709                   ct = 0;
18710                   tmp = expand_simple_unop (mode, NOT, tmp, copy_rtx (tmp), 1);
18711                 }
18712
18713               tmp = expand_simple_binop (mode, AND,
18714                                          copy_rtx (tmp),
18715                                          gen_int_mode (cf - ct, mode),
18716                                          copy_rtx (tmp), 1, OPTAB_DIRECT);
18717               if (ct)
18718                 tmp = expand_simple_binop (mode, PLUS,
18719                                            copy_rtx (tmp), GEN_INT (ct),
18720                                            copy_rtx (tmp), 1, OPTAB_DIRECT);
18721             }
18722
18723           if (!rtx_equal_p (tmp, out))
18724             emit_move_insn (copy_rtx (out), copy_rtx (tmp));
18725
18726           return true;
18727         }
18728
18729       if (diff < 0)
18730         {
18731           enum machine_mode cmp_mode = GET_MODE (op0);
18732
18733           HOST_WIDE_INT tmp;
18734           tmp = ct, ct = cf, cf = tmp;
18735           diff = -diff;
18736
18737           if (SCALAR_FLOAT_MODE_P (cmp_mode))
18738             {
18739               gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18740
18741               /* We may be reversing unordered compare to normal compare, that
18742                  is not valid in general (we may convert non-trapping condition
18743                  to trapping one), however on i386 we currently emit all
18744                  comparisons unordered.  */
18745               compare_code = reverse_condition_maybe_unordered (compare_code);
18746               code = reverse_condition_maybe_unordered (code);
18747             }
18748           else
18749             {
18750               compare_code = reverse_condition (compare_code);
18751               code = reverse_condition (code);
18752             }
18753         }
18754
18755       compare_code = UNKNOWN;
18756       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
18757           && CONST_INT_P (op1))
18758         {
18759           if (op1 == const0_rtx
18760               && (code == LT || code == GE))
18761             compare_code = code;
18762           else if (op1 == constm1_rtx)
18763             {
18764               if (code == LE)
18765                 compare_code = LT;
18766               else if (code == GT)
18767                 compare_code = GE;
18768             }
18769         }
18770
18771       /* Optimize dest = (op0 < 0) ? -1 : cf.  */
18772       if (compare_code != UNKNOWN
18773           && GET_MODE (op0) == GET_MODE (out)
18774           && (cf == -1 || ct == -1))
18775         {
18776           /* If lea code below could be used, only optimize
18777              if it results in a 2 insn sequence.  */
18778
18779           if (! (diff == 1 || diff == 2 || diff == 4 || diff == 8
18780                  || diff == 3 || diff == 5 || diff == 9)
18781               || (compare_code == LT && ct == -1)
18782               || (compare_code == GE && cf == -1))
18783             {
18784               /*
18785                * notl op1       (if necessary)
18786                * sarl $31, op1
18787                * orl cf, op1
18788                */
18789               if (ct != -1)
18790                 {
18791                   cf = ct;
18792                   ct = -1;
18793                   code = reverse_condition (code);
18794                 }
18795
18796               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18797
18798               out = expand_simple_binop (mode, IOR,
18799                                          out, GEN_INT (cf),
18800                                          out, 1, OPTAB_DIRECT);
18801               if (out != operands[0])
18802                 emit_move_insn (operands[0], out);
18803
18804               return true;
18805             }
18806         }
18807
18808
18809       if ((diff == 1 || diff == 2 || diff == 4 || diff == 8
18810            || diff == 3 || diff == 5 || diff == 9)
18811           && ((mode != QImode && mode != HImode) || !TARGET_PARTIAL_REG_STALL)
18812           && (mode != DImode
18813               || x86_64_immediate_operand (GEN_INT (cf), VOIDmode)))
18814         {
18815           /*
18816            * xorl dest,dest
18817            * cmpl op1,op2
18818            * setcc dest
18819            * lea cf(dest*(ct-cf)),dest
18820            *
18821            * Size 14.
18822            *
18823            * This also catches the degenerate setcc-only case.
18824            */
18825
18826           rtx tmp;
18827           int nops;
18828
18829           out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18830
18831           nops = 0;
18832           /* On x86_64 the lea instruction operates on Pmode, so we need
18833              to get arithmetics done in proper mode to match.  */
18834           if (diff == 1)
18835             tmp = copy_rtx (out);
18836           else
18837             {
18838               rtx out1;
18839               out1 = copy_rtx (out);
18840               tmp = gen_rtx_MULT (mode, out1, GEN_INT (diff & ~1));
18841               nops++;
18842               if (diff & 1)
18843                 {
18844                   tmp = gen_rtx_PLUS (mode, tmp, out1);
18845                   nops++;
18846                 }
18847             }
18848           if (cf != 0)
18849             {
18850               tmp = gen_rtx_PLUS (mode, tmp, GEN_INT (cf));
18851               nops++;
18852             }
18853           if (!rtx_equal_p (tmp, out))
18854             {
18855               if (nops == 1)
18856                 out = force_operand (tmp, copy_rtx (out));
18857               else
18858                 emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (out), copy_rtx (tmp)));
18859             }
18860           if (!rtx_equal_p (out, operands[0]))
18861             emit_move_insn (operands[0], copy_rtx (out));
18862
18863           return true;
18864         }
18865
18866       /*
18867        * General case:                  Jumpful:
18868        *   xorl dest,dest               cmpl op1, op2
18869        *   cmpl op1, op2                movl ct, dest
18870        *   setcc dest                   jcc 1f
18871        *   decl dest                    movl cf, dest
18872        *   andl (cf-ct),dest            1:
18873        *   addl ct,dest
18874        *
18875        * Size 20.                       Size 14.
18876        *
18877        * This is reasonably steep, but branch mispredict costs are
18878        * high on modern cpus, so consider failing only if optimizing
18879        * for space.
18880        */
18881
18882       if ((!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18883           && BRANCH_COST (optimize_insn_for_speed_p (),
18884                           false) >= 2)
18885         {
18886           if (cf == 0)
18887             {
18888               enum machine_mode cmp_mode = GET_MODE (op0);
18889
18890               cf = ct;
18891               ct = 0;
18892
18893               if (SCALAR_FLOAT_MODE_P (cmp_mode))
18894                 {
18895                   gcc_assert (!DECIMAL_FLOAT_MODE_P (cmp_mode));
18896
18897                   /* We may be reversing unordered compare to normal compare,
18898                      that is not valid in general (we may convert non-trapping
18899                      condition to trapping one), however on i386 we currently
18900                      emit all comparisons unordered.  */
18901                   code = reverse_condition_maybe_unordered (code);
18902                 }
18903               else
18904                 {
18905                   code = reverse_condition (code);
18906                   if (compare_code != UNKNOWN)
18907                     compare_code = reverse_condition (compare_code);
18908                 }
18909             }
18910
18911           if (compare_code != UNKNOWN)
18912             {
18913               /* notl op1       (if needed)
18914                  sarl $31, op1
18915                  andl (cf-ct), op1
18916                  addl ct, op1
18917
18918                  For x < 0 (resp. x <= -1) there will be no notl,
18919                  so if possible swap the constants to get rid of the
18920                  complement.
18921                  True/false will be -1/0 while code below (store flag
18922                  followed by decrement) is 0/-1, so the constants need
18923                  to be exchanged once more.  */
18924
18925               if (compare_code == GE || !cf)
18926                 {
18927                   code = reverse_condition (code);
18928                   compare_code = LT;
18929                 }
18930               else
18931                 {
18932                   HOST_WIDE_INT tmp = cf;
18933                   cf = ct;
18934                   ct = tmp;
18935                 }
18936
18937               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, -1);
18938             }
18939           else
18940             {
18941               out = emit_store_flag (out, code, op0, op1, VOIDmode, 0, 1);
18942
18943               out = expand_simple_binop (mode, PLUS, copy_rtx (out),
18944                                          constm1_rtx,
18945                                          copy_rtx (out), 1, OPTAB_DIRECT);
18946             }
18947
18948           out = expand_simple_binop (mode, AND, copy_rtx (out),
18949                                      gen_int_mode (cf - ct, mode),
18950                                      copy_rtx (out), 1, OPTAB_DIRECT);
18951           if (ct)
18952             out = expand_simple_binop (mode, PLUS, copy_rtx (out), GEN_INT (ct),
18953                                        copy_rtx (out), 1, OPTAB_DIRECT);
18954           if (!rtx_equal_p (out, operands[0]))
18955             emit_move_insn (operands[0], copy_rtx (out));
18956
18957           return true;
18958         }
18959     }
18960
18961   if (!TARGET_CMOVE || (mode == QImode && TARGET_PARTIAL_REG_STALL))
18962     {
18963       /* Try a few things more with specific constants and a variable.  */
18964
18965       optab op;
18966       rtx var, orig_out, out, tmp;
18967
18968       if (BRANCH_COST (optimize_insn_for_speed_p (), false) <= 2)
18969         return false;
18970
18971       /* If one of the two operands is an interesting constant, load a
18972          constant with the above and mask it in with a logical operation.  */
18973
18974       if (CONST_INT_P (operands[2]))
18975         {
18976           var = operands[3];
18977           if (INTVAL (operands[2]) == 0 && operands[3] != constm1_rtx)
18978             operands[3] = constm1_rtx, op = and_optab;
18979           else if (INTVAL (operands[2]) == -1 && operands[3] != const0_rtx)
18980             operands[3] = const0_rtx, op = ior_optab;
18981           else
18982             return false;
18983         }
18984       else if (CONST_INT_P (operands[3]))
18985         {
18986           var = operands[2];
18987           if (INTVAL (operands[3]) == 0 && operands[2] != constm1_rtx)
18988             operands[2] = constm1_rtx, op = and_optab;
18989           else if (INTVAL (operands[3]) == -1 && operands[3] != const0_rtx)
18990             operands[2] = const0_rtx, op = ior_optab;
18991           else
18992             return false;
18993         }
18994       else
18995         return false;
18996
18997       orig_out = operands[0];
18998       tmp = gen_reg_rtx (mode);
18999       operands[0] = tmp;
19000
19001       /* Recurse to get the constant loaded.  */
19002       if (ix86_expand_int_movcc (operands) == 0)
19003         return false;
19004
19005       /* Mask in the interesting variable.  */
19006       out = expand_binop (mode, op, var, tmp, orig_out, 0,
19007                           OPTAB_WIDEN);
19008       if (!rtx_equal_p (out, orig_out))
19009         emit_move_insn (copy_rtx (orig_out), copy_rtx (out));
19010
19011       return true;
19012     }
19013
19014   /*
19015    * For comparison with above,
19016    *
19017    * movl cf,dest
19018    * movl ct,tmp
19019    * cmpl op1,op2
19020    * cmovcc tmp,dest
19021    *
19022    * Size 15.
19023    */
19024
19025   if (! nonimmediate_operand (operands[2], mode))
19026     operands[2] = force_reg (mode, operands[2]);
19027   if (! nonimmediate_operand (operands[3], mode))
19028     operands[3] = force_reg (mode, operands[3]);
19029
19030   if (! register_operand (operands[2], VOIDmode)
19031       && (mode == QImode
19032           || ! register_operand (operands[3], VOIDmode)))
19033     operands[2] = force_reg (mode, operands[2]);
19034
19035   if (mode == QImode
19036       && ! register_operand (operands[3], VOIDmode))
19037     operands[3] = force_reg (mode, operands[3]);
19038
19039   emit_insn (compare_seq);
19040   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
19041                           gen_rtx_IF_THEN_ELSE (mode,
19042                                                 compare_op, operands[2],
19043                                                 operands[3])));
19044   return true;
19045 }
19046
19047 /* Swap, force into registers, or otherwise massage the two operands
19048    to an sse comparison with a mask result.  Thus we differ a bit from
19049    ix86_prepare_fp_compare_args which expects to produce a flags result.
19050
19051    The DEST operand exists to help determine whether to commute commutative
19052    operators.  The POP0/POP1 operands are updated in place.  The new
19053    comparison code is returned, or UNKNOWN if not implementable.  */
19054
19055 static enum rtx_code
19056 ix86_prepare_sse_fp_compare_args (rtx dest, enum rtx_code code,
19057                                   rtx *pop0, rtx *pop1)
19058 {
19059   rtx tmp;
19060
19061   switch (code)
19062     {
19063     case LTGT:
19064     case UNEQ:
19065       /* AVX supports all the needed comparisons.  */
19066       if (TARGET_AVX)
19067         break;
19068       /* We have no LTGT as an operator.  We could implement it with
19069          NE & ORDERED, but this requires an extra temporary.  It's
19070          not clear that it's worth it.  */
19071       return UNKNOWN;
19072
19073     case LT:
19074     case LE:
19075     case UNGT:
19076     case UNGE:
19077       /* These are supported directly.  */
19078       break;
19079
19080     case EQ:
19081     case NE:
19082     case UNORDERED:
19083     case ORDERED:
19084       /* AVX has 3 operand comparisons, no need to swap anything.  */
19085       if (TARGET_AVX)
19086         break;
19087       /* For commutative operators, try to canonicalize the destination
19088          operand to be first in the comparison - this helps reload to
19089          avoid extra moves.  */
19090       if (!dest || !rtx_equal_p (dest, *pop1))
19091         break;
19092       /* FALLTHRU */
19093
19094     case GE:
19095     case GT:
19096     case UNLE:
19097     case UNLT:
19098       /* These are not supported directly before AVX, and furthermore
19099          ix86_expand_sse_fp_minmax only optimizes LT/UNGE.  Swap the
19100          comparison operands to transform into something that is
19101          supported.  */
19102       tmp = *pop0;
19103       *pop0 = *pop1;
19104       *pop1 = tmp;
19105       code = swap_condition (code);
19106       break;
19107
19108     default:
19109       gcc_unreachable ();
19110     }
19111
19112   return code;
19113 }
19114
19115 /* Detect conditional moves that exactly match min/max operational
19116    semantics.  Note that this is IEEE safe, as long as we don't
19117    interchange the operands.
19118
19119    Returns FALSE if this conditional move doesn't match a MIN/MAX,
19120    and TRUE if the operation is successful and instructions are emitted.  */
19121
19122 static bool
19123 ix86_expand_sse_fp_minmax (rtx dest, enum rtx_code code, rtx cmp_op0,
19124                            rtx cmp_op1, rtx if_true, rtx if_false)
19125 {
19126   enum machine_mode mode;
19127   bool is_min;
19128   rtx tmp;
19129
19130   if (code == LT)
19131     ;
19132   else if (code == UNGE)
19133     {
19134       tmp = if_true;
19135       if_true = if_false;
19136       if_false = tmp;
19137     }
19138   else
19139     return false;
19140
19141   if (rtx_equal_p (cmp_op0, if_true) && rtx_equal_p (cmp_op1, if_false))
19142     is_min = true;
19143   else if (rtx_equal_p (cmp_op1, if_true) && rtx_equal_p (cmp_op0, if_false))
19144     is_min = false;
19145   else
19146     return false;
19147
19148   mode = GET_MODE (dest);
19149
19150   /* We want to check HONOR_NANS and HONOR_SIGNED_ZEROS here,
19151      but MODE may be a vector mode and thus not appropriate.  */
19152   if (!flag_finite_math_only || !flag_unsafe_math_optimizations)
19153     {
19154       int u = is_min ? UNSPEC_IEEE_MIN : UNSPEC_IEEE_MAX;
19155       rtvec v;
19156
19157       if_true = force_reg (mode, if_true);
19158       v = gen_rtvec (2, if_true, if_false);
19159       tmp = gen_rtx_UNSPEC (mode, v, u);
19160     }
19161   else
19162     {
19163       code = is_min ? SMIN : SMAX;
19164       tmp = gen_rtx_fmt_ee (code, mode, if_true, if_false);
19165     }
19166
19167   emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
19168   return true;
19169 }
19170
19171 /* Expand an sse vector comparison.  Return the register with the result.  */
19172
19173 static rtx
19174 ix86_expand_sse_cmp (rtx dest, enum rtx_code code, rtx cmp_op0, rtx cmp_op1,
19175                      rtx op_true, rtx op_false)
19176 {
19177   enum machine_mode mode = GET_MODE (dest);
19178   enum machine_mode cmp_mode = GET_MODE (cmp_op0);
19179   rtx x;
19180
19181   cmp_op0 = force_reg (cmp_mode, cmp_op0);
19182   if (!nonimmediate_operand (cmp_op1, cmp_mode))
19183     cmp_op1 = force_reg (cmp_mode, cmp_op1);
19184
19185   if (optimize
19186       || reg_overlap_mentioned_p (dest, op_true)
19187       || reg_overlap_mentioned_p (dest, op_false))
19188     dest = gen_reg_rtx (mode);
19189
19190   x = gen_rtx_fmt_ee (code, cmp_mode, cmp_op0, cmp_op1);
19191   if (cmp_mode != mode)
19192     {
19193       x = force_reg (cmp_mode, x);
19194       convert_move (dest, x, false);
19195     }
19196   else
19197     emit_insn (gen_rtx_SET (VOIDmode, dest, x));
19198
19199   return dest;
19200 }
19201
19202 /* Expand DEST = CMP ? OP_TRUE : OP_FALSE into a sequence of logical
19203    operations.  This is used for both scalar and vector conditional moves.  */
19204
19205 static void
19206 ix86_expand_sse_movcc (rtx dest, rtx cmp, rtx op_true, rtx op_false)
19207 {
19208   enum machine_mode mode = GET_MODE (dest);
19209   rtx t2, t3, x;
19210
19211   if (vector_all_ones_operand (op_true, mode)
19212       && rtx_equal_p (op_false, CONST0_RTX (mode)))
19213     {
19214       emit_insn (gen_rtx_SET (VOIDmode, dest, cmp));
19215     }
19216   else if (op_false == CONST0_RTX (mode))
19217     {
19218       op_true = force_reg (mode, op_true);
19219       x = gen_rtx_AND (mode, cmp, op_true);
19220       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
19221     }
19222   else if (op_true == CONST0_RTX (mode))
19223     {
19224       op_false = force_reg (mode, op_false);
19225       x = gen_rtx_NOT (mode, cmp);
19226       x = gen_rtx_AND (mode, x, op_false);
19227       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
19228     }
19229   else if (INTEGRAL_MODE_P (mode) && op_true == CONSTM1_RTX (mode))
19230     {
19231       op_false = force_reg (mode, op_false);
19232       x = gen_rtx_IOR (mode, cmp, op_false);
19233       emit_insn (gen_rtx_SET (VOIDmode, dest, x));
19234     }
19235   else if (TARGET_XOP)
19236     {
19237       op_true = force_reg (mode, op_true);
19238
19239       if (!nonimmediate_operand (op_false, mode))
19240         op_false = force_reg (mode, op_false);
19241
19242       emit_insn (gen_rtx_SET (mode, dest,
19243                               gen_rtx_IF_THEN_ELSE (mode, cmp,
19244                                                     op_true,
19245                                                     op_false)));
19246     }
19247   else
19248     {
19249       rtx (*gen) (rtx, rtx, rtx, rtx) = NULL;
19250
19251       if (!nonimmediate_operand (op_true, mode))
19252         op_true = force_reg (mode, op_true);
19253
19254       op_false = force_reg (mode, op_false);
19255
19256       switch (mode)
19257         {
19258         case V4SFmode:
19259           if (TARGET_SSE4_1)
19260             gen = gen_sse4_1_blendvps;
19261           break;
19262         case V2DFmode:
19263           if (TARGET_SSE4_1)
19264             gen = gen_sse4_1_blendvpd;
19265           break;
19266         case V16QImode:
19267         case V8HImode:
19268         case V4SImode:
19269         case V2DImode:
19270           if (TARGET_SSE4_1)
19271             {
19272               gen = gen_sse4_1_pblendvb;
19273               dest = gen_lowpart (V16QImode, dest);
19274               op_false = gen_lowpart (V16QImode, op_false);
19275               op_true = gen_lowpart (V16QImode, op_true);
19276               cmp = gen_lowpart (V16QImode, cmp);
19277             }
19278           break;
19279         case V8SFmode:
19280           if (TARGET_AVX)
19281             gen = gen_avx_blendvps256;
19282           break;
19283         case V4DFmode:
19284           if (TARGET_AVX)
19285             gen = gen_avx_blendvpd256;
19286           break;
19287         case V32QImode:
19288         case V16HImode:
19289         case V8SImode:
19290         case V4DImode:
19291           if (TARGET_AVX2)
19292             {
19293               gen = gen_avx2_pblendvb;
19294               dest = gen_lowpart (V32QImode, dest);
19295               op_false = gen_lowpart (V32QImode, op_false);
19296               op_true = gen_lowpart (V32QImode, op_true);
19297               cmp = gen_lowpart (V32QImode, cmp);
19298             }
19299           break;
19300         default:
19301           break;
19302         }
19303
19304       if (gen != NULL)
19305         emit_insn (gen (dest, op_false, op_true, cmp));
19306       else
19307         {
19308           op_true = force_reg (mode, op_true);
19309
19310           t2 = gen_reg_rtx (mode);
19311           if (optimize)
19312             t3 = gen_reg_rtx (mode);
19313           else
19314             t3 = dest;
19315
19316           x = gen_rtx_AND (mode, op_true, cmp);
19317           emit_insn (gen_rtx_SET (VOIDmode, t2, x));
19318
19319           x = gen_rtx_NOT (mode, cmp);
19320           x = gen_rtx_AND (mode, x, op_false);
19321           emit_insn (gen_rtx_SET (VOIDmode, t3, x));
19322
19323           x = gen_rtx_IOR (mode, t3, t2);
19324           emit_insn (gen_rtx_SET (VOIDmode, dest, x));
19325         }
19326     }
19327 }
19328
19329 /* Expand a floating-point conditional move.  Return true if successful.  */
19330
19331 bool
19332 ix86_expand_fp_movcc (rtx operands[])
19333 {
19334   enum machine_mode mode = GET_MODE (operands[0]);
19335   enum rtx_code code = GET_CODE (operands[1]);
19336   rtx tmp, compare_op;
19337   rtx op0 = XEXP (operands[1], 0);
19338   rtx op1 = XEXP (operands[1], 1);
19339
19340   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
19341     {
19342       enum machine_mode cmode;
19343
19344       /* Since we've no cmove for sse registers, don't force bad register
19345          allocation just to gain access to it.  Deny movcc when the
19346          comparison mode doesn't match the move mode.  */
19347       cmode = GET_MODE (op0);
19348       if (cmode == VOIDmode)
19349         cmode = GET_MODE (op1);
19350       if (cmode != mode)
19351         return false;
19352
19353       code = ix86_prepare_sse_fp_compare_args (operands[0], code, &op0, &op1);
19354       if (code == UNKNOWN)
19355         return false;
19356
19357       if (ix86_expand_sse_fp_minmax (operands[0], code, op0, op1,
19358                                      operands[2], operands[3]))
19359         return true;
19360
19361       tmp = ix86_expand_sse_cmp (operands[0], code, op0, op1,
19362                                  operands[2], operands[3]);
19363       ix86_expand_sse_movcc (operands[0], tmp, operands[2], operands[3]);
19364       return true;
19365     }
19366
19367   /* The floating point conditional move instructions don't directly
19368      support conditions resulting from a signed integer comparison.  */
19369
19370   compare_op = ix86_expand_compare (code, op0, op1);
19371   if (!fcmov_comparison_operator (compare_op, VOIDmode))
19372     {
19373       tmp = gen_reg_rtx (QImode);
19374       ix86_expand_setcc (tmp, code, op0, op1);
19375
19376       compare_op = ix86_expand_compare (NE, tmp, const0_rtx);
19377     }
19378
19379   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
19380                           gen_rtx_IF_THEN_ELSE (mode, compare_op,
19381                                                 operands[2], operands[3])));
19382
19383   return true;
19384 }
19385
19386 /* Expand a floating-point vector conditional move; a vcond operation
19387    rather than a movcc operation.  */
19388
19389 bool
19390 ix86_expand_fp_vcond (rtx operands[])
19391 {
19392   enum rtx_code code = GET_CODE (operands[3]);
19393   rtx cmp;
19394
19395   code = ix86_prepare_sse_fp_compare_args (operands[0], code,
19396                                            &operands[4], &operands[5]);
19397   if (code == UNKNOWN)
19398     {
19399       rtx temp;
19400       switch (GET_CODE (operands[3]))
19401         {
19402         case LTGT:
19403           temp = ix86_expand_sse_cmp (operands[0], ORDERED, operands[4],
19404                                       operands[5], operands[0], operands[0]);
19405           cmp = ix86_expand_sse_cmp (operands[0], NE, operands[4],
19406                                      operands[5], operands[1], operands[2]);
19407           code = AND;
19408           break;
19409         case UNEQ:
19410           temp = ix86_expand_sse_cmp (operands[0], UNORDERED, operands[4],
19411                                       operands[5], operands[0], operands[0]);
19412           cmp = ix86_expand_sse_cmp (operands[0], EQ, operands[4],
19413                                      operands[5], operands[1], operands[2]);
19414           code = IOR;
19415           break;
19416         default:
19417           gcc_unreachable ();
19418         }
19419       cmp = expand_simple_binop (GET_MODE (cmp), code, temp, cmp, cmp, 1,
19420                                  OPTAB_DIRECT);
19421       ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
19422       return true;
19423     }
19424
19425   if (ix86_expand_sse_fp_minmax (operands[0], code, operands[4],
19426                                  operands[5], operands[1], operands[2]))
19427     return true;
19428
19429   cmp = ix86_expand_sse_cmp (operands[0], code, operands[4], operands[5],
19430                              operands[1], operands[2]);
19431   ix86_expand_sse_movcc (operands[0], cmp, operands[1], operands[2]);
19432   return true;
19433 }
19434
19435 /* Expand a signed/unsigned integral vector conditional move.  */
19436
19437 bool
19438 ix86_expand_int_vcond (rtx operands[])
19439 {
19440   enum machine_mode data_mode = GET_MODE (operands[0]);
19441   enum machine_mode mode = GET_MODE (operands[4]);
19442   enum rtx_code code = GET_CODE (operands[3]);
19443   bool negate = false;
19444   rtx x, cop0, cop1;
19445
19446   cop0 = operands[4];
19447   cop1 = operands[5];
19448
19449   /* Try to optimize x < 0 ? -1 : 0 into (signed) x >> 31
19450      and x < 0 ? 1 : 0 into (unsigned) x >> 31.  */
19451   if ((code == LT || code == GE)
19452       && data_mode == mode
19453       && cop1 == CONST0_RTX (mode)
19454       && operands[1 + (code == LT)] == CONST0_RTX (data_mode)
19455       && GET_MODE_SIZE (GET_MODE_INNER (data_mode)) > 1
19456       && GET_MODE_SIZE (GET_MODE_INNER (data_mode)) <= 8
19457       && (GET_MODE_SIZE (data_mode) == 16
19458           || (TARGET_AVX2 && GET_MODE_SIZE (data_mode) == 32)))
19459     {
19460       rtx negop = operands[2 - (code == LT)];
19461       int shift = GET_MODE_BITSIZE (GET_MODE_INNER (data_mode)) - 1;
19462       if (negop == CONST1_RTX (data_mode))
19463         {
19464           rtx res = expand_simple_binop (mode, LSHIFTRT, cop0, GEN_INT (shift),
19465                                          operands[0], 1, OPTAB_DIRECT);
19466           if (res != operands[0])
19467             emit_move_insn (operands[0], res);
19468           return true;
19469         }
19470       else if (GET_MODE_INNER (data_mode) != DImode
19471                && vector_all_ones_operand (negop, data_mode))
19472         {
19473           rtx res = expand_simple_binop (mode, ASHIFTRT, cop0, GEN_INT (shift),
19474                                          operands[0], 0, OPTAB_DIRECT);
19475           if (res != operands[0])
19476             emit_move_insn (operands[0], res);
19477           return true;
19478         }
19479     }
19480
19481   if (!nonimmediate_operand (cop1, mode))
19482     cop1 = force_reg (mode, cop1);
19483   if (!general_operand (operands[1], data_mode))
19484     operands[1] = force_reg (data_mode, operands[1]);
19485   if (!general_operand (operands[2], data_mode))
19486     operands[2] = force_reg (data_mode, operands[2]);
19487
19488   /* XOP supports all of the comparisons on all 128-bit vector int types.  */
19489   if (TARGET_XOP
19490       && (mode == V16QImode || mode == V8HImode
19491           || mode == V4SImode || mode == V2DImode))
19492     ;
19493   else
19494     {
19495       /* Canonicalize the comparison to EQ, GT, GTU.  */
19496       switch (code)
19497         {
19498         case EQ:
19499         case GT:
19500         case GTU:
19501           break;
19502
19503         case NE:
19504         case LE:
19505         case LEU:
19506           code = reverse_condition (code);
19507           negate = true;
19508           break;
19509
19510         case GE:
19511         case GEU:
19512           code = reverse_condition (code);
19513           negate = true;
19514           /* FALLTHRU */
19515
19516         case LT:
19517         case LTU:
19518           code = swap_condition (code);
19519           x = cop0, cop0 = cop1, cop1 = x;
19520           break;
19521
19522         default:
19523           gcc_unreachable ();
19524         }
19525
19526       /* Only SSE4.1/SSE4.2 supports V2DImode.  */
19527       if (mode == V2DImode)
19528         {
19529           switch (code)
19530             {
19531             case EQ:
19532               /* SSE4.1 supports EQ.  */
19533               if (!TARGET_SSE4_1)
19534                 return false;
19535               break;
19536
19537             case GT:
19538             case GTU:
19539               /* SSE4.2 supports GT/GTU.  */
19540               if (!TARGET_SSE4_2)
19541                 return false;
19542               break;
19543
19544             default:
19545               gcc_unreachable ();
19546             }
19547         }
19548
19549       /* Unsigned parallel compare is not supported by the hardware.
19550          Play some tricks to turn this into a signed comparison
19551          against 0.  */
19552       if (code == GTU)
19553         {
19554           cop0 = force_reg (mode, cop0);
19555
19556           switch (mode)
19557             {
19558             case V8SImode:
19559             case V4DImode:
19560             case V4SImode:
19561             case V2DImode:
19562                 {
19563                   rtx t1, t2, mask;
19564                   rtx (*gen_sub3) (rtx, rtx, rtx);
19565
19566                   switch (mode)
19567                     {
19568                     case V8SImode: gen_sub3 = gen_subv8si3; break;
19569                     case V4DImode: gen_sub3 = gen_subv4di3; break;
19570                     case V4SImode: gen_sub3 = gen_subv4si3; break;
19571                     case V2DImode: gen_sub3 = gen_subv2di3; break;
19572                     default:
19573                       gcc_unreachable ();
19574                     }
19575                   /* Subtract (-(INT MAX) - 1) from both operands to make
19576                      them signed.  */
19577                   mask = ix86_build_signbit_mask (mode, true, false);
19578                   t1 = gen_reg_rtx (mode);
19579                   emit_insn (gen_sub3 (t1, cop0, mask));
19580
19581                   t2 = gen_reg_rtx (mode);
19582                   emit_insn (gen_sub3 (t2, cop1, mask));
19583
19584                   cop0 = t1;
19585                   cop1 = t2;
19586                   code = GT;
19587                 }
19588               break;
19589
19590             case V32QImode:
19591             case V16HImode:
19592             case V16QImode:
19593             case V8HImode:
19594               /* Perform a parallel unsigned saturating subtraction.  */
19595               x = gen_reg_rtx (mode);
19596               emit_insn (gen_rtx_SET (VOIDmode, x,
19597                                       gen_rtx_US_MINUS (mode, cop0, cop1)));
19598
19599               cop0 = x;
19600               cop1 = CONST0_RTX (mode);
19601               code = EQ;
19602               negate = !negate;
19603               break;
19604
19605             default:
19606               gcc_unreachable ();
19607             }
19608         }
19609     }
19610
19611   /* Allow the comparison to be done in one mode, but the movcc to
19612      happen in another mode.  */
19613   if (data_mode == mode)
19614     {
19615       x = ix86_expand_sse_cmp (operands[0], code, cop0, cop1,
19616                                operands[1+negate], operands[2-negate]);
19617     }
19618   else
19619     {
19620       gcc_assert (GET_MODE_SIZE (data_mode) == GET_MODE_SIZE (mode));
19621       x = ix86_expand_sse_cmp (gen_lowpart (mode, operands[0]),
19622                                code, cop0, cop1,
19623                                operands[1+negate], operands[2-negate]);
19624       x = gen_lowpart (data_mode, x);
19625     }
19626
19627   ix86_expand_sse_movcc (operands[0], x, operands[1+negate],
19628                          operands[2-negate]);
19629   return true;
19630 }
19631
19632 /* Expand a variable vector permutation.  */
19633
19634 void
19635 ix86_expand_vec_perm (rtx operands[])
19636 {
19637   rtx target = operands[0];
19638   rtx op0 = operands[1];
19639   rtx op1 = operands[2];
19640   rtx mask = operands[3];
19641   rtx t1, t2, t3, t4, vt, vt2, vec[32];
19642   enum machine_mode mode = GET_MODE (op0);
19643   enum machine_mode maskmode = GET_MODE (mask);
19644   int w, e, i;
19645   bool one_operand_shuffle = rtx_equal_p (op0, op1);
19646
19647   /* Number of elements in the vector.  */
19648   w = GET_MODE_NUNITS (mode);
19649   e = GET_MODE_UNIT_SIZE (mode);
19650   gcc_assert (w <= 32);
19651
19652   if (TARGET_AVX2)
19653     {
19654       if (mode == V4DImode || mode == V4DFmode || mode == V16HImode)
19655         {
19656           /* Unfortunately, the VPERMQ and VPERMPD instructions only support
19657              an constant shuffle operand.  With a tiny bit of effort we can
19658              use VPERMD instead.  A re-interpretation stall for V4DFmode is
19659              unfortunate but there's no avoiding it.
19660              Similarly for V16HImode we don't have instructions for variable
19661              shuffling, while for V32QImode we can use after preparing suitable
19662              masks vpshufb; vpshufb; vpermq; vpor.  */
19663
19664           if (mode == V16HImode)
19665             {
19666               maskmode = mode = V32QImode;
19667               w = 32;
19668               e = 1;
19669             }
19670           else
19671             {
19672               maskmode = mode = V8SImode;
19673               w = 8;
19674               e = 4;
19675             }
19676           t1 = gen_reg_rtx (maskmode);
19677
19678           /* Replicate the low bits of the V4DImode mask into V8SImode:
19679                mask = { A B C D }
19680                t1 = { A A B B C C D D }.  */
19681           for (i = 0; i < w / 2; ++i)
19682             vec[i*2 + 1] = vec[i*2] = GEN_INT (i * 2);
19683           vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19684           vt = force_reg (maskmode, vt);
19685           mask = gen_lowpart (maskmode, mask);
19686           if (maskmode == V8SImode)
19687             emit_insn (gen_avx2_permvarv8si (t1, vt, mask));
19688           else
19689             emit_insn (gen_avx2_pshufbv32qi3 (t1, mask, vt));
19690
19691           /* Multiply the shuffle indicies by two.  */
19692           t1 = expand_simple_binop (maskmode, PLUS, t1, t1, t1, 1,
19693                                     OPTAB_DIRECT);
19694
19695           /* Add one to the odd shuffle indicies:
19696                 t1 = { A*2, A*2+1, B*2, B*2+1, ... }.  */
19697           for (i = 0; i < w / 2; ++i)
19698             {
19699               vec[i * 2] = const0_rtx;
19700               vec[i * 2 + 1] = const1_rtx;
19701             }
19702           vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19703           vt = force_const_mem (maskmode, vt);
19704           t1 = expand_simple_binop (maskmode, PLUS, t1, vt, t1, 1,
19705                                     OPTAB_DIRECT);
19706
19707           /* Continue as if V8SImode (resp. V32QImode) was used initially.  */
19708           operands[3] = mask = t1;
19709           target = gen_lowpart (mode, target);
19710           op0 = gen_lowpart (mode, op0);
19711           op1 = gen_lowpart (mode, op1);
19712         }
19713
19714       switch (mode)
19715         {
19716         case V8SImode:
19717           /* The VPERMD and VPERMPS instructions already properly ignore
19718              the high bits of the shuffle elements.  No need for us to
19719              perform an AND ourselves.  */
19720           if (one_operand_shuffle)
19721             emit_insn (gen_avx2_permvarv8si (target, mask, op0));
19722           else
19723             {
19724               t1 = gen_reg_rtx (V8SImode);
19725               t2 = gen_reg_rtx (V8SImode);
19726               emit_insn (gen_avx2_permvarv8si (t1, mask, op0));
19727               emit_insn (gen_avx2_permvarv8si (t2, mask, op1));
19728               goto merge_two;
19729             }
19730           return;
19731
19732         case V8SFmode:
19733           mask = gen_lowpart (V8SFmode, mask);
19734           if (one_operand_shuffle)
19735             emit_insn (gen_avx2_permvarv8sf (target, mask, op0));
19736           else
19737             {
19738               t1 = gen_reg_rtx (V8SFmode);
19739               t2 = gen_reg_rtx (V8SFmode);
19740               emit_insn (gen_avx2_permvarv8sf (t1, mask, op0));
19741               emit_insn (gen_avx2_permvarv8sf (t2, mask, op1));
19742               goto merge_two;
19743             }
19744           return;
19745
19746         case V4SImode:
19747           /* By combining the two 128-bit input vectors into one 256-bit
19748              input vector, we can use VPERMD and VPERMPS for the full
19749              two-operand shuffle.  */
19750           t1 = gen_reg_rtx (V8SImode);
19751           t2 = gen_reg_rtx (V8SImode);
19752           emit_insn (gen_avx_vec_concatv8si (t1, op0, op1));
19753           emit_insn (gen_avx_vec_concatv8si (t2, mask, mask));
19754           emit_insn (gen_avx2_permvarv8si (t1, t2, t1));
19755           emit_insn (gen_avx_vextractf128v8si (target, t1, const0_rtx));
19756           return;
19757
19758         case V4SFmode:
19759           t1 = gen_reg_rtx (V8SFmode);
19760           t2 = gen_reg_rtx (V8SFmode);
19761           mask = gen_lowpart (V4SFmode, mask);
19762           emit_insn (gen_avx_vec_concatv8sf (t1, op0, op1));
19763           emit_insn (gen_avx_vec_concatv8sf (t2, mask, mask));
19764           emit_insn (gen_avx2_permvarv8sf (t1, t2, t1));
19765           emit_insn (gen_avx_vextractf128v8sf (target, t1, const0_rtx));
19766           return;
19767
19768         case V32QImode:
19769           t1 = gen_reg_rtx (V32QImode);
19770           t2 = gen_reg_rtx (V32QImode);
19771           t3 = gen_reg_rtx (V32QImode);
19772           vt2 = GEN_INT (128);
19773           for (i = 0; i < 32; i++)
19774             vec[i] = vt2;
19775           vt = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, vec));
19776           vt = force_reg (V32QImode, vt);
19777           for (i = 0; i < 32; i++)
19778             vec[i] = i < 16 ? vt2 : const0_rtx;
19779           vt2 = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, vec));
19780           vt2 = force_reg (V32QImode, vt2);
19781           /* From mask create two adjusted masks, which contain the same
19782              bits as mask in the low 7 bits of each vector element.
19783              The first mask will have the most significant bit clear
19784              if it requests element from the same 128-bit lane
19785              and MSB set if it requests element from the other 128-bit lane.
19786              The second mask will have the opposite values of the MSB,
19787              and additionally will have its 128-bit lanes swapped.
19788              E.g. { 07 12 1e 09 ... | 17 19 05 1f ... } mask vector will have
19789              t1   { 07 92 9e 09 ... | 17 19 85 1f ... } and
19790              t3   { 97 99 05 9f ... | 87 12 1e 89 ... } where each ...
19791              stands for other 12 bytes.  */
19792           /* The bit whether element is from the same lane or the other
19793              lane is bit 4, so shift it up by 3 to the MSB position.  */
19794           emit_insn (gen_ashlv4di3 (gen_lowpart (V4DImode, t1),
19795                                     gen_lowpart (V4DImode, mask),
19796                                     GEN_INT (3)));
19797           /* Clear MSB bits from the mask just in case it had them set.  */
19798           emit_insn (gen_avx2_andnotv32qi3 (t2, vt, mask));
19799           /* After this t1 will have MSB set for elements from other lane.  */
19800           emit_insn (gen_xorv32qi3 (t1, t1, vt2));
19801           /* Clear bits other than MSB.  */
19802           emit_insn (gen_andv32qi3 (t1, t1, vt));
19803           /* Or in the lower bits from mask into t3.  */
19804           emit_insn (gen_iorv32qi3 (t3, t1, t2));
19805           /* And invert MSB bits in t1, so MSB is set for elements from the same
19806              lane.  */
19807           emit_insn (gen_xorv32qi3 (t1, t1, vt));
19808           /* Swap 128-bit lanes in t3.  */
19809           emit_insn (gen_avx2_permv4di_1 (gen_lowpart (V4DImode, t3),
19810                                           gen_lowpart (V4DImode, t3),
19811                                           const2_rtx, GEN_INT (3),
19812                                           const0_rtx, const1_rtx));
19813           /* And or in the lower bits from mask into t1.  */
19814           emit_insn (gen_iorv32qi3 (t1, t1, t2));
19815           if (one_operand_shuffle)
19816             {
19817               /* Each of these shuffles will put 0s in places where
19818                  element from the other 128-bit lane is needed, otherwise
19819                  will shuffle in the requested value.  */
19820               emit_insn (gen_avx2_pshufbv32qi3 (t3, op0, t3));
19821               emit_insn (gen_avx2_pshufbv32qi3 (t1, op0, t1));
19822               /* For t3 the 128-bit lanes are swapped again.  */
19823               emit_insn (gen_avx2_permv4di_1 (gen_lowpart (V4DImode, t3),
19824                                               gen_lowpart (V4DImode, t3),
19825                                               const2_rtx, GEN_INT (3),
19826                                               const0_rtx, const1_rtx));
19827               /* And oring both together leads to the result.  */
19828               emit_insn (gen_iorv32qi3 (target, t1, t3));
19829               return;
19830             }
19831
19832           t4 = gen_reg_rtx (V32QImode);
19833           /* Similarly to the above one_operand_shuffle code,
19834              just for repeated twice for each operand.  merge_two:
19835              code will merge the two results together.  */
19836           emit_insn (gen_avx2_pshufbv32qi3 (t4, op0, t3));
19837           emit_insn (gen_avx2_pshufbv32qi3 (t3, op1, t3));
19838           emit_insn (gen_avx2_pshufbv32qi3 (t2, op0, t1));
19839           emit_insn (gen_avx2_pshufbv32qi3 (t1, op1, t1));
19840           emit_insn (gen_avx2_permv4di_1 (gen_lowpart (V4DImode, t4),
19841                                           gen_lowpart (V4DImode, t4),
19842                                           const2_rtx, GEN_INT (3),
19843                                           const0_rtx, const1_rtx));
19844           emit_insn (gen_avx2_permv4di_1 (gen_lowpart (V4DImode, t3),
19845                                           gen_lowpart (V4DImode, t3),
19846                                           const2_rtx, GEN_INT (3),
19847                                           const0_rtx, const1_rtx));
19848           emit_insn (gen_iorv32qi3 (t4, t2, t4));
19849           emit_insn (gen_iorv32qi3 (t3, t1, t3));
19850           t1 = t4;
19851           t2 = t3;
19852           goto merge_two;
19853
19854         default:
19855           gcc_assert (GET_MODE_SIZE (mode) <= 16);
19856           break;
19857         }
19858     }
19859
19860   if (TARGET_XOP)
19861     {
19862       /* The XOP VPPERM insn supports three inputs.  By ignoring the
19863          one_operand_shuffle special case, we avoid creating another
19864          set of constant vectors in memory.  */
19865       one_operand_shuffle = false;
19866
19867       /* mask = mask & {2*w-1, ...} */
19868       vt = GEN_INT (2*w - 1);
19869     }
19870   else
19871     {
19872       /* mask = mask & {w-1, ...} */
19873       vt = GEN_INT (w - 1);
19874     }
19875
19876   for (i = 0; i < w; i++)
19877     vec[i] = vt;
19878   vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19879   mask = expand_simple_binop (maskmode, AND, mask, vt,
19880                               NULL_RTX, 0, OPTAB_DIRECT);
19881
19882   /* For non-QImode operations, convert the word permutation control
19883      into a byte permutation control.  */
19884   if (mode != V16QImode)
19885     {
19886       mask = expand_simple_binop (maskmode, ASHIFT, mask,
19887                                   GEN_INT (exact_log2 (e)),
19888                                   NULL_RTX, 0, OPTAB_DIRECT);
19889
19890       /* Convert mask to vector of chars.  */
19891       mask = force_reg (V16QImode, gen_lowpart (V16QImode, mask));
19892
19893       /* Replicate each of the input bytes into byte positions:
19894          (v2di) --> {0,0,0,0,0,0,0,0, 8,8,8,8,8,8,8,8}
19895          (v4si) --> {0,0,0,0, 4,4,4,4, 8,8,8,8, 12,12,12,12}
19896          (v8hi) --> {0,0, 2,2, 4,4, 6,6, ...}.  */
19897       for (i = 0; i < 16; ++i)
19898         vec[i] = GEN_INT (i/e * e);
19899       vt = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, vec));
19900       vt = force_const_mem (V16QImode, vt);
19901       if (TARGET_XOP)
19902         emit_insn (gen_xop_pperm (mask, mask, mask, vt));
19903       else
19904         emit_insn (gen_ssse3_pshufbv16qi3 (mask, mask, vt));
19905
19906       /* Convert it into the byte positions by doing
19907          mask = mask + {0,1,..,16/w, 0,1,..,16/w, ...}  */
19908       for (i = 0; i < 16; ++i)
19909         vec[i] = GEN_INT (i % e);
19910       vt = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, vec));
19911       vt = force_const_mem (V16QImode, vt);
19912       emit_insn (gen_addv16qi3 (mask, mask, vt));
19913     }
19914
19915   /* The actual shuffle operations all operate on V16QImode.  */
19916   op0 = gen_lowpart (V16QImode, op0);
19917   op1 = gen_lowpart (V16QImode, op1);
19918   target = gen_lowpart (V16QImode, target);
19919
19920   if (TARGET_XOP)
19921     {
19922       emit_insn (gen_xop_pperm (target, op0, op1, mask));
19923     }
19924   else if (one_operand_shuffle)
19925     {
19926       emit_insn (gen_ssse3_pshufbv16qi3 (target, op0, mask));
19927     }
19928   else
19929     {
19930       rtx xops[6];
19931       bool ok;
19932
19933       /* Shuffle the two input vectors independently.  */
19934       t1 = gen_reg_rtx (V16QImode);
19935       t2 = gen_reg_rtx (V16QImode);
19936       emit_insn (gen_ssse3_pshufbv16qi3 (t1, op0, mask));
19937       emit_insn (gen_ssse3_pshufbv16qi3 (t2, op1, mask));
19938
19939  merge_two:
19940       /* Then merge them together.  The key is whether any given control
19941          element contained a bit set that indicates the second word.  */
19942       mask = operands[3];
19943       vt = GEN_INT (w);
19944       if (maskmode == V2DImode && !TARGET_SSE4_1)
19945         {
19946           /* Without SSE4.1, we don't have V2DImode EQ.  Perform one
19947              more shuffle to convert the V2DI input mask into a V4SI
19948              input mask.  At which point the masking that expand_int_vcond
19949              will work as desired.  */
19950           rtx t3 = gen_reg_rtx (V4SImode);
19951           emit_insn (gen_sse2_pshufd_1 (t3, gen_lowpart (V4SImode, mask),
19952                                         const0_rtx, const0_rtx,
19953                                         const2_rtx, const2_rtx));
19954           mask = t3;
19955           maskmode = V4SImode;
19956           e = w = 4;
19957         }
19958
19959       for (i = 0; i < w; i++)
19960         vec[i] = vt;
19961       vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec));
19962       vt = force_reg (maskmode, vt);
19963       mask = expand_simple_binop (maskmode, AND, mask, vt,
19964                                   NULL_RTX, 0, OPTAB_DIRECT);
19965
19966       xops[0] = gen_lowpart (mode, operands[0]);
19967       xops[1] = gen_lowpart (mode, t2);
19968       xops[2] = gen_lowpart (mode, t1);
19969       xops[3] = gen_rtx_EQ (maskmode, mask, vt);
19970       xops[4] = mask;
19971       xops[5] = vt;
19972       ok = ix86_expand_int_vcond (xops);
19973       gcc_assert (ok);
19974     }
19975 }
19976
19977 /* Unpack OP[1] into the next wider integer vector type.  UNSIGNED_P is
19978    true if we should do zero extension, else sign extension.  HIGH_P is
19979    true if we want the N/2 high elements, else the low elements.  */
19980
19981 void
19982 ix86_expand_sse_unpack (rtx operands[2], bool unsigned_p, bool high_p)
19983 {
19984   enum machine_mode imode = GET_MODE (operands[1]);
19985   rtx tmp, dest;
19986
19987   if (TARGET_SSE4_1)
19988     {
19989       rtx (*unpack)(rtx, rtx);
19990       rtx (*extract)(rtx, rtx) = NULL;
19991       enum machine_mode halfmode = BLKmode;
19992
19993       switch (imode)
19994         {
19995         case V32QImode:
19996           if (unsigned_p)
19997             unpack = gen_avx2_zero_extendv16qiv16hi2;
19998           else
19999             unpack = gen_avx2_sign_extendv16qiv16hi2;
20000           halfmode = V16QImode;
20001           extract
20002             = high_p ? gen_vec_extract_hi_v32qi : gen_vec_extract_lo_v32qi;
20003           break;
20004         case V16HImode:
20005           if (unsigned_p)
20006             unpack = gen_avx2_zero_extendv8hiv8si2;
20007           else
20008             unpack = gen_avx2_sign_extendv8hiv8si2;
20009           halfmode = V8HImode;
20010           extract
20011             = high_p ? gen_vec_extract_hi_v16hi : gen_vec_extract_lo_v16hi;
20012           break;
20013         case V8SImode:
20014           if (unsigned_p)
20015             unpack = gen_avx2_zero_extendv4siv4di2;
20016           else
20017             unpack = gen_avx2_sign_extendv4siv4di2;
20018           halfmode = V4SImode;
20019           extract
20020             = high_p ? gen_vec_extract_hi_v8si : gen_vec_extract_lo_v8si;
20021           break;
20022         case V16QImode:
20023           if (unsigned_p)
20024             unpack = gen_sse4_1_zero_extendv8qiv8hi2;
20025           else
20026             unpack = gen_sse4_1_sign_extendv8qiv8hi2;
20027           break;
20028         case V8HImode:
20029           if (unsigned_p)
20030             unpack = gen_sse4_1_zero_extendv4hiv4si2;
20031           else
20032             unpack = gen_sse4_1_sign_extendv4hiv4si2;
20033           break;
20034         case V4SImode:
20035           if (unsigned_p)
20036             unpack = gen_sse4_1_zero_extendv2siv2di2;
20037           else
20038             unpack = gen_sse4_1_sign_extendv2siv2di2;
20039           break;
20040         default:
20041           gcc_unreachable ();
20042         }
20043
20044       if (GET_MODE_SIZE (imode) == 32)
20045         {
20046           tmp = gen_reg_rtx (halfmode);
20047           emit_insn (extract (tmp, operands[1]));
20048         }
20049       else if (high_p)
20050         {
20051           /* Shift higher 8 bytes to lower 8 bytes.  */
20052           tmp = gen_reg_rtx (imode);
20053           emit_insn (gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, tmp),
20054                                          gen_lowpart (V1TImode, operands[1]),
20055                                          GEN_INT (64)));
20056         }
20057       else
20058         tmp = operands[1];
20059
20060       emit_insn (unpack (operands[0], tmp));
20061     }
20062   else
20063     {
20064       rtx (*unpack)(rtx, rtx, rtx);
20065
20066       switch (imode)
20067         {
20068         case V16QImode:
20069           if (high_p)
20070             unpack = gen_vec_interleave_highv16qi;
20071           else
20072             unpack = gen_vec_interleave_lowv16qi;
20073           break;
20074         case V8HImode:
20075           if (high_p)
20076             unpack = gen_vec_interleave_highv8hi;
20077           else
20078             unpack = gen_vec_interleave_lowv8hi;
20079           break;
20080         case V4SImode:
20081           if (high_p)
20082             unpack = gen_vec_interleave_highv4si;
20083           else
20084             unpack = gen_vec_interleave_lowv4si;
20085           break;
20086         default:
20087           gcc_unreachable ();
20088         }
20089
20090       dest = gen_lowpart (imode, operands[0]);
20091
20092       if (unsigned_p)
20093         tmp = force_reg (imode, CONST0_RTX (imode));
20094       else
20095         tmp = ix86_expand_sse_cmp (gen_reg_rtx (imode), GT, CONST0_RTX (imode),
20096                                    operands[1], pc_rtx, pc_rtx);
20097
20098       emit_insn (unpack (dest, operands[1], tmp));
20099     }
20100 }
20101
20102 /* Expand conditional increment or decrement using adb/sbb instructions.
20103    The default case using setcc followed by the conditional move can be
20104    done by generic code.  */
20105 bool
20106 ix86_expand_int_addcc (rtx operands[])
20107 {
20108   enum rtx_code code = GET_CODE (operands[1]);
20109   rtx flags;
20110   rtx (*insn)(rtx, rtx, rtx, rtx, rtx);
20111   rtx compare_op;
20112   rtx val = const0_rtx;
20113   bool fpcmp = false;
20114   enum machine_mode mode;
20115   rtx op0 = XEXP (operands[1], 0);
20116   rtx op1 = XEXP (operands[1], 1);
20117
20118   if (operands[3] != const1_rtx
20119       && operands[3] != constm1_rtx)
20120     return false;
20121   if (!ix86_expand_carry_flag_compare (code, op0, op1, &compare_op))
20122      return false;
20123   code = GET_CODE (compare_op);
20124
20125   flags = XEXP (compare_op, 0);
20126
20127   if (GET_MODE (flags) == CCFPmode
20128       || GET_MODE (flags) == CCFPUmode)
20129     {
20130       fpcmp = true;
20131       code = ix86_fp_compare_code_to_integer (code);
20132     }
20133
20134   if (code != LTU)
20135     {
20136       val = constm1_rtx;
20137       if (fpcmp)
20138         PUT_CODE (compare_op,
20139                   reverse_condition_maybe_unordered
20140                     (GET_CODE (compare_op)));
20141       else
20142         PUT_CODE (compare_op, reverse_condition (GET_CODE (compare_op)));
20143     }
20144
20145   mode = GET_MODE (operands[0]);
20146
20147   /* Construct either adc or sbb insn.  */
20148   if ((code == LTU) == (operands[3] == constm1_rtx))
20149     {
20150       switch (mode)
20151         {
20152           case QImode:
20153             insn = gen_subqi3_carry;
20154             break;
20155           case HImode:
20156             insn = gen_subhi3_carry;
20157             break;
20158           case SImode:
20159             insn = gen_subsi3_carry;
20160             break;
20161           case DImode:
20162             insn = gen_subdi3_carry;
20163             break;
20164           default:
20165             gcc_unreachable ();
20166         }
20167     }
20168   else
20169     {
20170       switch (mode)
20171         {
20172           case QImode:
20173             insn = gen_addqi3_carry;
20174             break;
20175           case HImode:
20176             insn = gen_addhi3_carry;
20177             break;
20178           case SImode:
20179             insn = gen_addsi3_carry;
20180             break;
20181           case DImode:
20182             insn = gen_adddi3_carry;
20183             break;
20184           default:
20185             gcc_unreachable ();
20186         }
20187     }
20188   emit_insn (insn (operands[0], operands[2], val, flags, compare_op));
20189
20190   return true;
20191 }
20192
20193
20194 /* Split operands 0 and 1 into half-mode parts.  Similar to split_double_mode,
20195    but works for floating pointer parameters and nonoffsetable memories.
20196    For pushes, it returns just stack offsets; the values will be saved
20197    in the right order.  Maximally three parts are generated.  */
20198
20199 static int
20200 ix86_split_to_parts (rtx operand, rtx *parts, enum machine_mode mode)
20201 {
20202   int size;
20203
20204   if (!TARGET_64BIT)
20205     size = mode==XFmode ? 3 : GET_MODE_SIZE (mode) / 4;
20206   else
20207     size = (GET_MODE_SIZE (mode) + 4) / 8;
20208
20209   gcc_assert (!REG_P (operand) || !MMX_REGNO_P (REGNO (operand)));
20210   gcc_assert (size >= 2 && size <= 4);
20211
20212   /* Optimize constant pool reference to immediates.  This is used by fp
20213      moves, that force all constants to memory to allow combining.  */
20214   if (MEM_P (operand) && MEM_READONLY_P (operand))
20215     {
20216       rtx tmp = maybe_get_pool_constant (operand);
20217       if (tmp)
20218         operand = tmp;
20219     }
20220
20221   if (MEM_P (operand) && !offsettable_memref_p (operand))
20222     {
20223       /* The only non-offsetable memories we handle are pushes.  */
20224       int ok = push_operand (operand, VOIDmode);
20225
20226       gcc_assert (ok);
20227
20228       operand = copy_rtx (operand);
20229       PUT_MODE (operand, Pmode);
20230       parts[0] = parts[1] = parts[2] = parts[3] = operand;
20231       return size;
20232     }
20233
20234   if (GET_CODE (operand) == CONST_VECTOR)
20235     {
20236       enum machine_mode imode = int_mode_for_mode (mode);
20237       /* Caution: if we looked through a constant pool memory above,
20238          the operand may actually have a different mode now.  That's
20239          ok, since we want to pun this all the way back to an integer.  */
20240       operand = simplify_subreg (imode, operand, GET_MODE (operand), 0);
20241       gcc_assert (operand != NULL);
20242       mode = imode;
20243     }
20244
20245   if (!TARGET_64BIT)
20246     {
20247       if (mode == DImode)
20248         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
20249       else
20250         {
20251           int i;
20252
20253           if (REG_P (operand))
20254             {
20255               gcc_assert (reload_completed);
20256               for (i = 0; i < size; i++)
20257                 parts[i] = gen_rtx_REG (SImode, REGNO (operand) + i);
20258             }
20259           else if (offsettable_memref_p (operand))
20260             {
20261               operand = adjust_address (operand, SImode, 0);
20262               parts[0] = operand;
20263               for (i = 1; i < size; i++)
20264                 parts[i] = adjust_address (operand, SImode, 4 * i);
20265             }
20266           else if (GET_CODE (operand) == CONST_DOUBLE)
20267             {
20268               REAL_VALUE_TYPE r;
20269               long l[4];
20270
20271               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
20272               switch (mode)
20273                 {
20274                 case TFmode:
20275                   real_to_target (l, &r, mode);
20276                   parts[3] = gen_int_mode (l[3], SImode);
20277                   parts[2] = gen_int_mode (l[2], SImode);
20278                   break;
20279                 case XFmode:
20280                   REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
20281                   parts[2] = gen_int_mode (l[2], SImode);
20282                   break;
20283                 case DFmode:
20284                   REAL_VALUE_TO_TARGET_DOUBLE (r, l);
20285                   break;
20286                 default:
20287                   gcc_unreachable ();
20288                 }
20289               parts[1] = gen_int_mode (l[1], SImode);
20290               parts[0] = gen_int_mode (l[0], SImode);
20291             }
20292           else
20293             gcc_unreachable ();
20294         }
20295     }
20296   else
20297     {
20298       if (mode == TImode)
20299         split_double_mode (mode, &operand, 1, &parts[0], &parts[1]);
20300       if (mode == XFmode || mode == TFmode)
20301         {
20302           enum machine_mode upper_mode = mode==XFmode ? SImode : DImode;
20303           if (REG_P (operand))
20304             {
20305               gcc_assert (reload_completed);
20306               parts[0] = gen_rtx_REG (DImode, REGNO (operand) + 0);
20307               parts[1] = gen_rtx_REG (upper_mode, REGNO (operand) + 1);
20308             }
20309           else if (offsettable_memref_p (operand))
20310             {
20311               operand = adjust_address (operand, DImode, 0);
20312               parts[0] = operand;
20313               parts[1] = adjust_address (operand, upper_mode, 8);
20314             }
20315           else if (GET_CODE (operand) == CONST_DOUBLE)
20316             {
20317               REAL_VALUE_TYPE r;
20318               long l[4];
20319
20320               REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
20321               real_to_target (l, &r, mode);
20322
20323               /* Do not use shift by 32 to avoid warning on 32bit systems.  */
20324               if (HOST_BITS_PER_WIDE_INT >= 64)
20325                 parts[0]
20326                   = gen_int_mode
20327                       ((l[0] & (((HOST_WIDE_INT) 2 << 31) - 1))
20328                        + ((((HOST_WIDE_INT) l[1]) << 31) << 1),
20329                        DImode);
20330               else
20331                 parts[0] = immed_double_const (l[0], l[1], DImode);
20332
20333               if (upper_mode == SImode)
20334                 parts[1] = gen_int_mode (l[2], SImode);
20335               else if (HOST_BITS_PER_WIDE_INT >= 64)
20336                 parts[1]
20337                   = gen_int_mode
20338                       ((l[2] & (((HOST_WIDE_INT) 2 << 31) - 1))
20339                        + ((((HOST_WIDE_INT) l[3]) << 31) << 1),
20340                        DImode);
20341               else
20342                 parts[1] = immed_double_const (l[2], l[3], DImode);
20343             }
20344           else
20345             gcc_unreachable ();
20346         }
20347     }
20348
20349   return size;
20350 }
20351
20352 /* Emit insns to perform a move or push of DI, DF, XF, and TF values.
20353    Return false when normal moves are needed; true when all required
20354    insns have been emitted.  Operands 2-4 contain the input values
20355    int the correct order; operands 5-7 contain the output values.  */
20356
20357 void
20358 ix86_split_long_move (rtx operands[])
20359 {
20360   rtx part[2][4];
20361   int nparts, i, j;
20362   int push = 0;
20363   int collisions = 0;
20364   enum machine_mode mode = GET_MODE (operands[0]);
20365   bool collisionparts[4];
20366
20367   /* The DFmode expanders may ask us to move double.
20368      For 64bit target this is single move.  By hiding the fact
20369      here we simplify i386.md splitters.  */
20370   if (TARGET_64BIT && GET_MODE_SIZE (GET_MODE (operands[0])) == 8)
20371     {
20372       /* Optimize constant pool reference to immediates.  This is used by
20373          fp moves, that force all constants to memory to allow combining.  */
20374
20375       if (MEM_P (operands[1])
20376           && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
20377           && CONSTANT_POOL_ADDRESS_P (XEXP (operands[1], 0)))
20378         operands[1] = get_pool_constant (XEXP (operands[1], 0));
20379       if (push_operand (operands[0], VOIDmode))
20380         {
20381           operands[0] = copy_rtx (operands[0]);
20382           PUT_MODE (operands[0], Pmode);
20383         }
20384       else
20385         operands[0] = gen_lowpart (DImode, operands[0]);
20386       operands[1] = gen_lowpart (DImode, operands[1]);
20387       emit_move_insn (operands[0], operands[1]);
20388       return;
20389     }
20390
20391   /* The only non-offsettable memory we handle is push.  */
20392   if (push_operand (operands[0], VOIDmode))
20393     push = 1;
20394   else
20395     gcc_assert (!MEM_P (operands[0])
20396                 || offsettable_memref_p (operands[0]));
20397
20398   nparts = ix86_split_to_parts (operands[1], part[1], GET_MODE (operands[0]));
20399   ix86_split_to_parts (operands[0], part[0], GET_MODE (operands[0]));
20400
20401   /* When emitting push, take care for source operands on the stack.  */
20402   if (push && MEM_P (operands[1])
20403       && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
20404     {
20405       rtx src_base = XEXP (part[1][nparts - 1], 0);
20406
20407       /* Compensate for the stack decrement by 4.  */
20408       if (!TARGET_64BIT && nparts == 3
20409           && mode == XFmode && TARGET_128BIT_LONG_DOUBLE)
20410         src_base = plus_constant (src_base, 4);
20411
20412       /* src_base refers to the stack pointer and is
20413          automatically decreased by emitted push.  */
20414       for (i = 0; i < nparts; i++)
20415         part[1][i] = change_address (part[1][i],
20416                                      GET_MODE (part[1][i]), src_base);
20417     }
20418
20419   /* We need to do copy in the right order in case an address register
20420      of the source overlaps the destination.  */
20421   if (REG_P (part[0][0]) && MEM_P (part[1][0]))
20422     {
20423       rtx tmp;
20424
20425       for (i = 0; i < nparts; i++)
20426         {
20427           collisionparts[i]
20428             = reg_overlap_mentioned_p (part[0][i], XEXP (part[1][0], 0));
20429           if (collisionparts[i])
20430             collisions++;
20431         }
20432
20433       /* Collision in the middle part can be handled by reordering.  */
20434       if (collisions == 1 && nparts == 3 && collisionparts [1])
20435         {
20436           tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
20437           tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
20438         }
20439       else if (collisions == 1
20440                && nparts == 4
20441                && (collisionparts [1] || collisionparts [2]))
20442         {
20443           if (collisionparts [1])
20444             {
20445               tmp = part[0][1]; part[0][1] = part[0][2]; part[0][2] = tmp;
20446               tmp = part[1][1]; part[1][1] = part[1][2]; part[1][2] = tmp;
20447             }
20448           else
20449             {
20450               tmp = part[0][2]; part[0][2] = part[0][3]; part[0][3] = tmp;
20451               tmp = part[1][2]; part[1][2] = part[1][3]; part[1][3] = tmp;
20452             }
20453         }
20454
20455       /* If there are more collisions, we can't handle it by reordering.
20456          Do an lea to the last part and use only one colliding move.  */
20457       else if (collisions > 1)
20458         {
20459           rtx base;
20460
20461           collisions = 1;
20462
20463           base = part[0][nparts - 1];
20464
20465           /* Handle the case when the last part isn't valid for lea.
20466              Happens in 64-bit mode storing the 12-byte XFmode.  */
20467           if (GET_MODE (base) != Pmode)
20468             base = gen_rtx_REG (Pmode, REGNO (base));
20469
20470           emit_insn (gen_rtx_SET (VOIDmode, base, XEXP (part[1][0], 0)));
20471           part[1][0] = replace_equiv_address (part[1][0], base);
20472           for (i = 1; i < nparts; i++)
20473             {
20474               tmp = plus_constant (base, UNITS_PER_WORD * i);
20475               part[1][i] = replace_equiv_address (part[1][i], tmp);
20476             }
20477         }
20478     }
20479
20480   if (push)
20481     {
20482       if (!TARGET_64BIT)
20483         {
20484           if (nparts == 3)
20485             {
20486               if (TARGET_128BIT_LONG_DOUBLE && mode == XFmode)
20487                 emit_insn (gen_addsi3 (stack_pointer_rtx,
20488                                        stack_pointer_rtx, GEN_INT (-4)));
20489               emit_move_insn (part[0][2], part[1][2]);
20490             }
20491           else if (nparts == 4)
20492             {
20493               emit_move_insn (part[0][3], part[1][3]);
20494               emit_move_insn (part[0][2], part[1][2]);
20495             }
20496         }
20497       else
20498         {
20499           /* In 64bit mode we don't have 32bit push available.  In case this is
20500              register, it is OK - we will just use larger counterpart.  We also
20501              retype memory - these comes from attempt to avoid REX prefix on
20502              moving of second half of TFmode value.  */
20503           if (GET_MODE (part[1][1]) == SImode)
20504             {
20505               switch (GET_CODE (part[1][1]))
20506                 {
20507                 case MEM:
20508                   part[1][1] = adjust_address (part[1][1], DImode, 0);
20509                   break;
20510
20511                 case REG:
20512                   part[1][1] = gen_rtx_REG (DImode, REGNO (part[1][1]));
20513                   break;
20514
20515                 default:
20516                   gcc_unreachable ();
20517                 }
20518
20519               if (GET_MODE (part[1][0]) == SImode)
20520                 part[1][0] = part[1][1];
20521             }
20522         }
20523       emit_move_insn (part[0][1], part[1][1]);
20524       emit_move_insn (part[0][0], part[1][0]);
20525       return;
20526     }
20527
20528   /* Choose correct order to not overwrite the source before it is copied.  */
20529   if ((REG_P (part[0][0])
20530        && REG_P (part[1][1])
20531        && (REGNO (part[0][0]) == REGNO (part[1][1])
20532            || (nparts == 3
20533                && REGNO (part[0][0]) == REGNO (part[1][2]))
20534            || (nparts == 4
20535                && REGNO (part[0][0]) == REGNO (part[1][3]))))
20536       || (collisions > 0
20537           && reg_overlap_mentioned_p (part[0][0], XEXP (part[1][0], 0))))
20538     {
20539       for (i = 0, j = nparts - 1; i < nparts; i++, j--)
20540         {
20541           operands[2 + i] = part[0][j];
20542           operands[6 + i] = part[1][j];
20543         }
20544     }
20545   else
20546     {
20547       for (i = 0; i < nparts; i++)
20548         {
20549           operands[2 + i] = part[0][i];
20550           operands[6 + i] = part[1][i];
20551         }
20552     }
20553
20554   /* If optimizing for size, attempt to locally unCSE nonzero constants.  */
20555   if (optimize_insn_for_size_p ())
20556     {
20557       for (j = 0; j < nparts - 1; j++)
20558         if (CONST_INT_P (operands[6 + j])
20559             && operands[6 + j] != const0_rtx
20560             && REG_P (operands[2 + j]))
20561           for (i = j; i < nparts - 1; i++)
20562             if (CONST_INT_P (operands[7 + i])
20563                 && INTVAL (operands[7 + i]) == INTVAL (operands[6 + j]))
20564               operands[7 + i] = operands[2 + j];
20565     }
20566
20567   for (i = 0; i < nparts; i++)
20568     emit_move_insn (operands[2 + i], operands[6 + i]);
20569
20570   return;
20571 }
20572
20573 /* Helper function of ix86_split_ashl used to generate an SImode/DImode
20574    left shift by a constant, either using a single shift or
20575    a sequence of add instructions.  */
20576
20577 static void
20578 ix86_expand_ashl_const (rtx operand, int count, enum machine_mode mode)
20579 {
20580   rtx (*insn)(rtx, rtx, rtx);
20581
20582   if (count == 1
20583       || (count * ix86_cost->add <= ix86_cost->shift_const
20584           && !optimize_insn_for_size_p ()))
20585     {
20586       insn = mode == DImode ? gen_addsi3 : gen_adddi3;
20587       while (count-- > 0)
20588         emit_insn (insn (operand, operand, operand));
20589     }
20590   else
20591     {
20592       insn = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
20593       emit_insn (insn (operand, operand, GEN_INT (count)));
20594     }
20595 }
20596
20597 void
20598 ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode)
20599 {
20600   rtx (*gen_ashl3)(rtx, rtx, rtx);
20601   rtx (*gen_shld)(rtx, rtx, rtx);
20602   int half_width = GET_MODE_BITSIZE (mode) >> 1;
20603
20604   rtx low[2], high[2];
20605   int count;
20606
20607   if (CONST_INT_P (operands[2]))
20608     {
20609       split_double_mode (mode, operands, 2, low, high);
20610       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
20611
20612       if (count >= half_width)
20613         {
20614           emit_move_insn (high[0], low[1]);
20615           emit_move_insn (low[0], const0_rtx);
20616
20617           if (count > half_width)
20618             ix86_expand_ashl_const (high[0], count - half_width, mode);
20619         }
20620       else
20621         {
20622           gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
20623
20624           if (!rtx_equal_p (operands[0], operands[1]))
20625             emit_move_insn (operands[0], operands[1]);
20626
20627           emit_insn (gen_shld (high[0], low[0], GEN_INT (count)));
20628           ix86_expand_ashl_const (low[0], count, mode);
20629         }
20630       return;
20631     }
20632
20633   split_double_mode (mode, operands, 1, low, high);
20634
20635   gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3;
20636
20637   if (operands[1] == const1_rtx)
20638     {
20639       /* Assuming we've chosen a QImode capable registers, then 1 << N
20640          can be done with two 32/64-bit shifts, no branches, no cmoves.  */
20641       if (ANY_QI_REG_P (low[0]) && ANY_QI_REG_P (high[0]))
20642         {
20643           rtx s, d, flags = gen_rtx_REG (CCZmode, FLAGS_REG);
20644
20645           ix86_expand_clear (low[0]);
20646           ix86_expand_clear (high[0]);
20647           emit_insn (gen_testqi_ccz_1 (operands[2], GEN_INT (half_width)));
20648
20649           d = gen_lowpart (QImode, low[0]);
20650           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
20651           s = gen_rtx_EQ (QImode, flags, const0_rtx);
20652           emit_insn (gen_rtx_SET (VOIDmode, d, s));
20653
20654           d = gen_lowpart (QImode, high[0]);
20655           d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
20656           s = gen_rtx_NE (QImode, flags, const0_rtx);
20657           emit_insn (gen_rtx_SET (VOIDmode, d, s));
20658         }
20659
20660       /* Otherwise, we can get the same results by manually performing
20661          a bit extract operation on bit 5/6, and then performing the two
20662          shifts.  The two methods of getting 0/1 into low/high are exactly
20663          the same size.  Avoiding the shift in the bit extract case helps
20664          pentium4 a bit; no one else seems to care much either way.  */
20665       else
20666         {
20667           enum machine_mode half_mode;
20668           rtx (*gen_lshr3)(rtx, rtx, rtx);
20669           rtx (*gen_and3)(rtx, rtx, rtx);
20670           rtx (*gen_xor3)(rtx, rtx, rtx);
20671           HOST_WIDE_INT bits;
20672           rtx x;
20673
20674           if (mode == DImode)
20675             {
20676               half_mode = SImode;
20677               gen_lshr3 = gen_lshrsi3;
20678               gen_and3 = gen_andsi3;
20679               gen_xor3 = gen_xorsi3;
20680               bits = 5;
20681             }
20682           else
20683             {
20684               half_mode = DImode;
20685               gen_lshr3 = gen_lshrdi3;
20686               gen_and3 = gen_anddi3;
20687               gen_xor3 = gen_xordi3;
20688               bits = 6;
20689             }
20690
20691           if (TARGET_PARTIAL_REG_STALL && !optimize_insn_for_size_p ())
20692             x = gen_rtx_ZERO_EXTEND (half_mode, operands[2]);
20693           else
20694             x = gen_lowpart (half_mode, operands[2]);
20695           emit_insn (gen_rtx_SET (VOIDmode, high[0], x));
20696
20697           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (bits)));
20698           emit_insn (gen_and3 (high[0], high[0], const1_rtx));
20699           emit_move_insn (low[0], high[0]);
20700           emit_insn (gen_xor3 (low[0], low[0], const1_rtx));
20701         }
20702
20703       emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
20704       emit_insn (gen_ashl3 (high[0], high[0], operands[2]));
20705       return;
20706     }
20707
20708   if (operands[1] == constm1_rtx)
20709     {
20710       /* For -1 << N, we can avoid the shld instruction, because we
20711          know that we're shifting 0...31/63 ones into a -1.  */
20712       emit_move_insn (low[0], constm1_rtx);
20713       if (optimize_insn_for_size_p ())
20714         emit_move_insn (high[0], low[0]);
20715       else
20716         emit_move_insn (high[0], constm1_rtx);
20717     }
20718   else
20719     {
20720       gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld;
20721
20722       if (!rtx_equal_p (operands[0], operands[1]))
20723         emit_move_insn (operands[0], operands[1]);
20724
20725       split_double_mode (mode, operands, 1, low, high);
20726       emit_insn (gen_shld (high[0], low[0], operands[2]));
20727     }
20728
20729   emit_insn (gen_ashl3 (low[0], low[0], operands[2]));
20730
20731   if (TARGET_CMOVE && scratch)
20732     {
20733       rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20734         = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20735
20736       ix86_expand_clear (scratch);
20737       emit_insn (gen_x86_shift_adj_1 (high[0], low[0], operands[2], scratch));
20738     }
20739   else
20740     {
20741       rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
20742         = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
20743
20744       emit_insn (gen_x86_shift_adj_2 (high[0], low[0], operands[2]));
20745     }
20746 }
20747
20748 void
20749 ix86_split_ashr (rtx *operands, rtx scratch, enum machine_mode mode)
20750 {
20751   rtx (*gen_ashr3)(rtx, rtx, rtx)
20752     = mode == DImode ? gen_ashrsi3 : gen_ashrdi3;
20753   rtx (*gen_shrd)(rtx, rtx, rtx);
20754   int half_width = GET_MODE_BITSIZE (mode) >> 1;
20755
20756   rtx low[2], high[2];
20757   int count;
20758
20759   if (CONST_INT_P (operands[2]))
20760     {
20761       split_double_mode (mode, operands, 2, low, high);
20762       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
20763
20764       if (count == GET_MODE_BITSIZE (mode) - 1)
20765         {
20766           emit_move_insn (high[0], high[1]);
20767           emit_insn (gen_ashr3 (high[0], high[0],
20768                                 GEN_INT (half_width - 1)));
20769           emit_move_insn (low[0], high[0]);
20770
20771         }
20772       else if (count >= half_width)
20773         {
20774           emit_move_insn (low[0], high[1]);
20775           emit_move_insn (high[0], low[0]);
20776           emit_insn (gen_ashr3 (high[0], high[0],
20777                                 GEN_INT (half_width - 1)));
20778
20779           if (count > half_width)
20780             emit_insn (gen_ashr3 (low[0], low[0],
20781                                   GEN_INT (count - half_width)));
20782         }
20783       else
20784         {
20785           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20786
20787           if (!rtx_equal_p (operands[0], operands[1]))
20788             emit_move_insn (operands[0], operands[1]);
20789
20790           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
20791           emit_insn (gen_ashr3 (high[0], high[0], GEN_INT (count)));
20792         }
20793     }
20794   else
20795     {
20796       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20797
20798      if (!rtx_equal_p (operands[0], operands[1]))
20799         emit_move_insn (operands[0], operands[1]);
20800
20801       split_double_mode (mode, operands, 1, low, high);
20802
20803       emit_insn (gen_shrd (low[0], high[0], operands[2]));
20804       emit_insn (gen_ashr3 (high[0], high[0], operands[2]));
20805
20806       if (TARGET_CMOVE && scratch)
20807         {
20808           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20809             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20810
20811           emit_move_insn (scratch, high[0]);
20812           emit_insn (gen_ashr3 (scratch, scratch,
20813                                 GEN_INT (half_width - 1)));
20814           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
20815                                           scratch));
20816         }
20817       else
20818         {
20819           rtx (*gen_x86_shift_adj_3)(rtx, rtx, rtx)
20820             = mode == DImode ? gen_x86_shiftsi_adj_3 : gen_x86_shiftdi_adj_3;
20821
20822           emit_insn (gen_x86_shift_adj_3 (low[0], high[0], operands[2]));
20823         }
20824     }
20825 }
20826
20827 void
20828 ix86_split_lshr (rtx *operands, rtx scratch, enum machine_mode mode)
20829 {
20830   rtx (*gen_lshr3)(rtx, rtx, rtx)
20831     = mode == DImode ? gen_lshrsi3 : gen_lshrdi3;
20832   rtx (*gen_shrd)(rtx, rtx, rtx);
20833   int half_width = GET_MODE_BITSIZE (mode) >> 1;
20834
20835   rtx low[2], high[2];
20836   int count;
20837
20838   if (CONST_INT_P (operands[2]))
20839     {
20840       split_double_mode (mode, operands, 2, low, high);
20841       count = INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1);
20842
20843       if (count >= half_width)
20844         {
20845           emit_move_insn (low[0], high[1]);
20846           ix86_expand_clear (high[0]);
20847
20848           if (count > half_width)
20849             emit_insn (gen_lshr3 (low[0], low[0],
20850                                   GEN_INT (count - half_width)));
20851         }
20852       else
20853         {
20854           gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20855
20856           if (!rtx_equal_p (operands[0], operands[1]))
20857             emit_move_insn (operands[0], operands[1]);
20858
20859           emit_insn (gen_shrd (low[0], high[0], GEN_INT (count)));
20860           emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (count)));
20861         }
20862     }
20863   else
20864     {
20865       gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd;
20866
20867       if (!rtx_equal_p (operands[0], operands[1]))
20868         emit_move_insn (operands[0], operands[1]);
20869
20870       split_double_mode (mode, operands, 1, low, high);
20871
20872       emit_insn (gen_shrd (low[0], high[0], operands[2]));
20873       emit_insn (gen_lshr3 (high[0], high[0], operands[2]));
20874
20875       if (TARGET_CMOVE && scratch)
20876         {
20877           rtx (*gen_x86_shift_adj_1)(rtx, rtx, rtx, rtx)
20878             = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1;
20879
20880           ix86_expand_clear (scratch);
20881           emit_insn (gen_x86_shift_adj_1 (low[0], high[0], operands[2],
20882                                           scratch));
20883         }
20884       else
20885         {
20886           rtx (*gen_x86_shift_adj_2)(rtx, rtx, rtx)
20887             = mode == DImode ? gen_x86_shiftsi_adj_2 : gen_x86_shiftdi_adj_2;
20888
20889           emit_insn (gen_x86_shift_adj_2 (low[0], high[0], operands[2]));
20890         }
20891     }
20892 }
20893
20894 /* Predict just emitted jump instruction to be taken with probability PROB.  */
20895 static void
20896 predict_jump (int prob)
20897 {
20898   rtx insn = get_last_insn ();
20899   gcc_assert (JUMP_P (insn));
20900   add_reg_note (insn, REG_BR_PROB, GEN_INT (prob));
20901 }
20902
20903 /* Helper function for the string operations below.  Dest VARIABLE whether
20904    it is aligned to VALUE bytes.  If true, jump to the label.  */
20905 static rtx
20906 ix86_expand_aligntest (rtx variable, int value, bool epilogue)
20907 {
20908   rtx label = gen_label_rtx ();
20909   rtx tmpcount = gen_reg_rtx (GET_MODE (variable));
20910   if (GET_MODE (variable) == DImode)
20911     emit_insn (gen_anddi3 (tmpcount, variable, GEN_INT (value)));
20912   else
20913     emit_insn (gen_andsi3 (tmpcount, variable, GEN_INT (value)));
20914   emit_cmp_and_jump_insns (tmpcount, const0_rtx, EQ, 0, GET_MODE (variable),
20915                            1, label);
20916   if (epilogue)
20917     predict_jump (REG_BR_PROB_BASE * 50 / 100);
20918   else
20919     predict_jump (REG_BR_PROB_BASE * 90 / 100);
20920   return label;
20921 }
20922
20923 /* Adjust COUNTER by the VALUE.  */
20924 static void
20925 ix86_adjust_counter (rtx countreg, HOST_WIDE_INT value)
20926 {
20927   rtx (*gen_add)(rtx, rtx, rtx)
20928     = GET_MODE (countreg) == DImode ? gen_adddi3 : gen_addsi3;
20929
20930   emit_insn (gen_add (countreg, countreg, GEN_INT (-value)));
20931 }
20932
20933 /* Zero extend possibly SImode EXP to Pmode register.  */
20934 rtx
20935 ix86_zero_extend_to_Pmode (rtx exp)
20936 {
20937   rtx r;
20938   if (GET_MODE (exp) == VOIDmode)
20939     return force_reg (Pmode, exp);
20940   if (GET_MODE (exp) == Pmode)
20941     return copy_to_mode_reg (Pmode, exp);
20942   r = gen_reg_rtx (Pmode);
20943   emit_insn (gen_zero_extendsidi2 (r, exp));
20944   return r;
20945 }
20946
20947 /* Divide COUNTREG by SCALE.  */
20948 static rtx
20949 scale_counter (rtx countreg, int scale)
20950 {
20951   rtx sc;
20952
20953   if (scale == 1)
20954     return countreg;
20955   if (CONST_INT_P (countreg))
20956     return GEN_INT (INTVAL (countreg) / scale);
20957   gcc_assert (REG_P (countreg));
20958
20959   sc = expand_simple_binop (GET_MODE (countreg), LSHIFTRT, countreg,
20960                             GEN_INT (exact_log2 (scale)),
20961                             NULL, 1, OPTAB_DIRECT);
20962   return sc;
20963 }
20964
20965 /* Return mode for the memcpy/memset loop counter.  Prefer SImode over
20966    DImode for constant loop counts.  */
20967
20968 static enum machine_mode
20969 counter_mode (rtx count_exp)
20970 {
20971   if (GET_MODE (count_exp) != VOIDmode)
20972     return GET_MODE (count_exp);
20973   if (!CONST_INT_P (count_exp))
20974     return Pmode;
20975   if (TARGET_64BIT && (INTVAL (count_exp) & ~0xffffffff))
20976     return DImode;
20977   return SImode;
20978 }
20979
20980 /* When SRCPTR is non-NULL, output simple loop to move memory
20981    pointer to SRCPTR to DESTPTR via chunks of MODE unrolled UNROLL times,
20982    overall size is COUNT specified in bytes.  When SRCPTR is NULL, output the
20983    equivalent loop to set memory by VALUE (supposed to be in MODE).
20984
20985    The size is rounded down to whole number of chunk size moved at once.
20986    SRCMEM and DESTMEM provide MEMrtx to feed proper aliasing info.  */
20987
20988
20989 static void
20990 expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem,
20991                                rtx destptr, rtx srcptr, rtx value,
20992                                rtx count, enum machine_mode mode, int unroll,
20993                                int expected_size)
20994 {
20995   rtx out_label, top_label, iter, tmp;
20996   enum machine_mode iter_mode = counter_mode (count);
20997   rtx piece_size = GEN_INT (GET_MODE_SIZE (mode) * unroll);
20998   rtx piece_size_mask = GEN_INT (~((GET_MODE_SIZE (mode) * unroll) - 1));
20999   rtx size;
21000   rtx x_addr;
21001   rtx y_addr;
21002   int i;
21003
21004   top_label = gen_label_rtx ();
21005   out_label = gen_label_rtx ();
21006   iter = gen_reg_rtx (iter_mode);
21007
21008   size = expand_simple_binop (iter_mode, AND, count, piece_size_mask,
21009                               NULL, 1, OPTAB_DIRECT);
21010   /* Those two should combine.  */
21011   if (piece_size == const1_rtx)
21012     {
21013       emit_cmp_and_jump_insns (size, const0_rtx, EQ, NULL_RTX, iter_mode,
21014                                true, out_label);
21015       predict_jump (REG_BR_PROB_BASE * 10 / 100);
21016     }
21017   emit_move_insn (iter, const0_rtx);
21018
21019   emit_label (top_label);
21020
21021   tmp = convert_modes (Pmode, iter_mode, iter, true);
21022   x_addr = gen_rtx_PLUS (Pmode, destptr, tmp);
21023   destmem = change_address (destmem, mode, x_addr);
21024
21025   if (srcmem)
21026     {
21027       y_addr = gen_rtx_PLUS (Pmode, srcptr, copy_rtx (tmp));
21028       srcmem = change_address (srcmem, mode, y_addr);
21029
21030       /* When unrolling for chips that reorder memory reads and writes,
21031          we can save registers by using single temporary.
21032          Also using 4 temporaries is overkill in 32bit mode.  */
21033       if (!TARGET_64BIT && 0)
21034         {
21035           for (i = 0; i < unroll; i++)
21036             {
21037               if (i)
21038                 {
21039                   destmem =
21040                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
21041                   srcmem =
21042                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
21043                 }
21044               emit_move_insn (destmem, srcmem);
21045             }
21046         }
21047       else
21048         {
21049           rtx tmpreg[4];
21050           gcc_assert (unroll <= 4);
21051           for (i = 0; i < unroll; i++)
21052             {
21053               tmpreg[i] = gen_reg_rtx (mode);
21054               if (i)
21055                 {
21056                   srcmem =
21057                     adjust_address (copy_rtx (srcmem), mode, GET_MODE_SIZE (mode));
21058                 }
21059               emit_move_insn (tmpreg[i], srcmem);
21060             }
21061           for (i = 0; i < unroll; i++)
21062             {
21063               if (i)
21064                 {
21065                   destmem =
21066                     adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
21067                 }
21068               emit_move_insn (destmem, tmpreg[i]);
21069             }
21070         }
21071     }
21072   else
21073     for (i = 0; i < unroll; i++)
21074       {
21075         if (i)
21076           destmem =
21077             adjust_address (copy_rtx (destmem), mode, GET_MODE_SIZE (mode));
21078         emit_move_insn (destmem, value);
21079       }
21080
21081   tmp = expand_simple_binop (iter_mode, PLUS, iter, piece_size, iter,
21082                              true, OPTAB_LIB_WIDEN);
21083   if (tmp != iter)
21084     emit_move_insn (iter, tmp);
21085
21086   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
21087                            true, top_label);
21088   if (expected_size != -1)
21089     {
21090       expected_size /= GET_MODE_SIZE (mode) * unroll;
21091       if (expected_size == 0)
21092         predict_jump (0);
21093       else if (expected_size > REG_BR_PROB_BASE)
21094         predict_jump (REG_BR_PROB_BASE - 1);
21095       else
21096         predict_jump (REG_BR_PROB_BASE - (REG_BR_PROB_BASE + expected_size / 2) / expected_size);
21097     }
21098   else
21099     predict_jump (REG_BR_PROB_BASE * 80 / 100);
21100   iter = ix86_zero_extend_to_Pmode (iter);
21101   tmp = expand_simple_binop (Pmode, PLUS, destptr, iter, destptr,
21102                              true, OPTAB_LIB_WIDEN);
21103   if (tmp != destptr)
21104     emit_move_insn (destptr, tmp);
21105   if (srcptr)
21106     {
21107       tmp = expand_simple_binop (Pmode, PLUS, srcptr, iter, srcptr,
21108                                  true, OPTAB_LIB_WIDEN);
21109       if (tmp != srcptr)
21110         emit_move_insn (srcptr, tmp);
21111     }
21112   emit_label (out_label);
21113 }
21114
21115 /* Output "rep; mov" instruction.
21116    Arguments have same meaning as for previous function */
21117 static void
21118 expand_movmem_via_rep_mov (rtx destmem, rtx srcmem,
21119                            rtx destptr, rtx srcptr,
21120                            rtx count,
21121                            enum machine_mode mode)
21122 {
21123   rtx destexp;
21124   rtx srcexp;
21125   rtx countreg;
21126   HOST_WIDE_INT rounded_count;
21127
21128   /* If the size is known, it is shorter to use rep movs.  */
21129   if (mode == QImode && CONST_INT_P (count)
21130       && !(INTVAL (count) & 3))
21131     mode = SImode;
21132
21133   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
21134     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
21135   if (srcptr != XEXP (srcmem, 0) || GET_MODE (srcmem) != BLKmode)
21136     srcmem = adjust_automodify_address_nv (srcmem, BLKmode, srcptr, 0);
21137   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
21138   if (mode != QImode)
21139     {
21140       destexp = gen_rtx_ASHIFT (Pmode, countreg,
21141                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
21142       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
21143       srcexp = gen_rtx_ASHIFT (Pmode, countreg,
21144                                GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
21145       srcexp = gen_rtx_PLUS (Pmode, srcexp, srcptr);
21146     }
21147   else
21148     {
21149       destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
21150       srcexp = gen_rtx_PLUS (Pmode, srcptr, countreg);
21151     }
21152   if (CONST_INT_P (count))
21153     {
21154       rounded_count = (INTVAL (count)
21155                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
21156       destmem = shallow_copy_rtx (destmem);
21157       srcmem = shallow_copy_rtx (srcmem);
21158       set_mem_size (destmem, rounded_count);
21159       set_mem_size (srcmem, rounded_count);
21160     }
21161   else
21162     {
21163       if (MEM_SIZE_KNOWN_P (destmem))
21164         clear_mem_size (destmem);
21165       if (MEM_SIZE_KNOWN_P (srcmem))
21166         clear_mem_size (srcmem);
21167     }
21168   emit_insn (gen_rep_mov (destptr, destmem, srcptr, srcmem, countreg,
21169                           destexp, srcexp));
21170 }
21171
21172 /* Output "rep; stos" instruction.
21173    Arguments have same meaning as for previous function */
21174 static void
21175 expand_setmem_via_rep_stos (rtx destmem, rtx destptr, rtx value,
21176                             rtx count, enum machine_mode mode,
21177                             rtx orig_value)
21178 {
21179   rtx destexp;
21180   rtx countreg;
21181   HOST_WIDE_INT rounded_count;
21182
21183   if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
21184     destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
21185   value = force_reg (mode, gen_lowpart (mode, value));
21186   countreg = ix86_zero_extend_to_Pmode (scale_counter (count, GET_MODE_SIZE (mode)));
21187   if (mode != QImode)
21188     {
21189       destexp = gen_rtx_ASHIFT (Pmode, countreg,
21190                                 GEN_INT (exact_log2 (GET_MODE_SIZE (mode))));
21191       destexp = gen_rtx_PLUS (Pmode, destexp, destptr);
21192     }
21193   else
21194     destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
21195   if (orig_value == const0_rtx && CONST_INT_P (count))
21196     {
21197       rounded_count = (INTVAL (count)
21198                        & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
21199       destmem = shallow_copy_rtx (destmem);
21200       set_mem_size (destmem, rounded_count);
21201     }
21202   else if (MEM_SIZE_KNOWN_P (destmem))
21203     clear_mem_size (destmem);
21204   emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp));
21205 }
21206
21207 static void
21208 emit_strmov (rtx destmem, rtx srcmem,
21209              rtx destptr, rtx srcptr, enum machine_mode mode, int offset)
21210 {
21211   rtx src = adjust_automodify_address_nv (srcmem, mode, srcptr, offset);
21212   rtx dest = adjust_automodify_address_nv (destmem, mode, destptr, offset);
21213   emit_insn (gen_strmov (destptr, dest, srcptr, src));
21214 }
21215
21216 /* Output code to copy at most count & (max_size - 1) bytes from SRC to DEST.  */
21217 static void
21218 expand_movmem_epilogue (rtx destmem, rtx srcmem,
21219                         rtx destptr, rtx srcptr, rtx count, int max_size)
21220 {
21221   rtx src, dest;
21222   if (CONST_INT_P (count))
21223     {
21224       HOST_WIDE_INT countval = INTVAL (count);
21225       int offset = 0;
21226
21227       if ((countval & 0x10) && max_size > 16)
21228         {
21229           if (TARGET_64BIT)
21230             {
21231               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
21232               emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset + 8);
21233             }
21234           else
21235             gcc_unreachable ();
21236           offset += 16;
21237         }
21238       if ((countval & 0x08) && max_size > 8)
21239         {
21240           if (TARGET_64BIT)
21241             emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset);
21242           else
21243             {
21244               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
21245               emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset + 4);
21246             }
21247           offset += 8;
21248         }
21249       if ((countval & 0x04) && max_size > 4)
21250         {
21251           emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset);
21252           offset += 4;
21253         }
21254       if ((countval & 0x02) && max_size > 2)
21255         {
21256           emit_strmov (destmem, srcmem, destptr, srcptr, HImode, offset);
21257           offset += 2;
21258         }
21259       if ((countval & 0x01) && max_size > 1)
21260         {
21261           emit_strmov (destmem, srcmem, destptr, srcptr, QImode, offset);
21262           offset += 1;
21263         }
21264       return;
21265     }
21266   if (max_size > 8)
21267     {
21268       count = expand_simple_binop (GET_MODE (count), AND, count, GEN_INT (max_size - 1),
21269                                     count, 1, OPTAB_DIRECT);
21270       expand_set_or_movmem_via_loop (destmem, srcmem, destptr, srcptr, NULL,
21271                                      count, QImode, 1, 4);
21272       return;
21273     }
21274
21275   /* When there are stringops, we can cheaply increase dest and src pointers.
21276      Otherwise we save code size by maintaining offset (zero is readily
21277      available from preceding rep operation) and using x86 addressing modes.
21278    */
21279   if (TARGET_SINGLE_STRINGOP)
21280     {
21281       if (max_size > 4)
21282         {
21283           rtx label = ix86_expand_aligntest (count, 4, true);
21284           src = change_address (srcmem, SImode, srcptr);
21285           dest = change_address (destmem, SImode, destptr);
21286           emit_insn (gen_strmov (destptr, dest, srcptr, src));
21287           emit_label (label);
21288           LABEL_NUSES (label) = 1;
21289         }
21290       if (max_size > 2)
21291         {
21292           rtx label = ix86_expand_aligntest (count, 2, true);
21293           src = change_address (srcmem, HImode, srcptr);
21294           dest = change_address (destmem, HImode, destptr);
21295           emit_insn (gen_strmov (destptr, dest, srcptr, src));
21296           emit_label (label);
21297           LABEL_NUSES (label) = 1;
21298         }
21299       if (max_size > 1)
21300         {
21301           rtx label = ix86_expand_aligntest (count, 1, true);
21302           src = change_address (srcmem, QImode, srcptr);
21303           dest = change_address (destmem, QImode, destptr);
21304           emit_insn (gen_strmov (destptr, dest, srcptr, src));
21305           emit_label (label);
21306           LABEL_NUSES (label) = 1;
21307         }
21308     }
21309   else
21310     {
21311       rtx offset = force_reg (Pmode, const0_rtx);
21312       rtx tmp;
21313
21314       if (max_size > 4)
21315         {
21316           rtx label = ix86_expand_aligntest (count, 4, true);
21317           src = change_address (srcmem, SImode, srcptr);
21318           dest = change_address (destmem, SImode, destptr);
21319           emit_move_insn (dest, src);
21320           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (4), NULL,
21321                                      true, OPTAB_LIB_WIDEN);
21322           if (tmp != offset)
21323             emit_move_insn (offset, tmp);
21324           emit_label (label);
21325           LABEL_NUSES (label) = 1;
21326         }
21327       if (max_size > 2)
21328         {
21329           rtx label = ix86_expand_aligntest (count, 2, true);
21330           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
21331           src = change_address (srcmem, HImode, tmp);
21332           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
21333           dest = change_address (destmem, HImode, tmp);
21334           emit_move_insn (dest, src);
21335           tmp = expand_simple_binop (Pmode, PLUS, offset, GEN_INT (2), tmp,
21336                                      true, OPTAB_LIB_WIDEN);
21337           if (tmp != offset)
21338             emit_move_insn (offset, tmp);
21339           emit_label (label);
21340           LABEL_NUSES (label) = 1;
21341         }
21342       if (max_size > 1)
21343         {
21344           rtx label = ix86_expand_aligntest (count, 1, true);
21345           tmp = gen_rtx_PLUS (Pmode, srcptr, offset);
21346           src = change_address (srcmem, QImode, tmp);
21347           tmp = gen_rtx_PLUS (Pmode, destptr, offset);
21348           dest = change_address (destmem, QImode, tmp);
21349           emit_move_insn (dest, src);
21350           emit_label (label);
21351           LABEL_NUSES (label) = 1;
21352         }
21353     }
21354 }
21355
21356 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
21357 static void
21358 expand_setmem_epilogue_via_loop (rtx destmem, rtx destptr, rtx value,
21359                                  rtx count, int max_size)
21360 {
21361   count =
21362     expand_simple_binop (counter_mode (count), AND, count,
21363                          GEN_INT (max_size - 1), count, 1, OPTAB_DIRECT);
21364   expand_set_or_movmem_via_loop (destmem, NULL, destptr, NULL,
21365                                  gen_lowpart (QImode, value), count, QImode,
21366                                  1, max_size / 2);
21367 }
21368
21369 /* Output code to set at most count & (max_size - 1) bytes starting by DEST.  */
21370 static void
21371 expand_setmem_epilogue (rtx destmem, rtx destptr, rtx value, rtx count, int max_size)
21372 {
21373   rtx dest;
21374
21375   if (CONST_INT_P (count))
21376     {
21377       HOST_WIDE_INT countval = INTVAL (count);
21378       int offset = 0;
21379
21380       if ((countval & 0x10) && max_size > 16)
21381         {
21382           if (TARGET_64BIT)
21383             {
21384               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
21385               emit_insn (gen_strset (destptr, dest, value));
21386               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset + 8);
21387               emit_insn (gen_strset (destptr, dest, value));
21388             }
21389           else
21390             gcc_unreachable ();
21391           offset += 16;
21392         }
21393       if ((countval & 0x08) && max_size > 8)
21394         {
21395           if (TARGET_64BIT)
21396             {
21397               dest = adjust_automodify_address_nv (destmem, DImode, destptr, offset);
21398               emit_insn (gen_strset (destptr, dest, value));
21399             }
21400           else
21401             {
21402               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
21403               emit_insn (gen_strset (destptr, dest, value));
21404               dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset + 4);
21405               emit_insn (gen_strset (destptr, dest, value));
21406             }
21407           offset += 8;
21408         }
21409       if ((countval & 0x04) && max_size > 4)
21410         {
21411           dest = adjust_automodify_address_nv (destmem, SImode, destptr, offset);
21412           emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
21413           offset += 4;
21414         }
21415       if ((countval & 0x02) && max_size > 2)
21416         {
21417           dest = adjust_automodify_address_nv (destmem, HImode, destptr, offset);
21418           emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
21419           offset += 2;
21420         }
21421       if ((countval & 0x01) && max_size > 1)
21422         {
21423           dest = adjust_automodify_address_nv (destmem, QImode, destptr, offset);
21424           emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
21425           offset += 1;
21426         }
21427       return;
21428     }
21429   if (max_size > 32)
21430     {
21431       expand_setmem_epilogue_via_loop (destmem, destptr, value, count, max_size);
21432       return;
21433     }
21434   if (max_size > 16)
21435     {
21436       rtx label = ix86_expand_aligntest (count, 16, true);
21437       if (TARGET_64BIT)
21438         {
21439           dest = change_address (destmem, DImode, destptr);
21440           emit_insn (gen_strset (destptr, dest, value));
21441           emit_insn (gen_strset (destptr, dest, value));
21442         }
21443       else
21444         {
21445           dest = change_address (destmem, SImode, destptr);
21446           emit_insn (gen_strset (destptr, dest, value));
21447           emit_insn (gen_strset (destptr, dest, value));
21448           emit_insn (gen_strset (destptr, dest, value));
21449           emit_insn (gen_strset (destptr, dest, value));
21450         }
21451       emit_label (label);
21452       LABEL_NUSES (label) = 1;
21453     }
21454   if (max_size > 8)
21455     {
21456       rtx label = ix86_expand_aligntest (count, 8, true);
21457       if (TARGET_64BIT)
21458         {
21459           dest = change_address (destmem, DImode, destptr);
21460           emit_insn (gen_strset (destptr, dest, value));
21461         }
21462       else
21463         {
21464           dest = change_address (destmem, SImode, destptr);
21465           emit_insn (gen_strset (destptr, dest, value));
21466           emit_insn (gen_strset (destptr, dest, value));
21467         }
21468       emit_label (label);
21469       LABEL_NUSES (label) = 1;
21470     }
21471   if (max_size > 4)
21472     {
21473       rtx label = ix86_expand_aligntest (count, 4, true);
21474       dest = change_address (destmem, SImode, destptr);
21475       emit_insn (gen_strset (destptr, dest, gen_lowpart (SImode, value)));
21476       emit_label (label);
21477       LABEL_NUSES (label) = 1;
21478     }
21479   if (max_size > 2)
21480     {
21481       rtx label = ix86_expand_aligntest (count, 2, true);
21482       dest = change_address (destmem, HImode, destptr);
21483       emit_insn (gen_strset (destptr, dest, gen_lowpart (HImode, value)));
21484       emit_label (label);
21485       LABEL_NUSES (label) = 1;
21486     }
21487   if (max_size > 1)
21488     {
21489       rtx label = ix86_expand_aligntest (count, 1, true);
21490       dest = change_address (destmem, QImode, destptr);
21491       emit_insn (gen_strset (destptr, dest, gen_lowpart (QImode, value)));
21492       emit_label (label);
21493       LABEL_NUSES (label) = 1;
21494     }
21495 }
21496
21497 /* Copy enough from DEST to SRC to align DEST known to by aligned by ALIGN to
21498    DESIRED_ALIGNMENT.  */
21499 static void
21500 expand_movmem_prologue (rtx destmem, rtx srcmem,
21501                         rtx destptr, rtx srcptr, rtx count,
21502                         int align, int desired_alignment)
21503 {
21504   if (align <= 1 && desired_alignment > 1)
21505     {
21506       rtx label = ix86_expand_aligntest (destptr, 1, false);
21507       srcmem = change_address (srcmem, QImode, srcptr);
21508       destmem = change_address (destmem, QImode, destptr);
21509       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
21510       ix86_adjust_counter (count, 1);
21511       emit_label (label);
21512       LABEL_NUSES (label) = 1;
21513     }
21514   if (align <= 2 && desired_alignment > 2)
21515     {
21516       rtx label = ix86_expand_aligntest (destptr, 2, false);
21517       srcmem = change_address (srcmem, HImode, srcptr);
21518       destmem = change_address (destmem, HImode, destptr);
21519       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
21520       ix86_adjust_counter (count, 2);
21521       emit_label (label);
21522       LABEL_NUSES (label) = 1;
21523     }
21524   if (align <= 4 && desired_alignment > 4)
21525     {
21526       rtx label = ix86_expand_aligntest (destptr, 4, false);
21527       srcmem = change_address (srcmem, SImode, srcptr);
21528       destmem = change_address (destmem, SImode, destptr);
21529       emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem));
21530       ix86_adjust_counter (count, 4);
21531       emit_label (label);
21532       LABEL_NUSES (label) = 1;
21533     }
21534   gcc_assert (desired_alignment <= 8);
21535 }
21536
21537 /* Copy enough from DST to SRC to align DST known to DESIRED_ALIGN.
21538    ALIGN_BYTES is how many bytes need to be copied.  */
21539 static rtx
21540 expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg,
21541                                  int desired_align, int align_bytes)
21542 {
21543   rtx src = *srcp;
21544   rtx orig_dst = dst;
21545   rtx orig_src = src;
21546   int off = 0;
21547   int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT);
21548   if (src_align_bytes >= 0)
21549     src_align_bytes = desired_align - src_align_bytes;
21550   if (align_bytes & 1)
21551     {
21552       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
21553       src = adjust_automodify_address_nv (src, QImode, srcreg, 0);
21554       off = 1;
21555       emit_insn (gen_strmov (destreg, dst, srcreg, src));
21556     }
21557   if (align_bytes & 2)
21558     {
21559       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
21560       src = adjust_automodify_address_nv (src, HImode, srcreg, off);
21561       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
21562         set_mem_align (dst, 2 * BITS_PER_UNIT);
21563       if (src_align_bytes >= 0
21564           && (src_align_bytes & 1) == (align_bytes & 1)
21565           && MEM_ALIGN (src) < 2 * BITS_PER_UNIT)
21566         set_mem_align (src, 2 * BITS_PER_UNIT);
21567       off = 2;
21568       emit_insn (gen_strmov (destreg, dst, srcreg, src));
21569     }
21570   if (align_bytes & 4)
21571     {
21572       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
21573       src = adjust_automodify_address_nv (src, SImode, srcreg, off);
21574       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
21575         set_mem_align (dst, 4 * BITS_PER_UNIT);
21576       if (src_align_bytes >= 0)
21577         {
21578           unsigned int src_align = 0;
21579           if ((src_align_bytes & 3) == (align_bytes & 3))
21580             src_align = 4;
21581           else if ((src_align_bytes & 1) == (align_bytes & 1))
21582             src_align = 2;
21583           if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
21584             set_mem_align (src, src_align * BITS_PER_UNIT);
21585         }
21586       off = 4;
21587       emit_insn (gen_strmov (destreg, dst, srcreg, src));
21588     }
21589   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
21590   src = adjust_automodify_address_nv (src, BLKmode, srcreg, off);
21591   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
21592     set_mem_align (dst, desired_align * BITS_PER_UNIT);
21593   if (src_align_bytes >= 0)
21594     {
21595       unsigned int src_align = 0;
21596       if ((src_align_bytes & 7) == (align_bytes & 7))
21597         src_align = 8;
21598       else if ((src_align_bytes & 3) == (align_bytes & 3))
21599         src_align = 4;
21600       else if ((src_align_bytes & 1) == (align_bytes & 1))
21601         src_align = 2;
21602       if (src_align > (unsigned int) desired_align)
21603         src_align = desired_align;
21604       if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
21605         set_mem_align (src, src_align * BITS_PER_UNIT);
21606     }
21607   if (MEM_SIZE_KNOWN_P (orig_dst))
21608     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
21609   if (MEM_SIZE_KNOWN_P (orig_src))
21610     set_mem_size (src, MEM_SIZE (orig_src) - align_bytes);
21611   *srcp = src;
21612   return dst;
21613 }
21614
21615 /* Set enough from DEST to align DEST known to by aligned by ALIGN to
21616    DESIRED_ALIGNMENT.  */
21617 static void
21618 expand_setmem_prologue (rtx destmem, rtx destptr, rtx value, rtx count,
21619                         int align, int desired_alignment)
21620 {
21621   if (align <= 1 && desired_alignment > 1)
21622     {
21623       rtx label = ix86_expand_aligntest (destptr, 1, false);
21624       destmem = change_address (destmem, QImode, destptr);
21625       emit_insn (gen_strset (destptr, destmem, gen_lowpart (QImode, value)));
21626       ix86_adjust_counter (count, 1);
21627       emit_label (label);
21628       LABEL_NUSES (label) = 1;
21629     }
21630   if (align <= 2 && desired_alignment > 2)
21631     {
21632       rtx label = ix86_expand_aligntest (destptr, 2, false);
21633       destmem = change_address (destmem, HImode, destptr);
21634       emit_insn (gen_strset (destptr, destmem, gen_lowpart (HImode, value)));
21635       ix86_adjust_counter (count, 2);
21636       emit_label (label);
21637       LABEL_NUSES (label) = 1;
21638     }
21639   if (align <= 4 && desired_alignment > 4)
21640     {
21641       rtx label = ix86_expand_aligntest (destptr, 4, false);
21642       destmem = change_address (destmem, SImode, destptr);
21643       emit_insn (gen_strset (destptr, destmem, gen_lowpart (SImode, value)));
21644       ix86_adjust_counter (count, 4);
21645       emit_label (label);
21646       LABEL_NUSES (label) = 1;
21647     }
21648   gcc_assert (desired_alignment <= 8);
21649 }
21650
21651 /* Set enough from DST to align DST known to by aligned by ALIGN to
21652    DESIRED_ALIGN.  ALIGN_BYTES is how many bytes need to be stored.  */
21653 static rtx
21654 expand_constant_setmem_prologue (rtx dst, rtx destreg, rtx value,
21655                                  int desired_align, int align_bytes)
21656 {
21657   int off = 0;
21658   rtx orig_dst = dst;
21659   if (align_bytes & 1)
21660     {
21661       dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
21662       off = 1;
21663       emit_insn (gen_strset (destreg, dst,
21664                              gen_lowpart (QImode, value)));
21665     }
21666   if (align_bytes & 2)
21667     {
21668       dst = adjust_automodify_address_nv (dst, HImode, destreg, off);
21669       if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT)
21670         set_mem_align (dst, 2 * BITS_PER_UNIT);
21671       off = 2;
21672       emit_insn (gen_strset (destreg, dst,
21673                              gen_lowpart (HImode, value)));
21674     }
21675   if (align_bytes & 4)
21676     {
21677       dst = adjust_automodify_address_nv (dst, SImode, destreg, off);
21678       if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT)
21679         set_mem_align (dst, 4 * BITS_PER_UNIT);
21680       off = 4;
21681       emit_insn (gen_strset (destreg, dst,
21682                              gen_lowpart (SImode, value)));
21683     }
21684   dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
21685   if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
21686     set_mem_align (dst, desired_align * BITS_PER_UNIT);
21687   if (MEM_SIZE_KNOWN_P (orig_dst))
21688     set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
21689   return dst;
21690 }
21691
21692 /* Given COUNT and EXPECTED_SIZE, decide on codegen of string operation.  */
21693 static enum stringop_alg
21694 decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset,
21695             int *dynamic_check)
21696 {
21697   const struct stringop_algs * algs;
21698   bool optimize_for_speed;
21699   /* Algorithms using the rep prefix want at least edi and ecx;
21700      additionally, memset wants eax and memcpy wants esi.  Don't
21701      consider such algorithms if the user has appropriated those
21702      registers for their own purposes.  */
21703   bool rep_prefix_usable = !(fixed_regs[CX_REG] || fixed_regs[DI_REG]
21704                              || (memset
21705                                  ? fixed_regs[AX_REG] : fixed_regs[SI_REG]));
21706
21707 #define ALG_USABLE_P(alg) (rep_prefix_usable                    \
21708                            || (alg != rep_prefix_1_byte         \
21709                                && alg != rep_prefix_4_byte      \
21710                                && alg != rep_prefix_8_byte))
21711   const struct processor_costs *cost;
21712
21713   /* Even if the string operation call is cold, we still might spend a lot
21714      of time processing large blocks.  */
21715   if (optimize_function_for_size_p (cfun)
21716       || (optimize_insn_for_size_p ()
21717           && expected_size != -1 && expected_size < 256))
21718     optimize_for_speed = false;
21719   else
21720     optimize_for_speed = true;
21721
21722   cost = optimize_for_speed ? ix86_cost : &ix86_size_cost;
21723
21724   *dynamic_check = -1;
21725   if (memset)
21726     algs = &cost->memset[TARGET_64BIT != 0];
21727   else
21728     algs = &cost->memcpy[TARGET_64BIT != 0];
21729   if (ix86_stringop_alg != no_stringop && ALG_USABLE_P (ix86_stringop_alg))
21730     return ix86_stringop_alg;
21731   /* rep; movq or rep; movl is the smallest variant.  */
21732   else if (!optimize_for_speed)
21733     {
21734       if (!count || (count & 3))
21735         return rep_prefix_usable ? rep_prefix_1_byte : loop_1_byte;
21736       else
21737         return rep_prefix_usable ? rep_prefix_4_byte : loop;
21738     }
21739   /* Very tiny blocks are best handled via the loop, REP is expensive to setup.
21740    */
21741   else if (expected_size != -1 && expected_size < 4)
21742     return loop_1_byte;
21743   else if (expected_size != -1)
21744     {
21745       unsigned int i;
21746       enum stringop_alg alg = libcall;
21747       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
21748         {
21749           /* We get here if the algorithms that were not libcall-based
21750              were rep-prefix based and we are unable to use rep prefixes
21751              based on global register usage.  Break out of the loop and
21752              use the heuristic below.  */
21753           if (algs->size[i].max == 0)
21754             break;
21755           if (algs->size[i].max >= expected_size || algs->size[i].max == -1)
21756             {
21757               enum stringop_alg candidate = algs->size[i].alg;
21758
21759               if (candidate != libcall && ALG_USABLE_P (candidate))
21760                 alg = candidate;
21761               /* Honor TARGET_INLINE_ALL_STRINGOPS by picking
21762                  last non-libcall inline algorithm.  */
21763               if (TARGET_INLINE_ALL_STRINGOPS)
21764                 {
21765                   /* When the current size is best to be copied by a libcall,
21766                      but we are still forced to inline, run the heuristic below
21767                      that will pick code for medium sized blocks.  */
21768                   if (alg != libcall)
21769                     return alg;
21770                   break;
21771                 }
21772               else if (ALG_USABLE_P (candidate))
21773                 return candidate;
21774             }
21775         }
21776       gcc_assert (TARGET_INLINE_ALL_STRINGOPS || !rep_prefix_usable);
21777     }
21778   /* When asked to inline the call anyway, try to pick meaningful choice.
21779      We look for maximal size of block that is faster to copy by hand and
21780      take blocks of at most of that size guessing that average size will
21781      be roughly half of the block.
21782
21783      If this turns out to be bad, we might simply specify the preferred
21784      choice in ix86_costs.  */
21785   if ((TARGET_INLINE_ALL_STRINGOPS || TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21786       && (algs->unknown_size == libcall || !ALG_USABLE_P (algs->unknown_size)))
21787     {
21788       int max = -1;
21789       enum stringop_alg alg;
21790       int i;
21791       bool any_alg_usable_p = true;
21792
21793       for (i = 0; i < MAX_STRINGOP_ALGS; i++)
21794         {
21795           enum stringop_alg candidate = algs->size[i].alg;
21796           any_alg_usable_p = any_alg_usable_p && ALG_USABLE_P (candidate);
21797
21798           if (candidate != libcall && candidate
21799               && ALG_USABLE_P (candidate))
21800               max = algs->size[i].max;
21801         }
21802       /* If there aren't any usable algorithms, then recursing on
21803          smaller sizes isn't going to find anything.  Just return the
21804          simple byte-at-a-time copy loop.  */
21805       if (!any_alg_usable_p)
21806         {
21807           /* Pick something reasonable.  */
21808           if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21809             *dynamic_check = 128;
21810           return loop_1_byte;
21811         }
21812       if (max == -1)
21813         max = 4096;
21814       alg = decide_alg (count, max / 2, memset, dynamic_check);
21815       gcc_assert (*dynamic_check == -1);
21816       gcc_assert (alg != libcall);
21817       if (TARGET_INLINE_STRINGOPS_DYNAMICALLY)
21818         *dynamic_check = max;
21819       return alg;
21820     }
21821   return ALG_USABLE_P (algs->unknown_size) ? algs->unknown_size : libcall;
21822 #undef ALG_USABLE_P
21823 }
21824
21825 /* Decide on alignment.  We know that the operand is already aligned to ALIGN
21826    (ALIGN can be based on profile feedback and thus it is not 100% guaranteed).  */
21827 static int
21828 decide_alignment (int align,
21829                   enum stringop_alg alg,
21830                   int expected_size)
21831 {
21832   int desired_align = 0;
21833   switch (alg)
21834     {
21835       case no_stringop:
21836         gcc_unreachable ();
21837       case loop:
21838       case unrolled_loop:
21839         desired_align = GET_MODE_SIZE (Pmode);
21840         break;
21841       case rep_prefix_8_byte:
21842         desired_align = 8;
21843         break;
21844       case rep_prefix_4_byte:
21845         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
21846            copying whole cacheline at once.  */
21847         if (TARGET_PENTIUMPRO)
21848           desired_align = 8;
21849         else
21850           desired_align = 4;
21851         break;
21852       case rep_prefix_1_byte:
21853         /* PentiumPro has special logic triggering for 8 byte aligned blocks.
21854            copying whole cacheline at once.  */
21855         if (TARGET_PENTIUMPRO)
21856           desired_align = 8;
21857         else
21858           desired_align = 1;
21859         break;
21860       case loop_1_byte:
21861         desired_align = 1;
21862         break;
21863       case libcall:
21864         return 0;
21865     }
21866
21867   if (optimize_size)
21868     desired_align = 1;
21869   if (desired_align < align)
21870     desired_align = align;
21871   if (expected_size != -1 && expected_size < 4)
21872     desired_align = align;
21873   return desired_align;
21874 }
21875
21876 /* Return the smallest power of 2 greater than VAL.  */
21877 static int
21878 smallest_pow2_greater_than (int val)
21879 {
21880   int ret = 1;
21881   while (ret <= val)
21882     ret <<= 1;
21883   return ret;
21884 }
21885
21886 /* Expand string move (memcpy) operation.  Use i386 string operations
21887    when profitable.  expand_setmem contains similar code.  The code
21888    depends upon architecture, block size and alignment, but always has
21889    the same overall structure:
21890
21891    1) Prologue guard: Conditional that jumps up to epilogues for small
21892       blocks that can be handled by epilogue alone.  This is faster
21893       but also needed for correctness, since prologue assume the block
21894       is larger than the desired alignment.
21895
21896       Optional dynamic check for size and libcall for large
21897       blocks is emitted here too, with -minline-stringops-dynamically.
21898
21899    2) Prologue: copy first few bytes in order to get destination
21900       aligned to DESIRED_ALIGN.  It is emitted only when ALIGN is less
21901       than DESIRED_ALIGN and up to DESIRED_ALIGN - ALIGN bytes can be
21902       copied.  We emit either a jump tree on power of two sized
21903       blocks, or a byte loop.
21904
21905    3) Main body: the copying loop itself, copying in SIZE_NEEDED chunks
21906       with specified algorithm.
21907
21908    4) Epilogue: code copying tail of the block that is too small to be
21909       handled by main body (or up to size guarded by prologue guard).  */
21910
21911 bool
21912 ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
21913                     rtx expected_align_exp, rtx expected_size_exp)
21914 {
21915   rtx destreg;
21916   rtx srcreg;
21917   rtx label = NULL;
21918   rtx tmp;
21919   rtx jump_around_label = NULL;
21920   HOST_WIDE_INT align = 1;
21921   unsigned HOST_WIDE_INT count = 0;
21922   HOST_WIDE_INT expected_size = -1;
21923   int size_needed = 0, epilogue_size_needed;
21924   int desired_align = 0, align_bytes = 0;
21925   enum stringop_alg alg;
21926   int dynamic_check;
21927   bool need_zero_guard = false;
21928
21929   if (CONST_INT_P (align_exp))
21930     align = INTVAL (align_exp);
21931   /* i386 can do misaligned access on reasonably increased cost.  */
21932   if (CONST_INT_P (expected_align_exp)
21933       && INTVAL (expected_align_exp) > align)
21934     align = INTVAL (expected_align_exp);
21935   /* ALIGN is the minimum of destination and source alignment, but we care here
21936      just about destination alignment.  */
21937   else if (MEM_ALIGN (dst) > (unsigned HOST_WIDE_INT) align * BITS_PER_UNIT)
21938     align = MEM_ALIGN (dst) / BITS_PER_UNIT;
21939
21940   if (CONST_INT_P (count_exp))
21941     count = expected_size = INTVAL (count_exp);
21942   if (CONST_INT_P (expected_size_exp) && count == 0)
21943     expected_size = INTVAL (expected_size_exp);
21944
21945   /* Make sure we don't need to care about overflow later on.  */
21946   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
21947     return false;
21948
21949   /* Step 0: Decide on preferred algorithm, desired alignment and
21950      size of chunks to be copied by main loop.  */
21951
21952   alg = decide_alg (count, expected_size, false, &dynamic_check);
21953   desired_align = decide_alignment (align, alg, expected_size);
21954
21955   if (!TARGET_ALIGN_STRINGOPS)
21956     align = desired_align;
21957
21958   if (alg == libcall)
21959     return false;
21960   gcc_assert (alg != no_stringop);
21961   if (!count)
21962     count_exp = copy_to_mode_reg (GET_MODE (count_exp), count_exp);
21963   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
21964   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
21965   switch (alg)
21966     {
21967     case libcall:
21968     case no_stringop:
21969       gcc_unreachable ();
21970     case loop:
21971       need_zero_guard = true;
21972       size_needed = GET_MODE_SIZE (Pmode);
21973       break;
21974     case unrolled_loop:
21975       need_zero_guard = true;
21976       size_needed = GET_MODE_SIZE (Pmode) * (TARGET_64BIT ? 4 : 2);
21977       break;
21978     case rep_prefix_8_byte:
21979       size_needed = 8;
21980       break;
21981     case rep_prefix_4_byte:
21982       size_needed = 4;
21983       break;
21984     case rep_prefix_1_byte:
21985       size_needed = 1;
21986       break;
21987     case loop_1_byte:
21988       need_zero_guard = true;
21989       size_needed = 1;
21990       break;
21991     }
21992
21993   epilogue_size_needed = size_needed;
21994
21995   /* Step 1: Prologue guard.  */
21996
21997   /* Alignment code needs count to be in register.  */
21998   if (CONST_INT_P (count_exp) && desired_align > align)
21999     {
22000       if (INTVAL (count_exp) > desired_align
22001           && INTVAL (count_exp) > size_needed)
22002         {
22003           align_bytes
22004             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
22005           if (align_bytes <= 0)
22006             align_bytes = 0;
22007           else
22008             align_bytes = desired_align - align_bytes;
22009         }
22010       if (align_bytes == 0)
22011         count_exp = force_reg (counter_mode (count_exp), count_exp);
22012     }
22013   gcc_assert (desired_align >= 1 && align >= 1);
22014
22015   /* Ensure that alignment prologue won't copy past end of block.  */
22016   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
22017     {
22018       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
22019       /* Epilogue always copies COUNT_EXP & EPILOGUE_SIZE_NEEDED bytes.
22020          Make sure it is power of 2.  */
22021       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
22022
22023       if (count)
22024         {
22025           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
22026             {
22027               /* If main algorithm works on QImode, no epilogue is needed.
22028                  For small sizes just don't align anything.  */
22029               if (size_needed == 1)
22030                 desired_align = align;
22031               else
22032                 goto epilogue;
22033             }
22034         }
22035       else
22036         {
22037           label = gen_label_rtx ();
22038           emit_cmp_and_jump_insns (count_exp,
22039                                    GEN_INT (epilogue_size_needed),
22040                                    LTU, 0, counter_mode (count_exp), 1, label);
22041           if (expected_size == -1 || expected_size < epilogue_size_needed)
22042             predict_jump (REG_BR_PROB_BASE * 60 / 100);
22043           else
22044             predict_jump (REG_BR_PROB_BASE * 20 / 100);
22045         }
22046     }
22047
22048   /* Emit code to decide on runtime whether library call or inline should be
22049      used.  */
22050   if (dynamic_check != -1)
22051     {
22052       if (CONST_INT_P (count_exp))
22053         {
22054           if (UINTVAL (count_exp) >= (unsigned HOST_WIDE_INT)dynamic_check)
22055             {
22056               emit_block_move_via_libcall (dst, src, count_exp, false);
22057               count_exp = const0_rtx;
22058               goto epilogue;
22059             }
22060         }
22061       else
22062         {
22063           rtx hot_label = gen_label_rtx ();
22064           jump_around_label = gen_label_rtx ();
22065           emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
22066                                    LEU, 0, GET_MODE (count_exp), 1, hot_label);
22067           predict_jump (REG_BR_PROB_BASE * 90 / 100);
22068           emit_block_move_via_libcall (dst, src, count_exp, false);
22069           emit_jump (jump_around_label);
22070           emit_label (hot_label);
22071         }
22072     }
22073
22074   /* Step 2: Alignment prologue.  */
22075
22076   if (desired_align > align)
22077     {
22078       if (align_bytes == 0)
22079         {
22080           /* Except for the first move in epilogue, we no longer know
22081              constant offset in aliasing info.  It don't seems to worth
22082              the pain to maintain it for the first move, so throw away
22083              the info early.  */
22084           src = change_address (src, BLKmode, srcreg);
22085           dst = change_address (dst, BLKmode, destreg);
22086           expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align,
22087                                   desired_align);
22088         }
22089       else
22090         {
22091           /* If we know how many bytes need to be stored before dst is
22092              sufficiently aligned, maintain aliasing info accurately.  */
22093           dst = expand_constant_movmem_prologue (dst, &src, destreg, srcreg,
22094                                                  desired_align, align_bytes);
22095           count_exp = plus_constant (count_exp, -align_bytes);
22096           count -= align_bytes;
22097         }
22098       if (need_zero_guard
22099           && (count < (unsigned HOST_WIDE_INT) size_needed
22100               || (align_bytes == 0
22101                   && count < ((unsigned HOST_WIDE_INT) size_needed
22102                               + desired_align - align))))
22103         {
22104           /* It is possible that we copied enough so the main loop will not
22105              execute.  */
22106           gcc_assert (size_needed > 1);
22107           if (label == NULL_RTX)
22108             label = gen_label_rtx ();
22109           emit_cmp_and_jump_insns (count_exp,
22110                                    GEN_INT (size_needed),
22111                                    LTU, 0, counter_mode (count_exp), 1, label);
22112           if (expected_size == -1
22113               || expected_size < (desired_align - align) / 2 + size_needed)
22114             predict_jump (REG_BR_PROB_BASE * 20 / 100);
22115           else
22116             predict_jump (REG_BR_PROB_BASE * 60 / 100);
22117         }
22118     }
22119   if (label && size_needed == 1)
22120     {
22121       emit_label (label);
22122       LABEL_NUSES (label) = 1;
22123       label = NULL;
22124       epilogue_size_needed = 1;
22125     }
22126   else if (label == NULL_RTX)
22127     epilogue_size_needed = size_needed;
22128
22129   /* Step 3: Main loop.  */
22130
22131   switch (alg)
22132     {
22133     case libcall:
22134     case no_stringop:
22135       gcc_unreachable ();
22136     case loop_1_byte:
22137       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
22138                                      count_exp, QImode, 1, expected_size);
22139       break;
22140     case loop:
22141       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
22142                                      count_exp, Pmode, 1, expected_size);
22143       break;
22144     case unrolled_loop:
22145       /* Unroll only by factor of 2 in 32bit mode, since we don't have enough
22146          registers for 4 temporaries anyway.  */
22147       expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL,
22148                                      count_exp, Pmode, TARGET_64BIT ? 4 : 2,
22149                                      expected_size);
22150       break;
22151     case rep_prefix_8_byte:
22152       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
22153                                  DImode);
22154       break;
22155     case rep_prefix_4_byte:
22156       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
22157                                  SImode);
22158       break;
22159     case rep_prefix_1_byte:
22160       expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp,
22161                                  QImode);
22162       break;
22163     }
22164   /* Adjust properly the offset of src and dest memory for aliasing.  */
22165   if (CONST_INT_P (count_exp))
22166     {
22167       src = adjust_automodify_address_nv (src, BLKmode, srcreg,
22168                                           (count / size_needed) * size_needed);
22169       dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
22170                                           (count / size_needed) * size_needed);
22171     }
22172   else
22173     {
22174       src = change_address (src, BLKmode, srcreg);
22175       dst = change_address (dst, BLKmode, destreg);
22176     }
22177
22178   /* Step 4: Epilogue to copy the remaining bytes.  */
22179  epilogue:
22180   if (label)
22181     {
22182       /* When the main loop is done, COUNT_EXP might hold original count,
22183          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
22184          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
22185          bytes. Compensate if needed.  */
22186
22187       if (size_needed < epilogue_size_needed)
22188         {
22189           tmp =
22190             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
22191                                  GEN_INT (size_needed - 1), count_exp, 1,
22192                                  OPTAB_DIRECT);
22193           if (tmp != count_exp)
22194             emit_move_insn (count_exp, tmp);
22195         }
22196       emit_label (label);
22197       LABEL_NUSES (label) = 1;
22198     }
22199
22200   if (count_exp != const0_rtx && epilogue_size_needed > 1)
22201     expand_movmem_epilogue (dst, src, destreg, srcreg, count_exp,
22202                             epilogue_size_needed);
22203   if (jump_around_label)
22204     emit_label (jump_around_label);
22205   return true;
22206 }
22207
22208 /* Helper function for memcpy.  For QImode value 0xXY produce
22209    0xXYXYXYXY of wide specified by MODE.  This is essentially
22210    a * 0x10101010, but we can do slightly better than
22211    synth_mult by unwinding the sequence by hand on CPUs with
22212    slow multiply.  */
22213 static rtx
22214 promote_duplicated_reg (enum machine_mode mode, rtx val)
22215 {
22216   enum machine_mode valmode = GET_MODE (val);
22217   rtx tmp;
22218   int nops = mode == DImode ? 3 : 2;
22219
22220   gcc_assert (mode == SImode || mode == DImode);
22221   if (val == const0_rtx)
22222     return copy_to_mode_reg (mode, const0_rtx);
22223   if (CONST_INT_P (val))
22224     {
22225       HOST_WIDE_INT v = INTVAL (val) & 255;
22226
22227       v |= v << 8;
22228       v |= v << 16;
22229       if (mode == DImode)
22230         v |= (v << 16) << 16;
22231       return copy_to_mode_reg (mode, gen_int_mode (v, mode));
22232     }
22233
22234   if (valmode == VOIDmode)
22235     valmode = QImode;
22236   if (valmode != QImode)
22237     val = gen_lowpart (QImode, val);
22238   if (mode == QImode)
22239     return val;
22240   if (!TARGET_PARTIAL_REG_STALL)
22241     nops--;
22242   if (ix86_cost->mult_init[mode == DImode ? 3 : 2]
22243       + ix86_cost->mult_bit * (mode == DImode ? 8 : 4)
22244       <= (ix86_cost->shift_const + ix86_cost->add) * nops
22245           + (COSTS_N_INSNS (TARGET_PARTIAL_REG_STALL == 0)))
22246     {
22247       rtx reg = convert_modes (mode, QImode, val, true);
22248       tmp = promote_duplicated_reg (mode, const1_rtx);
22249       return expand_simple_binop (mode, MULT, reg, tmp, NULL, 1,
22250                                   OPTAB_DIRECT);
22251     }
22252   else
22253     {
22254       rtx reg = convert_modes (mode, QImode, val, true);
22255
22256       if (!TARGET_PARTIAL_REG_STALL)
22257         if (mode == SImode)
22258           emit_insn (gen_movsi_insv_1 (reg, reg));
22259         else
22260           emit_insn (gen_movdi_insv_1 (reg, reg));
22261       else
22262         {
22263           tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (8),
22264                                      NULL, 1, OPTAB_DIRECT);
22265           reg =
22266             expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
22267         }
22268       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (16),
22269                                  NULL, 1, OPTAB_DIRECT);
22270       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
22271       if (mode == SImode)
22272         return reg;
22273       tmp = expand_simple_binop (mode, ASHIFT, reg, GEN_INT (32),
22274                                  NULL, 1, OPTAB_DIRECT);
22275       reg = expand_simple_binop (mode, IOR, reg, tmp, reg, 1, OPTAB_DIRECT);
22276       return reg;
22277     }
22278 }
22279
22280 /* Duplicate value VAL using promote_duplicated_reg into maximal size that will
22281    be needed by main loop copying SIZE_NEEDED chunks and prologue getting
22282    alignment from ALIGN to DESIRED_ALIGN.  */
22283 static rtx
22284 promote_duplicated_reg_to_size (rtx val, int size_needed, int desired_align, int align)
22285 {
22286   rtx promoted_val;
22287
22288   if (TARGET_64BIT
22289       && (size_needed > 4 || (desired_align > align && desired_align > 4)))
22290     promoted_val = promote_duplicated_reg (DImode, val);
22291   else if (size_needed > 2 || (desired_align > align && desired_align > 2))
22292     promoted_val = promote_duplicated_reg (SImode, val);
22293   else if (size_needed > 1 || (desired_align > align && desired_align > 1))
22294     promoted_val = promote_duplicated_reg (HImode, val);
22295   else
22296     promoted_val = val;
22297
22298   return promoted_val;
22299 }
22300
22301 /* Expand string clear operation (bzero).  Use i386 string operations when
22302    profitable.  See expand_movmem comment for explanation of individual
22303    steps performed.  */
22304 bool
22305 ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp,
22306                     rtx expected_align_exp, rtx expected_size_exp)
22307 {
22308   rtx destreg;
22309   rtx label = NULL;
22310   rtx tmp;
22311   rtx jump_around_label = NULL;
22312   HOST_WIDE_INT align = 1;
22313   unsigned HOST_WIDE_INT count = 0;
22314   HOST_WIDE_INT expected_size = -1;
22315   int size_needed = 0, epilogue_size_needed;
22316   int desired_align = 0, align_bytes = 0;
22317   enum stringop_alg alg;
22318   rtx promoted_val = NULL;
22319   bool force_loopy_epilogue = false;
22320   int dynamic_check;
22321   bool need_zero_guard = false;
22322
22323   if (CONST_INT_P (align_exp))
22324     align = INTVAL (align_exp);
22325   /* i386 can do misaligned access on reasonably increased cost.  */
22326   if (CONST_INT_P (expected_align_exp)
22327       && INTVAL (expected_align_exp) > align)
22328     align = INTVAL (expected_align_exp);
22329   if (CONST_INT_P (count_exp))
22330     count = expected_size = INTVAL (count_exp);
22331   if (CONST_INT_P (expected_size_exp) && count == 0)
22332     expected_size = INTVAL (expected_size_exp);
22333
22334   /* Make sure we don't need to care about overflow later on.  */
22335   if (count > ((unsigned HOST_WIDE_INT) 1 << 30))
22336     return false;
22337
22338   /* Step 0: Decide on preferred algorithm, desired alignment and
22339      size of chunks to be copied by main loop.  */
22340
22341   alg = decide_alg (count, expected_size, true, &dynamic_check);
22342   desired_align = decide_alignment (align, alg, expected_size);
22343
22344   if (!TARGET_ALIGN_STRINGOPS)
22345     align = desired_align;
22346
22347   if (alg == libcall)
22348     return false;
22349   gcc_assert (alg != no_stringop);
22350   if (!count)
22351     count_exp = copy_to_mode_reg (counter_mode (count_exp), count_exp);
22352   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
22353   switch (alg)
22354     {
22355     case libcall:
22356     case no_stringop:
22357       gcc_unreachable ();
22358     case loop:
22359       need_zero_guard = true;
22360       size_needed = GET_MODE_SIZE (Pmode);
22361       break;
22362     case unrolled_loop:
22363       need_zero_guard = true;
22364       size_needed = GET_MODE_SIZE (Pmode) * 4;
22365       break;
22366     case rep_prefix_8_byte:
22367       size_needed = 8;
22368       break;
22369     case rep_prefix_4_byte:
22370       size_needed = 4;
22371       break;
22372     case rep_prefix_1_byte:
22373       size_needed = 1;
22374       break;
22375     case loop_1_byte:
22376       need_zero_guard = true;
22377       size_needed = 1;
22378       break;
22379     }
22380   epilogue_size_needed = size_needed;
22381
22382   /* Step 1: Prologue guard.  */
22383
22384   /* Alignment code needs count to be in register.  */
22385   if (CONST_INT_P (count_exp) && desired_align > align)
22386     {
22387       if (INTVAL (count_exp) > desired_align
22388           && INTVAL (count_exp) > size_needed)
22389         {
22390           align_bytes
22391             = get_mem_align_offset (dst, desired_align * BITS_PER_UNIT);
22392           if (align_bytes <= 0)
22393             align_bytes = 0;
22394           else
22395             align_bytes = desired_align - align_bytes;
22396         }
22397       if (align_bytes == 0)
22398         {
22399           enum machine_mode mode = SImode;
22400           if (TARGET_64BIT && (count & ~0xffffffff))
22401             mode = DImode;
22402           count_exp = force_reg (mode, count_exp);
22403         }
22404     }
22405   /* Do the cheap promotion to allow better CSE across the
22406      main loop and epilogue (ie one load of the big constant in the
22407      front of all code.  */
22408   if (CONST_INT_P (val_exp))
22409     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
22410                                                    desired_align, align);
22411   /* Ensure that alignment prologue won't copy past end of block.  */
22412   if (size_needed > 1 || (desired_align > 1 && desired_align > align))
22413     {
22414       epilogue_size_needed = MAX (size_needed - 1, desired_align - align);
22415       /* Epilogue always copies COUNT_EXP & (EPILOGUE_SIZE_NEEDED - 1) bytes.
22416          Make sure it is power of 2.  */
22417       epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed);
22418
22419       /* To improve performance of small blocks, we jump around the VAL
22420          promoting mode.  This mean that if the promoted VAL is not constant,
22421          we might not use it in the epilogue and have to use byte
22422          loop variant.  */
22423       if (epilogue_size_needed > 2 && !promoted_val)
22424         force_loopy_epilogue = true;
22425       if (count)
22426         {
22427           if (count < (unsigned HOST_WIDE_INT)epilogue_size_needed)
22428             {
22429               /* If main algorithm works on QImode, no epilogue is needed.
22430                  For small sizes just don't align anything.  */
22431               if (size_needed == 1)
22432                 desired_align = align;
22433               else
22434                 goto epilogue;
22435             }
22436         }
22437       else
22438         {
22439           label = gen_label_rtx ();
22440           emit_cmp_and_jump_insns (count_exp,
22441                                    GEN_INT (epilogue_size_needed),
22442                                    LTU, 0, counter_mode (count_exp), 1, label);
22443           if (expected_size == -1 || expected_size <= epilogue_size_needed)
22444             predict_jump (REG_BR_PROB_BASE * 60 / 100);
22445           else
22446             predict_jump (REG_BR_PROB_BASE * 20 / 100);
22447         }
22448     }
22449   if (dynamic_check != -1)
22450     {
22451       rtx hot_label = gen_label_rtx ();
22452       jump_around_label = gen_label_rtx ();
22453       emit_cmp_and_jump_insns (count_exp, GEN_INT (dynamic_check - 1),
22454                                LEU, 0, counter_mode (count_exp), 1, hot_label);
22455       predict_jump (REG_BR_PROB_BASE * 90 / 100);
22456       set_storage_via_libcall (dst, count_exp, val_exp, false);
22457       emit_jump (jump_around_label);
22458       emit_label (hot_label);
22459     }
22460
22461   /* Step 2: Alignment prologue.  */
22462
22463   /* Do the expensive promotion once we branched off the small blocks.  */
22464   if (!promoted_val)
22465     promoted_val = promote_duplicated_reg_to_size (val_exp, size_needed,
22466                                                    desired_align, align);
22467   gcc_assert (desired_align >= 1 && align >= 1);
22468
22469   if (desired_align > align)
22470     {
22471       if (align_bytes == 0)
22472         {
22473           /* Except for the first move in epilogue, we no longer know
22474              constant offset in aliasing info.  It don't seems to worth
22475              the pain to maintain it for the first move, so throw away
22476              the info early.  */
22477           dst = change_address (dst, BLKmode, destreg);
22478           expand_setmem_prologue (dst, destreg, promoted_val, count_exp, align,
22479                                   desired_align);
22480         }
22481       else
22482         {
22483           /* If we know how many bytes need to be stored before dst is
22484              sufficiently aligned, maintain aliasing info accurately.  */
22485           dst = expand_constant_setmem_prologue (dst, destreg, promoted_val,
22486                                                  desired_align, align_bytes);
22487           count_exp = plus_constant (count_exp, -align_bytes);
22488           count -= align_bytes;
22489         }
22490       if (need_zero_guard
22491           && (count < (unsigned HOST_WIDE_INT) size_needed
22492               || (align_bytes == 0
22493                   && count < ((unsigned HOST_WIDE_INT) size_needed
22494                               + desired_align - align))))
22495         {
22496           /* It is possible that we copied enough so the main loop will not
22497              execute.  */
22498           gcc_assert (size_needed > 1);
22499           if (label == NULL_RTX)
22500             label = gen_label_rtx ();
22501           emit_cmp_and_jump_insns (count_exp,
22502                                    GEN_INT (size_needed),
22503                                    LTU, 0, counter_mode (count_exp), 1, label);
22504           if (expected_size == -1
22505               || expected_size < (desired_align - align) / 2 + size_needed)
22506             predict_jump (REG_BR_PROB_BASE * 20 / 100);
22507           else
22508             predict_jump (REG_BR_PROB_BASE * 60 / 100);
22509         }
22510     }
22511   if (label && size_needed == 1)
22512     {
22513       emit_label (label);
22514       LABEL_NUSES (label) = 1;
22515       label = NULL;
22516       promoted_val = val_exp;
22517       epilogue_size_needed = 1;
22518     }
22519   else if (label == NULL_RTX)
22520     epilogue_size_needed = size_needed;
22521
22522   /* Step 3: Main loop.  */
22523
22524   switch (alg)
22525     {
22526     case libcall:
22527     case no_stringop:
22528       gcc_unreachable ();
22529     case loop_1_byte:
22530       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
22531                                      count_exp, QImode, 1, expected_size);
22532       break;
22533     case loop:
22534       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
22535                                      count_exp, Pmode, 1, expected_size);
22536       break;
22537     case unrolled_loop:
22538       expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val,
22539                                      count_exp, Pmode, 4, expected_size);
22540       break;
22541     case rep_prefix_8_byte:
22542       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
22543                                   DImode, val_exp);
22544       break;
22545     case rep_prefix_4_byte:
22546       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
22547                                   SImode, val_exp);
22548       break;
22549     case rep_prefix_1_byte:
22550       expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp,
22551                                   QImode, val_exp);
22552       break;
22553     }
22554   /* Adjust properly the offset of src and dest memory for aliasing.  */
22555   if (CONST_INT_P (count_exp))
22556     dst = adjust_automodify_address_nv (dst, BLKmode, destreg,
22557                                         (count / size_needed) * size_needed);
22558   else
22559     dst = change_address (dst, BLKmode, destreg);
22560
22561   /* Step 4: Epilogue to copy the remaining bytes.  */
22562
22563   if (label)
22564     {
22565       /* When the main loop is done, COUNT_EXP might hold original count,
22566          while we want to copy only COUNT_EXP & SIZE_NEEDED bytes.
22567          Epilogue code will actually copy COUNT_EXP & EPILOGUE_SIZE_NEEDED
22568          bytes. Compensate if needed.  */
22569
22570       if (size_needed < epilogue_size_needed)
22571         {
22572           tmp =
22573             expand_simple_binop (counter_mode (count_exp), AND, count_exp,
22574                                  GEN_INT (size_needed - 1), count_exp, 1,
22575                                  OPTAB_DIRECT);
22576           if (tmp != count_exp)
22577             emit_move_insn (count_exp, tmp);
22578         }
22579       emit_label (label);
22580       LABEL_NUSES (label) = 1;
22581     }
22582  epilogue:
22583   if (count_exp != const0_rtx && epilogue_size_needed > 1)
22584     {
22585       if (force_loopy_epilogue)
22586         expand_setmem_epilogue_via_loop (dst, destreg, val_exp, count_exp,
22587                                          epilogue_size_needed);
22588       else
22589         expand_setmem_epilogue (dst, destreg, promoted_val, count_exp,
22590                                 epilogue_size_needed);
22591     }
22592   if (jump_around_label)
22593     emit_label (jump_around_label);
22594   return true;
22595 }
22596
22597 /* Expand the appropriate insns for doing strlen if not just doing
22598    repnz; scasb
22599
22600    out = result, initialized with the start address
22601    align_rtx = alignment of the address.
22602    scratch = scratch register, initialized with the startaddress when
22603         not aligned, otherwise undefined
22604
22605    This is just the body. It needs the initializations mentioned above and
22606    some address computing at the end.  These things are done in i386.md.  */
22607
22608 static void
22609 ix86_expand_strlensi_unroll_1 (rtx out, rtx src, rtx align_rtx)
22610 {
22611   int align;
22612   rtx tmp;
22613   rtx align_2_label = NULL_RTX;
22614   rtx align_3_label = NULL_RTX;
22615   rtx align_4_label = gen_label_rtx ();
22616   rtx end_0_label = gen_label_rtx ();
22617   rtx mem;
22618   rtx tmpreg = gen_reg_rtx (SImode);
22619   rtx scratch = gen_reg_rtx (SImode);
22620   rtx cmp;
22621
22622   align = 0;
22623   if (CONST_INT_P (align_rtx))
22624     align = INTVAL (align_rtx);
22625
22626   /* Loop to check 1..3 bytes for null to get an aligned pointer.  */
22627
22628   /* Is there a known alignment and is it less than 4?  */
22629   if (align < 4)
22630     {
22631       rtx scratch1 = gen_reg_rtx (Pmode);
22632       emit_move_insn (scratch1, out);
22633       /* Is there a known alignment and is it not 2? */
22634       if (align != 2)
22635         {
22636           align_3_label = gen_label_rtx (); /* Label when aligned to 3-byte */
22637           align_2_label = gen_label_rtx (); /* Label when aligned to 2-byte */
22638
22639           /* Leave just the 3 lower bits.  */
22640           align_rtx = expand_binop (Pmode, and_optab, scratch1, GEN_INT (3),
22641                                     NULL_RTX, 0, OPTAB_WIDEN);
22642
22643           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
22644                                    Pmode, 1, align_4_label);
22645           emit_cmp_and_jump_insns (align_rtx, const2_rtx, EQ, NULL,
22646                                    Pmode, 1, align_2_label);
22647           emit_cmp_and_jump_insns (align_rtx, const2_rtx, GTU, NULL,
22648                                    Pmode, 1, align_3_label);
22649         }
22650       else
22651         {
22652           /* Since the alignment is 2, we have to check 2 or 0 bytes;
22653              check if is aligned to 4 - byte.  */
22654
22655           align_rtx = expand_binop (Pmode, and_optab, scratch1, const2_rtx,
22656                                     NULL_RTX, 0, OPTAB_WIDEN);
22657
22658           emit_cmp_and_jump_insns (align_rtx, const0_rtx, EQ, NULL,
22659                                    Pmode, 1, align_4_label);
22660         }
22661
22662       mem = change_address (src, QImode, out);
22663
22664       /* Now compare the bytes.  */
22665
22666       /* Compare the first n unaligned byte on a byte per byte basis.  */
22667       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL,
22668                                QImode, 1, end_0_label);
22669
22670       /* Increment the address.  */
22671       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22672
22673       /* Not needed with an alignment of 2 */
22674       if (align != 2)
22675         {
22676           emit_label (align_2_label);
22677
22678           emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
22679                                    end_0_label);
22680
22681           emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22682
22683           emit_label (align_3_label);
22684         }
22685
22686       emit_cmp_and_jump_insns (mem, const0_rtx, EQ, NULL, QImode, 1,
22687                                end_0_label);
22688
22689       emit_insn (ix86_gen_add3 (out, out, const1_rtx));
22690     }
22691
22692   /* Generate loop to check 4 bytes at a time.  It is not a good idea to
22693      align this loop.  It gives only huge programs, but does not help to
22694      speed up.  */
22695   emit_label (align_4_label);
22696
22697   mem = change_address (src, SImode, out);
22698   emit_move_insn (scratch, mem);
22699   emit_insn (ix86_gen_add3 (out, out, GEN_INT (4)));
22700
22701   /* This formula yields a nonzero result iff one of the bytes is zero.
22702      This saves three branches inside loop and many cycles.  */
22703
22704   emit_insn (gen_addsi3 (tmpreg, scratch, GEN_INT (-0x01010101)));
22705   emit_insn (gen_one_cmplsi2 (scratch, scratch));
22706   emit_insn (gen_andsi3 (tmpreg, tmpreg, scratch));
22707   emit_insn (gen_andsi3 (tmpreg, tmpreg,
22708                          gen_int_mode (0x80808080, SImode)));
22709   emit_cmp_and_jump_insns (tmpreg, const0_rtx, EQ, 0, SImode, 1,
22710                            align_4_label);
22711
22712   if (TARGET_CMOVE)
22713     {
22714        rtx reg = gen_reg_rtx (SImode);
22715        rtx reg2 = gen_reg_rtx (Pmode);
22716        emit_move_insn (reg, tmpreg);
22717        emit_insn (gen_lshrsi3 (reg, reg, GEN_INT (16)));
22718
22719        /* If zero is not in the first two bytes, move two bytes forward.  */
22720        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
22721        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22722        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
22723        emit_insn (gen_rtx_SET (VOIDmode, tmpreg,
22724                                gen_rtx_IF_THEN_ELSE (SImode, tmp,
22725                                                      reg,
22726                                                      tmpreg)));
22727        /* Emit lea manually to avoid clobbering of flags.  */
22728        emit_insn (gen_rtx_SET (SImode, reg2,
22729                                gen_rtx_PLUS (Pmode, out, const2_rtx)));
22730
22731        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22732        tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
22733        emit_insn (gen_rtx_SET (VOIDmode, out,
22734                                gen_rtx_IF_THEN_ELSE (Pmode, tmp,
22735                                                      reg2,
22736                                                      out)));
22737     }
22738   else
22739     {
22740        rtx end_2_label = gen_label_rtx ();
22741        /* Is zero in the first two bytes? */
22742
22743        emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
22744        tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
22745        tmp = gen_rtx_NE (VOIDmode, tmp, const0_rtx);
22746        tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
22747                             gen_rtx_LABEL_REF (VOIDmode, end_2_label),
22748                             pc_rtx);
22749        tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
22750        JUMP_LABEL (tmp) = end_2_label;
22751
22752        /* Not in the first two.  Move two bytes forward.  */
22753        emit_insn (gen_lshrsi3 (tmpreg, tmpreg, GEN_INT (16)));
22754        emit_insn (ix86_gen_add3 (out, out, const2_rtx));
22755
22756        emit_label (end_2_label);
22757
22758     }
22759
22760   /* Avoid branch in fixing the byte.  */
22761   tmpreg = gen_lowpart (QImode, tmpreg);
22762   emit_insn (gen_addqi3_cc (tmpreg, tmpreg, tmpreg));
22763   tmp = gen_rtx_REG (CCmode, FLAGS_REG);
22764   cmp = gen_rtx_LTU (VOIDmode, tmp, const0_rtx);
22765   emit_insn (ix86_gen_sub3_carry (out, out, GEN_INT (3), tmp, cmp));
22766
22767   emit_label (end_0_label);
22768 }
22769
22770 /* Expand strlen.  */
22771
22772 bool
22773 ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align)
22774 {
22775   rtx addr, scratch1, scratch2, scratch3, scratch4;
22776
22777   /* The generic case of strlen expander is long.  Avoid it's
22778      expanding unless TARGET_INLINE_ALL_STRINGOPS.  */
22779
22780   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
22781       && !TARGET_INLINE_ALL_STRINGOPS
22782       && !optimize_insn_for_size_p ()
22783       && (!CONST_INT_P (align) || INTVAL (align) < 4))
22784     return false;
22785
22786   addr = force_reg (Pmode, XEXP (src, 0));
22787   scratch1 = gen_reg_rtx (Pmode);
22788
22789   if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1
22790       && !optimize_insn_for_size_p ())
22791     {
22792       /* Well it seems that some optimizer does not combine a call like
22793          foo(strlen(bar), strlen(bar));
22794          when the move and the subtraction is done here.  It does calculate
22795          the length just once when these instructions are done inside of
22796          output_strlen_unroll().  But I think since &bar[strlen(bar)] is
22797          often used and I use one fewer register for the lifetime of
22798          output_strlen_unroll() this is better.  */
22799
22800       emit_move_insn (out, addr);
22801
22802       ix86_expand_strlensi_unroll_1 (out, src, align);
22803
22804       /* strlensi_unroll_1 returns the address of the zero at the end of
22805          the string, like memchr(), so compute the length by subtracting
22806          the start address.  */
22807       emit_insn (ix86_gen_sub3 (out, out, addr));
22808     }
22809   else
22810     {
22811       rtx unspec;
22812
22813       /* Can't use this if the user has appropriated eax, ecx, or edi.  */
22814       if (fixed_regs[AX_REG] || fixed_regs[CX_REG] || fixed_regs[DI_REG])
22815         return false;
22816
22817       scratch2 = gen_reg_rtx (Pmode);
22818       scratch3 = gen_reg_rtx (Pmode);
22819       scratch4 = force_reg (Pmode, constm1_rtx);
22820
22821       emit_move_insn (scratch3, addr);
22822       eoschar = force_reg (QImode, eoschar);
22823
22824       src = replace_equiv_address_nv (src, scratch3);
22825
22826       /* If .md starts supporting :P, this can be done in .md.  */
22827       unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (4, src, eoschar, align,
22828                                                  scratch4), UNSPEC_SCAS);
22829       emit_insn (gen_strlenqi_1 (scratch1, scratch3, unspec));
22830       emit_insn (ix86_gen_one_cmpl2 (scratch2, scratch1));
22831       emit_insn (ix86_gen_add3 (out, scratch2, constm1_rtx));
22832     }
22833   return true;
22834 }
22835
22836 /* For given symbol (function) construct code to compute address of it's PLT
22837    entry in large x86-64 PIC model.  */
22838 rtx
22839 construct_plt_address (rtx symbol)
22840 {
22841   rtx tmp = gen_reg_rtx (Pmode);
22842   rtx unspec = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, symbol), UNSPEC_PLTOFF);
22843
22844   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
22845   gcc_assert (ix86_cmodel == CM_LARGE_PIC);
22846
22847   emit_move_insn (tmp, gen_rtx_CONST (Pmode, unspec));
22848   emit_insn (gen_adddi3 (tmp, tmp, pic_offset_table_rtx));
22849   return tmp;
22850 }
22851
22852 rtx
22853 ix86_expand_call (rtx retval, rtx fnaddr, rtx callarg1,
22854                   rtx callarg2,
22855                   rtx pop, bool sibcall)
22856 {
22857   /* We need to represent that SI and DI registers are clobbered
22858      by SYSV calls.  */
22859   static int clobbered_registers[] = {
22860         XMM6_REG, XMM7_REG, XMM8_REG,
22861         XMM9_REG, XMM10_REG, XMM11_REG,
22862         XMM12_REG, XMM13_REG, XMM14_REG,
22863         XMM15_REG, SI_REG, DI_REG
22864   };
22865   rtx vec[ARRAY_SIZE (clobbered_registers) + 3];
22866   rtx use = NULL, call;
22867   unsigned int vec_len;
22868
22869   if (pop == const0_rtx)
22870     pop = NULL;
22871   gcc_assert (!TARGET_64BIT || !pop);
22872
22873   if (TARGET_MACHO && !TARGET_64BIT)
22874     {
22875 #if TARGET_MACHO
22876       if (flag_pic && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF)
22877         fnaddr = machopic_indirect_call_target (fnaddr);
22878 #endif
22879     }
22880   else
22881     {
22882       /* Static functions and indirect calls don't need the pic register.  */
22883       if (flag_pic && (!TARGET_64BIT || ix86_cmodel == CM_LARGE_PIC)
22884           && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
22885           && ! SYMBOL_REF_LOCAL_P (XEXP (fnaddr, 0)))
22886         use_reg (&use, pic_offset_table_rtx);
22887     }
22888
22889   if (TARGET_64BIT && INTVAL (callarg2) >= 0)
22890     {
22891       rtx al = gen_rtx_REG (QImode, AX_REG);
22892       emit_move_insn (al, callarg2);
22893       use_reg (&use, al);
22894     }
22895
22896   if (ix86_cmodel == CM_LARGE_PIC
22897       && MEM_P (fnaddr)
22898       && GET_CODE (XEXP (fnaddr, 0)) == SYMBOL_REF
22899       && !local_symbolic_operand (XEXP (fnaddr, 0), VOIDmode))
22900     fnaddr = gen_rtx_MEM (QImode, construct_plt_address (XEXP (fnaddr, 0)));
22901   else if (sibcall
22902            ? !sibcall_insn_operand (XEXP (fnaddr, 0), Pmode)
22903            : !call_insn_operand (XEXP (fnaddr, 0), Pmode))
22904     {
22905       fnaddr = XEXP (fnaddr, 0);
22906       if (GET_MODE (fnaddr) != Pmode)
22907         fnaddr = convert_to_mode (Pmode, fnaddr, 1);
22908       fnaddr = gen_rtx_MEM (QImode, copy_to_mode_reg (Pmode, fnaddr));
22909     }
22910
22911   vec_len = 0;
22912   call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
22913   if (retval)
22914     call = gen_rtx_SET (VOIDmode, retval, call);
22915   vec[vec_len++] = call;
22916
22917   if (pop)
22918     {
22919       pop = gen_rtx_PLUS (Pmode, stack_pointer_rtx, pop);
22920       pop = gen_rtx_SET (VOIDmode, stack_pointer_rtx, pop);
22921       vec[vec_len++] = pop;
22922     }
22923
22924   if (TARGET_64BIT_MS_ABI
22925       && (!callarg2 || INTVAL (callarg2) != -2))
22926     {
22927       unsigned i;
22928
22929       vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx),
22930                                        UNSPEC_MS_TO_SYSV_CALL);
22931
22932       for (i = 0; i < ARRAY_SIZE (clobbered_registers); i++)
22933         vec[vec_len++]
22934           = gen_rtx_CLOBBER (SSE_REGNO_P (clobbered_registers[i])
22935                              ? TImode : DImode,
22936                              gen_rtx_REG (SSE_REGNO_P (clobbered_registers[i])
22937                                           ? TImode : DImode,
22938                                           clobbered_registers[i]));
22939     }
22940
22941   /* Add UNSPEC_CALL_NEEDS_VZEROUPPER decoration.  */
22942   if (TARGET_VZEROUPPER)
22943     {
22944       int avx256;
22945       if (cfun->machine->callee_pass_avx256_p)
22946         {
22947           if (cfun->machine->callee_return_avx256_p)
22948             avx256 = callee_return_pass_avx256;
22949           else
22950             avx256 = callee_pass_avx256;
22951         }
22952       else if (cfun->machine->callee_return_avx256_p)
22953         avx256 = callee_return_avx256;
22954       else
22955         avx256 = call_no_avx256;
22956
22957       if (reload_completed)
22958         emit_insn (gen_avx_vzeroupper (GEN_INT (avx256)));
22959       else
22960         vec[vec_len++] = gen_rtx_UNSPEC (VOIDmode,
22961                                          gen_rtvec (1, GEN_INT (avx256)),
22962                                          UNSPEC_CALL_NEEDS_VZEROUPPER);
22963     }
22964
22965   if (vec_len > 1)
22966     call = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (vec_len, vec));
22967   call = emit_call_insn (call);
22968   if (use)
22969     CALL_INSN_FUNCTION_USAGE (call) = use;
22970
22971   return call;
22972 }
22973
22974 void
22975 ix86_split_call_vzeroupper (rtx insn, rtx vzeroupper)
22976 {
22977   rtx pat = PATTERN (insn);
22978   rtvec vec = XVEC (pat, 0);
22979   int len = GET_NUM_ELEM (vec) - 1;
22980
22981   /* Strip off the last entry of the parallel.  */
22982   gcc_assert (GET_CODE (RTVEC_ELT (vec, len)) == UNSPEC);
22983   gcc_assert (XINT (RTVEC_ELT (vec, len), 1) == UNSPEC_CALL_NEEDS_VZEROUPPER);
22984   if (len == 1)
22985     pat = RTVEC_ELT (vec, 0);
22986   else
22987     pat = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (len, &RTVEC_ELT (vec, 0)));
22988
22989   emit_insn (gen_avx_vzeroupper (vzeroupper));
22990   emit_call_insn (pat);
22991 }
22992
22993 /* Output the assembly for a call instruction.  */
22994
22995 const char *
22996 ix86_output_call_insn (rtx insn, rtx call_op)
22997 {
22998   bool direct_p = constant_call_address_operand (call_op, Pmode);
22999   bool seh_nop_p = false;
23000   const char *xasm;
23001
23002   if (SIBLING_CALL_P (insn))
23003     {
23004       if (direct_p)
23005         xasm = "jmp\t%P0";
23006       /* SEH epilogue detection requires the indirect branch case
23007          to include REX.W.  */
23008       else if (TARGET_SEH)
23009         xasm = "rex.W jmp %A0";
23010       else
23011         xasm = "jmp\t%A0";
23012
23013       output_asm_insn (xasm, &call_op);
23014       return "";
23015     }
23016
23017   /* SEH unwinding can require an extra nop to be emitted in several
23018      circumstances.  Determine if we have one of those.  */
23019   if (TARGET_SEH)
23020     {
23021       rtx i;
23022
23023       for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
23024         {
23025           /* If we get to another real insn, we don't need the nop.  */
23026           if (INSN_P (i))
23027             break;
23028
23029           /* If we get to the epilogue note, prevent a catch region from
23030              being adjacent to the standard epilogue sequence.  If non-
23031              call-exceptions, we'll have done this during epilogue emission. */
23032           if (NOTE_P (i) && NOTE_KIND (i) == NOTE_INSN_EPILOGUE_BEG
23033               && !flag_non_call_exceptions
23034               && !can_throw_internal (insn))
23035             {
23036               seh_nop_p = true;
23037               break;
23038             }
23039         }
23040
23041       /* If we didn't find a real insn following the call, prevent the
23042          unwinder from looking into the next function.  */
23043       if (i == NULL)
23044         seh_nop_p = true;
23045     }
23046
23047   if (direct_p)
23048     xasm = "call\t%P0";
23049   else
23050     xasm = "call\t%A0";
23051
23052   output_asm_insn (xasm, &call_op);
23053
23054   if (seh_nop_p)
23055     return "nop";
23056
23057   return "";
23058 }
23059 \f
23060 /* Clear stack slot assignments remembered from previous functions.
23061    This is called from INIT_EXPANDERS once before RTL is emitted for each
23062    function.  */
23063
23064 static struct machine_function *
23065 ix86_init_machine_status (void)
23066 {
23067   struct machine_function *f;
23068
23069   f = ggc_alloc_cleared_machine_function ();
23070   f->use_fast_prologue_epilogue_nregs = -1;
23071   f->tls_descriptor_call_expanded_p = 0;
23072   f->call_abi = ix86_abi;
23073
23074   return f;
23075 }
23076
23077 /* Return a MEM corresponding to a stack slot with mode MODE.
23078    Allocate a new slot if necessary.
23079
23080    The RTL for a function can have several slots available: N is
23081    which slot to use.  */
23082
23083 rtx
23084 assign_386_stack_local (enum machine_mode mode, enum ix86_stack_slot n)
23085 {
23086   struct stack_local_entry *s;
23087
23088   gcc_assert (n < MAX_386_STACK_LOCALS);
23089
23090   /* Virtual slot is valid only before vregs are instantiated.  */
23091   gcc_assert ((n == SLOT_VIRTUAL) == !virtuals_instantiated);
23092
23093   for (s = ix86_stack_locals; s; s = s->next)
23094     if (s->mode == mode && s->n == n)
23095       return validize_mem (copy_rtx (s->rtl));
23096
23097   s = ggc_alloc_stack_local_entry ();
23098   s->n = n;
23099   s->mode = mode;
23100   s->rtl = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
23101
23102   s->next = ix86_stack_locals;
23103   ix86_stack_locals = s;
23104   return validize_mem (s->rtl);
23105 }
23106 \f
23107 /* Calculate the length of the memory address in the instruction encoding.
23108    Includes addr32 prefix, does not include the one-byte modrm, opcode,
23109    or other prefixes.  */
23110
23111 int
23112 memory_address_length (rtx addr)
23113 {
23114   struct ix86_address parts;
23115   rtx base, index, disp;
23116   int len;
23117   int ok;
23118
23119   if (GET_CODE (addr) == PRE_DEC
23120       || GET_CODE (addr) == POST_INC
23121       || GET_CODE (addr) == PRE_MODIFY
23122       || GET_CODE (addr) == POST_MODIFY)
23123     return 0;
23124
23125   ok = ix86_decompose_address (addr, &parts);
23126   gcc_assert (ok);
23127
23128   if (parts.base && GET_CODE (parts.base) == SUBREG)
23129     parts.base = SUBREG_REG (parts.base);
23130   if (parts.index && GET_CODE (parts.index) == SUBREG)
23131     parts.index = SUBREG_REG (parts.index);
23132
23133   base = parts.base;
23134   index = parts.index;
23135   disp = parts.disp;
23136
23137   /* Add length of addr32 prefix.  */
23138   len = (GET_CODE (addr) == ZERO_EXTEND
23139          || GET_CODE (addr) == AND);
23140
23141   /* Rule of thumb:
23142        - esp as the base always wants an index,
23143        - ebp as the base always wants a displacement,
23144        - r12 as the base always wants an index,
23145        - r13 as the base always wants a displacement.  */
23146
23147   /* Register Indirect.  */
23148   if (base && !index && !disp)
23149     {
23150       /* esp (for its index) and ebp (for its displacement) need
23151          the two-byte modrm form.  Similarly for r12 and r13 in 64-bit
23152          code.  */
23153       if (REG_P (addr)
23154           && (addr == arg_pointer_rtx
23155               || addr == frame_pointer_rtx
23156               || REGNO (addr) == SP_REG
23157               || REGNO (addr) == BP_REG
23158               || REGNO (addr) == R12_REG
23159               || REGNO (addr) == R13_REG))
23160         len = 1;
23161     }
23162
23163   /* Direct Addressing.  In 64-bit mode mod 00 r/m 5
23164      is not disp32, but disp32(%rip), so for disp32
23165      SIB byte is needed, unless print_operand_address
23166      optimizes it into disp32(%rip) or (%rip) is implied
23167      by UNSPEC.  */
23168   else if (disp && !base && !index)
23169     {
23170       len = 4;
23171       if (TARGET_64BIT)
23172         {
23173           rtx symbol = disp;
23174
23175           if (GET_CODE (disp) == CONST)
23176             symbol = XEXP (disp, 0);
23177           if (GET_CODE (symbol) == PLUS
23178               && CONST_INT_P (XEXP (symbol, 1)))
23179             symbol = XEXP (symbol, 0);
23180
23181           if (GET_CODE (symbol) != LABEL_REF
23182               && (GET_CODE (symbol) != SYMBOL_REF
23183                   || SYMBOL_REF_TLS_MODEL (symbol) != 0)
23184               && (GET_CODE (symbol) != UNSPEC
23185                   || (XINT (symbol, 1) != UNSPEC_GOTPCREL
23186                       && XINT (symbol, 1) != UNSPEC_PCREL
23187                       && XINT (symbol, 1) != UNSPEC_GOTNTPOFF)))
23188             len += 1;
23189         }
23190     }
23191
23192   else
23193     {
23194       /* Find the length of the displacement constant.  */
23195       if (disp)
23196         {
23197           if (base && satisfies_constraint_K (disp))
23198             len = 1;
23199           else
23200             len = 4;
23201         }
23202       /* ebp always wants a displacement.  Similarly r13.  */
23203       else if (base && REG_P (base)
23204                && (REGNO (base) == BP_REG || REGNO (base) == R13_REG))
23205         len = 1;
23206
23207       /* An index requires the two-byte modrm form....  */
23208       if (index
23209           /* ...like esp (or r12), which always wants an index.  */
23210           || base == arg_pointer_rtx
23211           || base == frame_pointer_rtx
23212           || (base && REG_P (base)
23213               && (REGNO (base) == SP_REG || REGNO (base) == R12_REG)))
23214         len += 1;
23215     }
23216
23217   switch (parts.seg)
23218     {
23219     case SEG_FS:
23220     case SEG_GS:
23221       len += 1;
23222       break;
23223     default:
23224       break;
23225     }
23226
23227   return len;
23228 }
23229
23230 /* Compute default value for "length_immediate" attribute.  When SHORTFORM
23231    is set, expect that insn have 8bit immediate alternative.  */
23232 int
23233 ix86_attr_length_immediate_default (rtx insn, bool shortform)
23234 {
23235   int len = 0;
23236   int i;
23237   extract_insn_cached (insn);
23238   for (i = recog_data.n_operands - 1; i >= 0; --i)
23239     if (CONSTANT_P (recog_data.operand[i]))
23240       {
23241         enum attr_mode mode = get_attr_mode (insn);
23242
23243         gcc_assert (!len);
23244         if (shortform && CONST_INT_P (recog_data.operand[i]))
23245           {
23246             HOST_WIDE_INT ival = INTVAL (recog_data.operand[i]);
23247             switch (mode)
23248               {
23249               case MODE_QI:
23250                 len = 1;
23251                 continue;
23252               case MODE_HI:
23253                 ival = trunc_int_for_mode (ival, HImode);
23254                 break;
23255               case MODE_SI:
23256                 ival = trunc_int_for_mode (ival, SImode);
23257                 break;
23258               default:
23259                 break;
23260               }
23261             if (IN_RANGE (ival, -128, 127))
23262               {
23263                 len = 1;
23264                 continue;
23265               }
23266           }
23267         switch (mode)
23268           {
23269           case MODE_QI:
23270             len = 1;
23271             break;
23272           case MODE_HI:
23273             len = 2;
23274             break;
23275           case MODE_SI:
23276             len = 4;
23277             break;
23278           /* Immediates for DImode instructions are encoded as 32bit sign extended values.  */
23279           case MODE_DI:
23280             len = 4;
23281             break;
23282           default:
23283             fatal_insn ("unknown insn mode", insn);
23284         }
23285       }
23286   return len;
23287 }
23288 /* Compute default value for "length_address" attribute.  */
23289 int
23290 ix86_attr_length_address_default (rtx insn)
23291 {
23292   int i;
23293
23294   if (get_attr_type (insn) == TYPE_LEA)
23295     {
23296       rtx set = PATTERN (insn), addr;
23297
23298       if (GET_CODE (set) == PARALLEL)
23299         set = XVECEXP (set, 0, 0);
23300
23301       gcc_assert (GET_CODE (set) == SET);
23302
23303       addr = SET_SRC (set);
23304       if (TARGET_64BIT && get_attr_mode (insn) == MODE_SI)
23305         {
23306           if (GET_CODE (addr) == ZERO_EXTEND)
23307             addr = XEXP (addr, 0);
23308           if (GET_CODE (addr) == SUBREG)
23309             addr = SUBREG_REG (addr);
23310         }
23311
23312       return memory_address_length (addr);
23313     }
23314
23315   extract_insn_cached (insn);
23316   for (i = recog_data.n_operands - 1; i >= 0; --i)
23317     if (MEM_P (recog_data.operand[i]))
23318       {
23319         constrain_operands_cached (reload_completed);
23320         if (which_alternative != -1)
23321           {
23322             const char *constraints = recog_data.constraints[i];
23323             int alt = which_alternative;
23324
23325             while (*constraints == '=' || *constraints == '+')
23326               constraints++;
23327             while (alt-- > 0)
23328               while (*constraints++ != ',')
23329                 ;
23330             /* Skip ignored operands.  */
23331             if (*constraints == 'X')
23332               continue;
23333           }
23334         return memory_address_length (XEXP (recog_data.operand[i], 0));
23335       }
23336   return 0;
23337 }
23338
23339 /* Compute default value for "length_vex" attribute. It includes
23340    2 or 3 byte VEX prefix and 1 opcode byte.  */
23341
23342 int
23343 ix86_attr_length_vex_default (rtx insn, bool has_0f_opcode, bool has_vex_w)
23344 {
23345   int i;
23346
23347   /* Only 0f opcode can use 2 byte VEX prefix and  VEX W bit uses 3
23348      byte VEX prefix.  */
23349   if (!has_0f_opcode || has_vex_w)
23350     return 3 + 1;
23351
23352  /* We can always use 2 byte VEX prefix in 32bit.  */
23353   if (!TARGET_64BIT)
23354     return 2 + 1;
23355
23356   extract_insn_cached (insn);
23357
23358   for (i = recog_data.n_operands - 1; i >= 0; --i)
23359     if (REG_P (recog_data.operand[i]))
23360       {
23361         /* REX.W bit uses 3 byte VEX prefix.  */
23362         if (GET_MODE (recog_data.operand[i]) == DImode
23363             && GENERAL_REG_P (recog_data.operand[i]))
23364           return 3 + 1;
23365       }
23366     else
23367       {
23368         /* REX.X or REX.B bits use 3 byte VEX prefix.  */
23369         if (MEM_P (recog_data.operand[i])
23370             && x86_extended_reg_mentioned_p (recog_data.operand[i]))
23371           return 3 + 1;
23372       }
23373
23374   return 2 + 1;
23375 }
23376 \f
23377 /* Return the maximum number of instructions a cpu can issue.  */
23378
23379 static int
23380 ix86_issue_rate (void)
23381 {
23382   switch (ix86_tune)
23383     {
23384     case PROCESSOR_PENTIUM:
23385     case PROCESSOR_ATOM:
23386     case PROCESSOR_K6:
23387       return 2;
23388
23389     case PROCESSOR_PENTIUMPRO:
23390     case PROCESSOR_PENTIUM4:
23391     case PROCESSOR_CORE2_32:
23392     case PROCESSOR_CORE2_64:
23393     case PROCESSOR_COREI7_32:
23394     case PROCESSOR_COREI7_64:
23395     case PROCESSOR_ATHLON:
23396     case PROCESSOR_K8:
23397     case PROCESSOR_AMDFAM10:
23398     case PROCESSOR_NOCONA:
23399     case PROCESSOR_GENERIC32:
23400     case PROCESSOR_GENERIC64:
23401     case PROCESSOR_BDVER1:
23402     case PROCESSOR_BDVER2:
23403     case PROCESSOR_BTVER1:
23404       return 3;
23405
23406     default:
23407       return 1;
23408     }
23409 }
23410
23411 /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
23412    by DEP_INSN and nothing set by DEP_INSN.  */
23413
23414 static bool
23415 ix86_flags_dependent (rtx insn, rtx dep_insn, enum attr_type insn_type)
23416 {
23417   rtx set, set2;
23418
23419   /* Simplify the test for uninteresting insns.  */
23420   if (insn_type != TYPE_SETCC
23421       && insn_type != TYPE_ICMOV
23422       && insn_type != TYPE_FCMOV
23423       && insn_type != TYPE_IBR)
23424     return false;
23425
23426   if ((set = single_set (dep_insn)) != 0)
23427     {
23428       set = SET_DEST (set);
23429       set2 = NULL_RTX;
23430     }
23431   else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
23432            && XVECLEN (PATTERN (dep_insn), 0) == 2
23433            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
23434            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
23435     {
23436       set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
23437       set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
23438     }
23439   else
23440     return false;
23441
23442   if (!REG_P (set) || REGNO (set) != FLAGS_REG)
23443     return false;
23444
23445   /* This test is true if the dependent insn reads the flags but
23446      not any other potentially set register.  */
23447   if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
23448     return false;
23449
23450   if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
23451     return false;
23452
23453   return true;
23454 }
23455
23456 /* Return true iff USE_INSN has a memory address with operands set by
23457    SET_INSN.  */
23458
23459 bool
23460 ix86_agi_dependent (rtx set_insn, rtx use_insn)
23461 {
23462   int i;
23463   extract_insn_cached (use_insn);
23464   for (i = recog_data.n_operands - 1; i >= 0; --i)
23465     if (MEM_P (recog_data.operand[i]))
23466       {
23467         rtx addr = XEXP (recog_data.operand[i], 0);
23468         return modified_in_p (addr, set_insn) != 0;
23469       }
23470   return false;
23471 }
23472
23473 static int
23474 ix86_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
23475 {
23476   enum attr_type insn_type, dep_insn_type;
23477   enum attr_memory memory;
23478   rtx set, set2;
23479   int dep_insn_code_number;
23480
23481   /* Anti and output dependencies have zero cost on all CPUs.  */
23482   if (REG_NOTE_KIND (link) != 0)
23483     return 0;
23484
23485   dep_insn_code_number = recog_memoized (dep_insn);
23486
23487   /* If we can't recognize the insns, we can't really do anything.  */
23488   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
23489     return cost;
23490
23491   insn_type = get_attr_type (insn);
23492   dep_insn_type = get_attr_type (dep_insn);
23493
23494   switch (ix86_tune)
23495     {
23496     case PROCESSOR_PENTIUM:
23497       /* Address Generation Interlock adds a cycle of latency.  */
23498       if (insn_type == TYPE_LEA)
23499         {
23500           rtx addr = PATTERN (insn);
23501
23502           if (GET_CODE (addr) == PARALLEL)
23503             addr = XVECEXP (addr, 0, 0);
23504
23505           gcc_assert (GET_CODE (addr) == SET);
23506
23507           addr = SET_SRC (addr);
23508           if (modified_in_p (addr, dep_insn))
23509             cost += 1;
23510         }
23511       else if (ix86_agi_dependent (dep_insn, insn))
23512         cost += 1;
23513
23514       /* ??? Compares pair with jump/setcc.  */
23515       if (ix86_flags_dependent (insn, dep_insn, insn_type))
23516         cost = 0;
23517
23518       /* Floating point stores require value to be ready one cycle earlier.  */
23519       if (insn_type == TYPE_FMOV
23520           && get_attr_memory (insn) == MEMORY_STORE
23521           && !ix86_agi_dependent (dep_insn, insn))
23522         cost += 1;
23523       break;
23524
23525     case PROCESSOR_PENTIUMPRO:
23526       memory = get_attr_memory (insn);
23527
23528       /* INT->FP conversion is expensive.  */
23529       if (get_attr_fp_int_src (dep_insn))
23530         cost += 5;
23531
23532       /* There is one cycle extra latency between an FP op and a store.  */
23533       if (insn_type == TYPE_FMOV
23534           && (set = single_set (dep_insn)) != NULL_RTX
23535           && (set2 = single_set (insn)) != NULL_RTX
23536           && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
23537           && MEM_P (SET_DEST (set2)))
23538         cost += 1;
23539
23540       /* Show ability of reorder buffer to hide latency of load by executing
23541          in parallel with previous instruction in case
23542          previous instruction is not needed to compute the address.  */
23543       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
23544           && !ix86_agi_dependent (dep_insn, insn))
23545         {
23546           /* Claim moves to take one cycle, as core can issue one load
23547              at time and the next load can start cycle later.  */
23548           if (dep_insn_type == TYPE_IMOV
23549               || dep_insn_type == TYPE_FMOV)
23550             cost = 1;
23551           else if (cost > 1)
23552             cost--;
23553         }
23554       break;
23555
23556     case PROCESSOR_K6:
23557       memory = get_attr_memory (insn);
23558
23559       /* The esp dependency is resolved before the instruction is really
23560          finished.  */
23561       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
23562           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
23563         return 1;
23564
23565       /* INT->FP conversion is expensive.  */
23566       if (get_attr_fp_int_src (dep_insn))
23567         cost += 5;
23568
23569       /* Show ability of reorder buffer to hide latency of load by executing
23570          in parallel with previous instruction in case
23571          previous instruction is not needed to compute the address.  */
23572       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
23573           && !ix86_agi_dependent (dep_insn, insn))
23574         {
23575           /* Claim moves to take one cycle, as core can issue one load
23576              at time and the next load can start cycle later.  */
23577           if (dep_insn_type == TYPE_IMOV
23578               || dep_insn_type == TYPE_FMOV)
23579             cost = 1;
23580           else if (cost > 2)
23581             cost -= 2;
23582           else
23583             cost = 1;
23584         }
23585       break;
23586
23587     case PROCESSOR_ATHLON:
23588     case PROCESSOR_K8:
23589     case PROCESSOR_AMDFAM10:
23590     case PROCESSOR_BDVER1:
23591     case PROCESSOR_BDVER2:
23592     case PROCESSOR_BTVER1:
23593     case PROCESSOR_ATOM:
23594     case PROCESSOR_GENERIC32:
23595     case PROCESSOR_GENERIC64:
23596       memory = get_attr_memory (insn);
23597
23598       /* Show ability of reorder buffer to hide latency of load by executing
23599          in parallel with previous instruction in case
23600          previous instruction is not needed to compute the address.  */
23601       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
23602           && !ix86_agi_dependent (dep_insn, insn))
23603         {
23604           enum attr_unit unit = get_attr_unit (insn);
23605           int loadcost = 3;
23606
23607           /* Because of the difference between the length of integer and
23608              floating unit pipeline preparation stages, the memory operands
23609              for floating point are cheaper.
23610
23611              ??? For Athlon it the difference is most probably 2.  */
23612           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
23613             loadcost = 3;
23614           else
23615             loadcost = TARGET_ATHLON ? 2 : 0;
23616
23617           if (cost >= loadcost)
23618             cost -= loadcost;
23619           else
23620             cost = 0;
23621         }
23622
23623     default:
23624       break;
23625     }
23626
23627   return cost;
23628 }
23629
23630 /* How many alternative schedules to try.  This should be as wide as the
23631    scheduling freedom in the DFA, but no wider.  Making this value too
23632    large results extra work for the scheduler.  */
23633
23634 static int
23635 ia32_multipass_dfa_lookahead (void)
23636 {
23637   switch (ix86_tune)
23638     {
23639     case PROCESSOR_PENTIUM:
23640       return 2;
23641
23642     case PROCESSOR_PENTIUMPRO:
23643     case PROCESSOR_K6:
23644       return 1;
23645
23646     case PROCESSOR_CORE2_32:
23647     case PROCESSOR_CORE2_64:
23648     case PROCESSOR_COREI7_32:
23649     case PROCESSOR_COREI7_64:
23650       /* Generally, we want haifa-sched:max_issue() to look ahead as far
23651          as many instructions can be executed on a cycle, i.e.,
23652          issue_rate.  I wonder why tuning for many CPUs does not do this.  */
23653       return ix86_issue_rate ();
23654
23655     default:
23656       return 0;
23657     }
23658 }
23659
23660 \f
23661
23662 /* Model decoder of Core 2/i7.
23663    Below hooks for multipass scheduling (see haifa-sched.c:max_issue)
23664    track the instruction fetch block boundaries and make sure that long
23665    (9+ bytes) instructions are assigned to D0.  */
23666
23667 /* Maximum length of an insn that can be handled by
23668    a secondary decoder unit.  '8' for Core 2/i7.  */
23669 static int core2i7_secondary_decoder_max_insn_size;
23670
23671 /* Ifetch block size, i.e., number of bytes decoder reads per cycle.
23672    '16' for Core 2/i7.  */
23673 static int core2i7_ifetch_block_size;
23674
23675 /* Maximum number of instructions decoder can handle per cycle.
23676    '6' for Core 2/i7.  */
23677 static int core2i7_ifetch_block_max_insns;
23678
23679 typedef struct ix86_first_cycle_multipass_data_ *
23680   ix86_first_cycle_multipass_data_t;
23681 typedef const struct ix86_first_cycle_multipass_data_ *
23682   const_ix86_first_cycle_multipass_data_t;
23683
23684 /* A variable to store target state across calls to max_issue within
23685    one cycle.  */
23686 static struct ix86_first_cycle_multipass_data_ _ix86_first_cycle_multipass_data,
23687   *ix86_first_cycle_multipass_data = &_ix86_first_cycle_multipass_data;
23688
23689 /* Initialize DATA.  */
23690 static void
23691 core2i7_first_cycle_multipass_init (void *_data)
23692 {
23693   ix86_first_cycle_multipass_data_t data
23694     = (ix86_first_cycle_multipass_data_t) _data;
23695
23696   data->ifetch_block_len = 0;
23697   data->ifetch_block_n_insns = 0;
23698   data->ready_try_change = NULL;
23699   data->ready_try_change_size = 0;
23700 }
23701
23702 /* Advancing the cycle; reset ifetch block counts.  */
23703 static void
23704 core2i7_dfa_post_advance_cycle (void)
23705 {
23706   ix86_first_cycle_multipass_data_t data = ix86_first_cycle_multipass_data;
23707
23708   gcc_assert (data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
23709
23710   data->ifetch_block_len = 0;
23711   data->ifetch_block_n_insns = 0;
23712 }
23713
23714 static int min_insn_size (rtx);
23715
23716 /* Filter out insns from ready_try that the core will not be able to issue
23717    on current cycle due to decoder.  */
23718 static void
23719 core2i7_first_cycle_multipass_filter_ready_try
23720 (const_ix86_first_cycle_multipass_data_t data,
23721  char *ready_try, int n_ready, bool first_cycle_insn_p)
23722 {
23723   while (n_ready--)
23724     {
23725       rtx insn;
23726       int insn_size;
23727
23728       if (ready_try[n_ready])
23729         continue;
23730
23731       insn = get_ready_element (n_ready);
23732       insn_size = min_insn_size (insn);
23733
23734       if (/* If this is a too long an insn for a secondary decoder ...  */
23735           (!first_cycle_insn_p
23736            && insn_size > core2i7_secondary_decoder_max_insn_size)
23737           /* ... or it would not fit into the ifetch block ...  */
23738           || data->ifetch_block_len + insn_size > core2i7_ifetch_block_size
23739           /* ... or the decoder is full already ...  */
23740           || data->ifetch_block_n_insns + 1 > core2i7_ifetch_block_max_insns)
23741         /* ... mask the insn out.  */
23742         {
23743           ready_try[n_ready] = 1;
23744
23745           if (data->ready_try_change)
23746             SET_BIT (data->ready_try_change, n_ready);
23747         }
23748     }
23749 }
23750
23751 /* Prepare for a new round of multipass lookahead scheduling.  */
23752 static void
23753 core2i7_first_cycle_multipass_begin (void *_data, char *ready_try, int n_ready,
23754                                      bool first_cycle_insn_p)
23755 {
23756   ix86_first_cycle_multipass_data_t data
23757     = (ix86_first_cycle_multipass_data_t) _data;
23758   const_ix86_first_cycle_multipass_data_t prev_data
23759     = ix86_first_cycle_multipass_data;
23760
23761   /* Restore the state from the end of the previous round.  */
23762   data->ifetch_block_len = prev_data->ifetch_block_len;
23763   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns;
23764
23765   /* Filter instructions that cannot be issued on current cycle due to
23766      decoder restrictions.  */
23767   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
23768                                                   first_cycle_insn_p);
23769 }
23770
23771 /* INSN is being issued in current solution.  Account for its impact on
23772    the decoder model.  */
23773 static void
23774 core2i7_first_cycle_multipass_issue (void *_data, char *ready_try, int n_ready,
23775                                      rtx insn, const void *_prev_data)
23776 {
23777   ix86_first_cycle_multipass_data_t data
23778     = (ix86_first_cycle_multipass_data_t) _data;
23779   const_ix86_first_cycle_multipass_data_t prev_data
23780     = (const_ix86_first_cycle_multipass_data_t) _prev_data;
23781
23782   int insn_size = min_insn_size (insn);
23783
23784   data->ifetch_block_len = prev_data->ifetch_block_len + insn_size;
23785   data->ifetch_block_n_insns = prev_data->ifetch_block_n_insns + 1;
23786   gcc_assert (data->ifetch_block_len <= core2i7_ifetch_block_size
23787               && data->ifetch_block_n_insns <= core2i7_ifetch_block_max_insns);
23788
23789   /* Allocate or resize the bitmap for storing INSN's effect on ready_try.  */
23790   if (!data->ready_try_change)
23791     {
23792       data->ready_try_change = sbitmap_alloc (n_ready);
23793       data->ready_try_change_size = n_ready;
23794     }
23795   else if (data->ready_try_change_size < n_ready)
23796     {
23797       data->ready_try_change = sbitmap_resize (data->ready_try_change,
23798                                                n_ready, 0);
23799       data->ready_try_change_size = n_ready;
23800     }
23801   sbitmap_zero (data->ready_try_change);
23802
23803   /* Filter out insns from ready_try that the core will not be able to issue
23804      on current cycle due to decoder.  */
23805   core2i7_first_cycle_multipass_filter_ready_try (data, ready_try, n_ready,
23806                                                   false);
23807 }
23808
23809 /* Revert the effect on ready_try.  */
23810 static void
23811 core2i7_first_cycle_multipass_backtrack (const void *_data,
23812                                          char *ready_try,
23813                                          int n_ready ATTRIBUTE_UNUSED)
23814 {
23815   const_ix86_first_cycle_multipass_data_t data
23816     = (const_ix86_first_cycle_multipass_data_t) _data;
23817   unsigned int i = 0;
23818   sbitmap_iterator sbi;
23819
23820   gcc_assert (sbitmap_last_set_bit (data->ready_try_change) < n_ready);
23821   EXECUTE_IF_SET_IN_SBITMAP (data->ready_try_change, 0, i, sbi)
23822     {
23823       ready_try[i] = 0;
23824     }
23825 }
23826
23827 /* Save the result of multipass lookahead scheduling for the next round.  */
23828 static void
23829 core2i7_first_cycle_multipass_end (const void *_data)
23830 {
23831   const_ix86_first_cycle_multipass_data_t data
23832     = (const_ix86_first_cycle_multipass_data_t) _data;
23833   ix86_first_cycle_multipass_data_t next_data
23834     = ix86_first_cycle_multipass_data;
23835
23836   if (data != NULL)
23837     {
23838       next_data->ifetch_block_len = data->ifetch_block_len;
23839       next_data->ifetch_block_n_insns = data->ifetch_block_n_insns;
23840     }
23841 }
23842
23843 /* Deallocate target data.  */
23844 static void
23845 core2i7_first_cycle_multipass_fini (void *_data)
23846 {
23847   ix86_first_cycle_multipass_data_t data
23848     = (ix86_first_cycle_multipass_data_t) _data;
23849
23850   if (data->ready_try_change)
23851     {
23852       sbitmap_free (data->ready_try_change);
23853       data->ready_try_change = NULL;
23854       data->ready_try_change_size = 0;
23855     }
23856 }
23857
23858 /* Prepare for scheduling pass.  */
23859 static void
23860 ix86_sched_init_global (FILE *dump ATTRIBUTE_UNUSED,
23861                         int verbose ATTRIBUTE_UNUSED,
23862                         int max_uid ATTRIBUTE_UNUSED)
23863 {
23864   /* Install scheduling hooks for current CPU.  Some of these hooks are used
23865      in time-critical parts of the scheduler, so we only set them up when
23866      they are actually used.  */
23867   switch (ix86_tune)
23868     {
23869     case PROCESSOR_CORE2_32:
23870     case PROCESSOR_CORE2_64:
23871     case PROCESSOR_COREI7_32:
23872     case PROCESSOR_COREI7_64:
23873       targetm.sched.dfa_post_advance_cycle
23874         = core2i7_dfa_post_advance_cycle;
23875       targetm.sched.first_cycle_multipass_init
23876         = core2i7_first_cycle_multipass_init;
23877       targetm.sched.first_cycle_multipass_begin
23878         = core2i7_first_cycle_multipass_begin;
23879       targetm.sched.first_cycle_multipass_issue
23880         = core2i7_first_cycle_multipass_issue;
23881       targetm.sched.first_cycle_multipass_backtrack
23882         = core2i7_first_cycle_multipass_backtrack;
23883       targetm.sched.first_cycle_multipass_end
23884         = core2i7_first_cycle_multipass_end;
23885       targetm.sched.first_cycle_multipass_fini
23886         = core2i7_first_cycle_multipass_fini;
23887
23888       /* Set decoder parameters.  */
23889       core2i7_secondary_decoder_max_insn_size = 8;
23890       core2i7_ifetch_block_size = 16;
23891       core2i7_ifetch_block_max_insns = 6;
23892       break;
23893
23894     default:
23895       targetm.sched.dfa_post_advance_cycle = NULL;
23896       targetm.sched.first_cycle_multipass_init = NULL;
23897       targetm.sched.first_cycle_multipass_begin = NULL;
23898       targetm.sched.first_cycle_multipass_issue = NULL;
23899       targetm.sched.first_cycle_multipass_backtrack = NULL;
23900       targetm.sched.first_cycle_multipass_end = NULL;
23901       targetm.sched.first_cycle_multipass_fini = NULL;
23902       break;
23903     }
23904 }
23905
23906 \f
23907 /* Compute the alignment given to a constant that is being placed in memory.
23908    EXP is the constant and ALIGN is the alignment that the object would
23909    ordinarily have.
23910    The value of this function is used instead of that alignment to align
23911    the object.  */
23912
23913 int
23914 ix86_constant_alignment (tree exp, int align)
23915 {
23916   if (TREE_CODE (exp) == REAL_CST || TREE_CODE (exp) == VECTOR_CST
23917       || TREE_CODE (exp) == INTEGER_CST)
23918     {
23919       if (TYPE_MODE (TREE_TYPE (exp)) == DFmode && align < 64)
23920         return 64;
23921       else if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (exp))) && align < 128)
23922         return 128;
23923     }
23924   else if (!optimize_size && TREE_CODE (exp) == STRING_CST
23925            && TREE_STRING_LENGTH (exp) >= 31 && align < BITS_PER_WORD)
23926     return BITS_PER_WORD;
23927
23928   return align;
23929 }
23930
23931 /* Compute the alignment for a static variable.
23932    TYPE is the data type, and ALIGN is the alignment that
23933    the object would ordinarily have.  The value of this function is used
23934    instead of that alignment to align the object.  */
23935
23936 int
23937 ix86_data_alignment (tree type, int align)
23938 {
23939   int max_align = optimize_size ? BITS_PER_WORD : MIN (256, MAX_OFILE_ALIGNMENT);
23940
23941   if (AGGREGATE_TYPE_P (type)
23942       && TYPE_SIZE (type)
23943       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
23944       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align
23945           || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
23946       && align < max_align)
23947     align = max_align;
23948
23949   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
23950      to 16byte boundary.  */
23951   if (TARGET_64BIT)
23952     {
23953       if (AGGREGATE_TYPE_P (type)
23954            && TYPE_SIZE (type)
23955            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
23956            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 128
23957                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
23958         return 128;
23959     }
23960
23961   if (TREE_CODE (type) == ARRAY_TYPE)
23962     {
23963       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
23964         return 64;
23965       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
23966         return 128;
23967     }
23968   else if (TREE_CODE (type) == COMPLEX_TYPE)
23969     {
23970
23971       if (TYPE_MODE (type) == DCmode && align < 64)
23972         return 64;
23973       if ((TYPE_MODE (type) == XCmode
23974            || TYPE_MODE (type) == TCmode) && align < 128)
23975         return 128;
23976     }
23977   else if ((TREE_CODE (type) == RECORD_TYPE
23978             || TREE_CODE (type) == UNION_TYPE
23979             || TREE_CODE (type) == QUAL_UNION_TYPE)
23980            && TYPE_FIELDS (type))
23981     {
23982       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
23983         return 64;
23984       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
23985         return 128;
23986     }
23987   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
23988            || TREE_CODE (type) == INTEGER_TYPE)
23989     {
23990       if (TYPE_MODE (type) == DFmode && align < 64)
23991         return 64;
23992       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
23993         return 128;
23994     }
23995
23996   return align;
23997 }
23998
23999 /* Compute the alignment for a local variable or a stack slot.  EXP is
24000    the data type or decl itself, MODE is the widest mode available and
24001    ALIGN is the alignment that the object would ordinarily have.  The
24002    value of this macro is used instead of that alignment to align the
24003    object.  */
24004
24005 unsigned int
24006 ix86_local_alignment (tree exp, enum machine_mode mode,
24007                       unsigned int align)
24008 {
24009   tree type, decl;
24010
24011   if (exp && DECL_P (exp))
24012     {
24013       type = TREE_TYPE (exp);
24014       decl = exp;
24015     }
24016   else
24017     {
24018       type = exp;
24019       decl = NULL;
24020     }
24021
24022   /* Don't do dynamic stack realignment for long long objects with
24023      -mpreferred-stack-boundary=2.  */
24024   if (!TARGET_64BIT
24025       && align == 64
24026       && ix86_preferred_stack_boundary < 64
24027       && (mode == DImode || (type && TYPE_MODE (type) == DImode))
24028       && (!type || !TYPE_USER_ALIGN (type))
24029       && (!decl || !DECL_USER_ALIGN (decl)))
24030     align = 32;
24031
24032   /* If TYPE is NULL, we are allocating a stack slot for caller-save
24033      register in MODE.  We will return the largest alignment of XF
24034      and DF.  */
24035   if (!type)
24036     {
24037       if (mode == XFmode && align < GET_MODE_ALIGNMENT (DFmode))
24038         align = GET_MODE_ALIGNMENT (DFmode);
24039       return align;
24040     }
24041
24042   /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
24043      to 16byte boundary.  Exact wording is:
24044
24045      An array uses the same alignment as its elements, except that a local or
24046      global array variable of length at least 16 bytes or
24047      a C99 variable-length array variable always has alignment of at least 16 bytes.
24048
24049      This was added to allow use of aligned SSE instructions at arrays.  This
24050      rule is meant for static storage (where compiler can not do the analysis
24051      by itself).  We follow it for automatic variables only when convenient.
24052      We fully control everything in the function compiled and functions from
24053      other unit can not rely on the alignment.
24054
24055      Exclude va_list type.  It is the common case of local array where
24056      we can not benefit from the alignment.  */
24057   if (TARGET_64BIT && optimize_function_for_speed_p (cfun)
24058       && TARGET_SSE)
24059     {
24060       if (AGGREGATE_TYPE_P (type)
24061            && (va_list_type_node == NULL_TREE
24062                || (TYPE_MAIN_VARIANT (type)
24063                    != TYPE_MAIN_VARIANT (va_list_type_node)))
24064            && TYPE_SIZE (type)
24065            && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
24066            && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 16
24067                || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 128)
24068         return 128;
24069     }
24070   if (TREE_CODE (type) == ARRAY_TYPE)
24071     {
24072       if (TYPE_MODE (TREE_TYPE (type)) == DFmode && align < 64)
24073         return 64;
24074       if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (type))) && align < 128)
24075         return 128;
24076     }
24077   else if (TREE_CODE (type) == COMPLEX_TYPE)
24078     {
24079       if (TYPE_MODE (type) == DCmode && align < 64)
24080         return 64;
24081       if ((TYPE_MODE (type) == XCmode
24082            || TYPE_MODE (type) == TCmode) && align < 128)
24083         return 128;
24084     }
24085   else if ((TREE_CODE (type) == RECORD_TYPE
24086             || TREE_CODE (type) == UNION_TYPE
24087             || TREE_CODE (type) == QUAL_UNION_TYPE)
24088            && TYPE_FIELDS (type))
24089     {
24090       if (DECL_MODE (TYPE_FIELDS (type)) == DFmode && align < 64)
24091         return 64;
24092       if (ALIGN_MODE_128 (DECL_MODE (TYPE_FIELDS (type))) && align < 128)
24093         return 128;
24094     }
24095   else if (TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == VECTOR_TYPE
24096            || TREE_CODE (type) == INTEGER_TYPE)
24097     {
24098
24099       if (TYPE_MODE (type) == DFmode && align < 64)
24100         return 64;
24101       if (ALIGN_MODE_128 (TYPE_MODE (type)) && align < 128)
24102         return 128;
24103     }
24104   return align;
24105 }
24106
24107 /* Compute the minimum required alignment for dynamic stack realignment
24108    purposes for a local variable, parameter or a stack slot.  EXP is
24109    the data type or decl itself, MODE is its mode and ALIGN is the
24110    alignment that the object would ordinarily have.  */
24111
24112 unsigned int
24113 ix86_minimum_alignment (tree exp, enum machine_mode mode,
24114                         unsigned int align)
24115 {
24116   tree type, decl;
24117
24118   if (exp && DECL_P (exp))
24119     {
24120       type = TREE_TYPE (exp);
24121       decl = exp;
24122     }
24123   else
24124     {
24125       type = exp;
24126       decl = NULL;
24127     }
24128
24129   if (TARGET_64BIT || align != 64 || ix86_preferred_stack_boundary >= 64)
24130     return align;
24131
24132   /* Don't do dynamic stack realignment for long long objects with
24133      -mpreferred-stack-boundary=2.  */
24134   if ((mode == DImode || (type && TYPE_MODE (type) == DImode))
24135       && (!type || !TYPE_USER_ALIGN (type))
24136       && (!decl || !DECL_USER_ALIGN (decl)))
24137     return 32;
24138
24139   return align;
24140 }
24141 \f
24142 /* Find a location for the static chain incoming to a nested function.
24143    This is a register, unless all free registers are used by arguments.  */
24144
24145 static rtx
24146 ix86_static_chain (const_tree fndecl, bool incoming_p)
24147 {
24148   unsigned regno;
24149
24150   if (!DECL_STATIC_CHAIN (fndecl))
24151     return NULL;
24152
24153   if (TARGET_64BIT)
24154     {
24155       /* We always use R10 in 64-bit mode.  */
24156       regno = R10_REG;
24157     }
24158   else
24159     {
24160       tree fntype;
24161       unsigned int ccvt;
24162
24163       /* By default in 32-bit mode we use ECX to pass the static chain.  */
24164       regno = CX_REG;
24165
24166       fntype = TREE_TYPE (fndecl);
24167       ccvt = ix86_get_callcvt (fntype);
24168       if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
24169         {
24170           /* Fastcall functions use ecx/edx for arguments, which leaves
24171              us with EAX for the static chain.
24172              Thiscall functions use ecx for arguments, which also
24173              leaves us with EAX for the static chain.  */
24174           regno = AX_REG;
24175         }
24176       else if (ix86_function_regparm (fntype, fndecl) == 3)
24177         {
24178           /* For regparm 3, we have no free call-clobbered registers in
24179              which to store the static chain.  In order to implement this,
24180              we have the trampoline push the static chain to the stack.
24181              However, we can't push a value below the return address when
24182              we call the nested function directly, so we have to use an
24183              alternate entry point.  For this we use ESI, and have the
24184              alternate entry point push ESI, so that things appear the
24185              same once we're executing the nested function.  */
24186           if (incoming_p)
24187             {
24188               if (fndecl == current_function_decl)
24189                 ix86_static_chain_on_stack = true;
24190               return gen_frame_mem (SImode,
24191                                     plus_constant (arg_pointer_rtx, -8));
24192             }
24193           regno = SI_REG;
24194         }
24195     }
24196
24197   return gen_rtx_REG (Pmode, regno);
24198 }
24199
24200 /* Emit RTL insns to initialize the variable parts of a trampoline.
24201    FNDECL is the decl of the target address; M_TRAMP is a MEM for
24202    the trampoline, and CHAIN_VALUE is an RTX for the static chain
24203    to be passed to the target function.  */
24204
24205 static void
24206 ix86_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
24207 {
24208   rtx mem, fnaddr;
24209   int opcode;
24210   int offset = 0;
24211
24212   fnaddr = XEXP (DECL_RTL (fndecl), 0);
24213
24214   if (TARGET_64BIT)
24215     {
24216       int size;
24217
24218       /* Load the function address to r11.  Try to load address using
24219          the shorter movl instead of movabs.  We may want to support
24220          movq for kernel mode, but kernel does not use trampolines at
24221          the moment.  */
24222       if (x86_64_zext_immediate_operand (fnaddr, VOIDmode))
24223         {
24224           fnaddr = copy_to_mode_reg (DImode, fnaddr);
24225
24226           mem = adjust_address (m_tramp, HImode, offset);
24227           emit_move_insn (mem, gen_int_mode (0xbb41, HImode));
24228
24229           mem = adjust_address (m_tramp, SImode, offset + 2);
24230           emit_move_insn (mem, gen_lowpart (SImode, fnaddr));
24231           offset += 6;
24232         }
24233       else
24234         {
24235           mem = adjust_address (m_tramp, HImode, offset);
24236           emit_move_insn (mem, gen_int_mode (0xbb49, HImode));
24237
24238           mem = adjust_address (m_tramp, DImode, offset + 2);
24239           emit_move_insn (mem, fnaddr);
24240           offset += 10;
24241         }
24242
24243       /* Load static chain using movabs to r10.  Use the
24244          shorter movl instead of movabs for x32.  */
24245       if (TARGET_X32)
24246         {
24247           opcode = 0xba41;
24248           size = 6;
24249         }
24250       else
24251         {
24252           opcode = 0xba49;
24253           size = 10;
24254         }
24255
24256       mem = adjust_address (m_tramp, HImode, offset);
24257       emit_move_insn (mem, gen_int_mode (opcode, HImode));
24258
24259       mem = adjust_address (m_tramp, ptr_mode, offset + 2);
24260       emit_move_insn (mem, chain_value);
24261       offset += size;
24262
24263       /* Jump to r11; the last (unused) byte is a nop, only there to
24264          pad the write out to a single 32-bit store.  */
24265       mem = adjust_address (m_tramp, SImode, offset);
24266       emit_move_insn (mem, gen_int_mode (0x90e3ff49, SImode));
24267       offset += 4;
24268     }
24269   else
24270     {
24271       rtx disp, chain;
24272
24273       /* Depending on the static chain location, either load a register
24274          with a constant, or push the constant to the stack.  All of the
24275          instructions are the same size.  */
24276       chain = ix86_static_chain (fndecl, true);
24277       if (REG_P (chain))
24278         {
24279           switch (REGNO (chain))
24280             {
24281             case AX_REG:
24282               opcode = 0xb8; break;
24283             case CX_REG:
24284               opcode = 0xb9; break;
24285             default:
24286               gcc_unreachable ();
24287             }
24288         }
24289       else
24290         opcode = 0x68;
24291
24292       mem = adjust_address (m_tramp, QImode, offset);
24293       emit_move_insn (mem, gen_int_mode (opcode, QImode));
24294
24295       mem = adjust_address (m_tramp, SImode, offset + 1);
24296       emit_move_insn (mem, chain_value);
24297       offset += 5;
24298
24299       mem = adjust_address (m_tramp, QImode, offset);
24300       emit_move_insn (mem, gen_int_mode (0xe9, QImode));
24301
24302       mem = adjust_address (m_tramp, SImode, offset + 1);
24303
24304       /* Compute offset from the end of the jmp to the target function.
24305          In the case in which the trampoline stores the static chain on
24306          the stack, we need to skip the first insn which pushes the
24307          (call-saved) register static chain; this push is 1 byte.  */
24308       offset += 5;
24309       disp = expand_binop (SImode, sub_optab, fnaddr,
24310                            plus_constant (XEXP (m_tramp, 0),
24311                                           offset - (MEM_P (chain) ? 1 : 0)),
24312                            NULL_RTX, 1, OPTAB_DIRECT);
24313       emit_move_insn (mem, disp);
24314     }
24315
24316   gcc_assert (offset <= TRAMPOLINE_SIZE);
24317
24318 #ifdef HAVE_ENABLE_EXECUTE_STACK
24319 #ifdef CHECK_EXECUTE_STACK_ENABLED
24320   if (CHECK_EXECUTE_STACK_ENABLED)
24321 #endif
24322   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
24323                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
24324 #endif
24325 }
24326 \f
24327 /* The following file contains several enumerations and data structures
24328    built from the definitions in i386-builtin-types.def.  */
24329
24330 #include "i386-builtin-types.inc"
24331
24332 /* Table for the ix86 builtin non-function types.  */
24333 static GTY(()) tree ix86_builtin_type_tab[(int) IX86_BT_LAST_CPTR + 1];
24334
24335 /* Retrieve an element from the above table, building some of
24336    the types lazily.  */
24337
24338 static tree
24339 ix86_get_builtin_type (enum ix86_builtin_type tcode)
24340 {
24341   unsigned int index;
24342   tree type, itype;
24343
24344   gcc_assert ((unsigned)tcode < ARRAY_SIZE(ix86_builtin_type_tab));
24345
24346   type = ix86_builtin_type_tab[(int) tcode];
24347   if (type != NULL)
24348     return type;
24349
24350   gcc_assert (tcode > IX86_BT_LAST_PRIM);
24351   if (tcode <= IX86_BT_LAST_VECT)
24352     {
24353       enum machine_mode mode;
24354
24355       index = tcode - IX86_BT_LAST_PRIM - 1;
24356       itype = ix86_get_builtin_type (ix86_builtin_type_vect_base[index]);
24357       mode = ix86_builtin_type_vect_mode[index];
24358
24359       type = build_vector_type_for_mode (itype, mode);
24360     }
24361   else
24362     {
24363       int quals;
24364
24365       index = tcode - IX86_BT_LAST_VECT - 1;
24366       if (tcode <= IX86_BT_LAST_PTR)
24367         quals = TYPE_UNQUALIFIED;
24368       else
24369         quals = TYPE_QUAL_CONST;
24370
24371       itype = ix86_get_builtin_type (ix86_builtin_type_ptr_base[index]);
24372       if (quals != TYPE_UNQUALIFIED)
24373         itype = build_qualified_type (itype, quals);
24374
24375       type = build_pointer_type (itype);
24376     }
24377
24378   ix86_builtin_type_tab[(int) tcode] = type;
24379   return type;
24380 }
24381
24382 /* Table for the ix86 builtin function types.  */
24383 static GTY(()) tree ix86_builtin_func_type_tab[(int) IX86_BT_LAST_ALIAS + 1];
24384
24385 /* Retrieve an element from the above table, building some of
24386    the types lazily.  */
24387
24388 static tree
24389 ix86_get_builtin_func_type (enum ix86_builtin_func_type tcode)
24390 {
24391   tree type;
24392
24393   gcc_assert ((unsigned)tcode < ARRAY_SIZE (ix86_builtin_func_type_tab));
24394
24395   type = ix86_builtin_func_type_tab[(int) tcode];
24396   if (type != NULL)
24397     return type;
24398
24399   if (tcode <= IX86_BT_LAST_FUNC)
24400     {
24401       unsigned start = ix86_builtin_func_start[(int) tcode];
24402       unsigned after = ix86_builtin_func_start[(int) tcode + 1];
24403       tree rtype, atype, args = void_list_node;
24404       unsigned i;
24405
24406       rtype = ix86_get_builtin_type (ix86_builtin_func_args[start]);
24407       for (i = after - 1; i > start; --i)
24408         {
24409           atype = ix86_get_builtin_type (ix86_builtin_func_args[i]);
24410           args = tree_cons (NULL, atype, args);
24411         }
24412
24413       type = build_function_type (rtype, args);
24414     }
24415   else
24416     {
24417       unsigned index = tcode - IX86_BT_LAST_FUNC - 1;
24418       enum ix86_builtin_func_type icode;
24419
24420       icode = ix86_builtin_func_alias_base[index];
24421       type = ix86_get_builtin_func_type (icode);
24422     }
24423
24424   ix86_builtin_func_type_tab[(int) tcode] = type;
24425   return type;
24426 }
24427
24428
24429 /* Codes for all the SSE/MMX builtins.  */
24430 enum ix86_builtins
24431 {
24432   IX86_BUILTIN_ADDPS,
24433   IX86_BUILTIN_ADDSS,
24434   IX86_BUILTIN_DIVPS,
24435   IX86_BUILTIN_DIVSS,
24436   IX86_BUILTIN_MULPS,
24437   IX86_BUILTIN_MULSS,
24438   IX86_BUILTIN_SUBPS,
24439   IX86_BUILTIN_SUBSS,
24440
24441   IX86_BUILTIN_CMPEQPS,
24442   IX86_BUILTIN_CMPLTPS,
24443   IX86_BUILTIN_CMPLEPS,
24444   IX86_BUILTIN_CMPGTPS,
24445   IX86_BUILTIN_CMPGEPS,
24446   IX86_BUILTIN_CMPNEQPS,
24447   IX86_BUILTIN_CMPNLTPS,
24448   IX86_BUILTIN_CMPNLEPS,
24449   IX86_BUILTIN_CMPNGTPS,
24450   IX86_BUILTIN_CMPNGEPS,
24451   IX86_BUILTIN_CMPORDPS,
24452   IX86_BUILTIN_CMPUNORDPS,
24453   IX86_BUILTIN_CMPEQSS,
24454   IX86_BUILTIN_CMPLTSS,
24455   IX86_BUILTIN_CMPLESS,
24456   IX86_BUILTIN_CMPNEQSS,
24457   IX86_BUILTIN_CMPNLTSS,
24458   IX86_BUILTIN_CMPNLESS,
24459   IX86_BUILTIN_CMPNGTSS,
24460   IX86_BUILTIN_CMPNGESS,
24461   IX86_BUILTIN_CMPORDSS,
24462   IX86_BUILTIN_CMPUNORDSS,
24463
24464   IX86_BUILTIN_COMIEQSS,
24465   IX86_BUILTIN_COMILTSS,
24466   IX86_BUILTIN_COMILESS,
24467   IX86_BUILTIN_COMIGTSS,
24468   IX86_BUILTIN_COMIGESS,
24469   IX86_BUILTIN_COMINEQSS,
24470   IX86_BUILTIN_UCOMIEQSS,
24471   IX86_BUILTIN_UCOMILTSS,
24472   IX86_BUILTIN_UCOMILESS,
24473   IX86_BUILTIN_UCOMIGTSS,
24474   IX86_BUILTIN_UCOMIGESS,
24475   IX86_BUILTIN_UCOMINEQSS,
24476
24477   IX86_BUILTIN_CVTPI2PS,
24478   IX86_BUILTIN_CVTPS2PI,
24479   IX86_BUILTIN_CVTSI2SS,
24480   IX86_BUILTIN_CVTSI642SS,
24481   IX86_BUILTIN_CVTSS2SI,
24482   IX86_BUILTIN_CVTSS2SI64,
24483   IX86_BUILTIN_CVTTPS2PI,
24484   IX86_BUILTIN_CVTTSS2SI,
24485   IX86_BUILTIN_CVTTSS2SI64,
24486
24487   IX86_BUILTIN_MAXPS,
24488   IX86_BUILTIN_MAXSS,
24489   IX86_BUILTIN_MINPS,
24490   IX86_BUILTIN_MINSS,
24491
24492   IX86_BUILTIN_LOADUPS,
24493   IX86_BUILTIN_STOREUPS,
24494   IX86_BUILTIN_MOVSS,
24495
24496   IX86_BUILTIN_MOVHLPS,
24497   IX86_BUILTIN_MOVLHPS,
24498   IX86_BUILTIN_LOADHPS,
24499   IX86_BUILTIN_LOADLPS,
24500   IX86_BUILTIN_STOREHPS,
24501   IX86_BUILTIN_STORELPS,
24502
24503   IX86_BUILTIN_MASKMOVQ,
24504   IX86_BUILTIN_MOVMSKPS,
24505   IX86_BUILTIN_PMOVMSKB,
24506
24507   IX86_BUILTIN_MOVNTPS,
24508   IX86_BUILTIN_MOVNTQ,
24509
24510   IX86_BUILTIN_LOADDQU,
24511   IX86_BUILTIN_STOREDQU,
24512
24513   IX86_BUILTIN_PACKSSWB,
24514   IX86_BUILTIN_PACKSSDW,
24515   IX86_BUILTIN_PACKUSWB,
24516
24517   IX86_BUILTIN_PADDB,
24518   IX86_BUILTIN_PADDW,
24519   IX86_BUILTIN_PADDD,
24520   IX86_BUILTIN_PADDQ,
24521   IX86_BUILTIN_PADDSB,
24522   IX86_BUILTIN_PADDSW,
24523   IX86_BUILTIN_PADDUSB,
24524   IX86_BUILTIN_PADDUSW,
24525   IX86_BUILTIN_PSUBB,
24526   IX86_BUILTIN_PSUBW,
24527   IX86_BUILTIN_PSUBD,
24528   IX86_BUILTIN_PSUBQ,
24529   IX86_BUILTIN_PSUBSB,
24530   IX86_BUILTIN_PSUBSW,
24531   IX86_BUILTIN_PSUBUSB,
24532   IX86_BUILTIN_PSUBUSW,
24533
24534   IX86_BUILTIN_PAND,
24535   IX86_BUILTIN_PANDN,
24536   IX86_BUILTIN_POR,
24537   IX86_BUILTIN_PXOR,
24538
24539   IX86_BUILTIN_PAVGB,
24540   IX86_BUILTIN_PAVGW,
24541
24542   IX86_BUILTIN_PCMPEQB,
24543   IX86_BUILTIN_PCMPEQW,
24544   IX86_BUILTIN_PCMPEQD,
24545   IX86_BUILTIN_PCMPGTB,
24546   IX86_BUILTIN_PCMPGTW,
24547   IX86_BUILTIN_PCMPGTD,
24548
24549   IX86_BUILTIN_PMADDWD,
24550
24551   IX86_BUILTIN_PMAXSW,
24552   IX86_BUILTIN_PMAXUB,
24553   IX86_BUILTIN_PMINSW,
24554   IX86_BUILTIN_PMINUB,
24555
24556   IX86_BUILTIN_PMULHUW,
24557   IX86_BUILTIN_PMULHW,
24558   IX86_BUILTIN_PMULLW,
24559
24560   IX86_BUILTIN_PSADBW,
24561   IX86_BUILTIN_PSHUFW,
24562
24563   IX86_BUILTIN_PSLLW,
24564   IX86_BUILTIN_PSLLD,
24565   IX86_BUILTIN_PSLLQ,
24566   IX86_BUILTIN_PSRAW,
24567   IX86_BUILTIN_PSRAD,
24568   IX86_BUILTIN_PSRLW,
24569   IX86_BUILTIN_PSRLD,
24570   IX86_BUILTIN_PSRLQ,
24571   IX86_BUILTIN_PSLLWI,
24572   IX86_BUILTIN_PSLLDI,
24573   IX86_BUILTIN_PSLLQI,
24574   IX86_BUILTIN_PSRAWI,
24575   IX86_BUILTIN_PSRADI,
24576   IX86_BUILTIN_PSRLWI,
24577   IX86_BUILTIN_PSRLDI,
24578   IX86_BUILTIN_PSRLQI,
24579
24580   IX86_BUILTIN_PUNPCKHBW,
24581   IX86_BUILTIN_PUNPCKHWD,
24582   IX86_BUILTIN_PUNPCKHDQ,
24583   IX86_BUILTIN_PUNPCKLBW,
24584   IX86_BUILTIN_PUNPCKLWD,
24585   IX86_BUILTIN_PUNPCKLDQ,
24586
24587   IX86_BUILTIN_SHUFPS,
24588
24589   IX86_BUILTIN_RCPPS,
24590   IX86_BUILTIN_RCPSS,
24591   IX86_BUILTIN_RSQRTPS,
24592   IX86_BUILTIN_RSQRTPS_NR,
24593   IX86_BUILTIN_RSQRTSS,
24594   IX86_BUILTIN_RSQRTF,
24595   IX86_BUILTIN_SQRTPS,
24596   IX86_BUILTIN_SQRTPS_NR,
24597   IX86_BUILTIN_SQRTSS,
24598
24599   IX86_BUILTIN_UNPCKHPS,
24600   IX86_BUILTIN_UNPCKLPS,
24601
24602   IX86_BUILTIN_ANDPS,
24603   IX86_BUILTIN_ANDNPS,
24604   IX86_BUILTIN_ORPS,
24605   IX86_BUILTIN_XORPS,
24606
24607   IX86_BUILTIN_EMMS,
24608   IX86_BUILTIN_LDMXCSR,
24609   IX86_BUILTIN_STMXCSR,
24610   IX86_BUILTIN_SFENCE,
24611
24612   /* 3DNow! Original */
24613   IX86_BUILTIN_FEMMS,
24614   IX86_BUILTIN_PAVGUSB,
24615   IX86_BUILTIN_PF2ID,
24616   IX86_BUILTIN_PFACC,
24617   IX86_BUILTIN_PFADD,
24618   IX86_BUILTIN_PFCMPEQ,
24619   IX86_BUILTIN_PFCMPGE,
24620   IX86_BUILTIN_PFCMPGT,
24621   IX86_BUILTIN_PFMAX,
24622   IX86_BUILTIN_PFMIN,
24623   IX86_BUILTIN_PFMUL,
24624   IX86_BUILTIN_PFRCP,
24625   IX86_BUILTIN_PFRCPIT1,
24626   IX86_BUILTIN_PFRCPIT2,
24627   IX86_BUILTIN_PFRSQIT1,
24628   IX86_BUILTIN_PFRSQRT,
24629   IX86_BUILTIN_PFSUB,
24630   IX86_BUILTIN_PFSUBR,
24631   IX86_BUILTIN_PI2FD,
24632   IX86_BUILTIN_PMULHRW,
24633
24634   /* 3DNow! Athlon Extensions */
24635   IX86_BUILTIN_PF2IW,
24636   IX86_BUILTIN_PFNACC,
24637   IX86_BUILTIN_PFPNACC,
24638   IX86_BUILTIN_PI2FW,
24639   IX86_BUILTIN_PSWAPDSI,
24640   IX86_BUILTIN_PSWAPDSF,
24641
24642   /* SSE2 */
24643   IX86_BUILTIN_ADDPD,
24644   IX86_BUILTIN_ADDSD,
24645   IX86_BUILTIN_DIVPD,
24646   IX86_BUILTIN_DIVSD,
24647   IX86_BUILTIN_MULPD,
24648   IX86_BUILTIN_MULSD,
24649   IX86_BUILTIN_SUBPD,
24650   IX86_BUILTIN_SUBSD,
24651
24652   IX86_BUILTIN_CMPEQPD,
24653   IX86_BUILTIN_CMPLTPD,
24654   IX86_BUILTIN_CMPLEPD,
24655   IX86_BUILTIN_CMPGTPD,
24656   IX86_BUILTIN_CMPGEPD,
24657   IX86_BUILTIN_CMPNEQPD,
24658   IX86_BUILTIN_CMPNLTPD,
24659   IX86_BUILTIN_CMPNLEPD,
24660   IX86_BUILTIN_CMPNGTPD,
24661   IX86_BUILTIN_CMPNGEPD,
24662   IX86_BUILTIN_CMPORDPD,
24663   IX86_BUILTIN_CMPUNORDPD,
24664   IX86_BUILTIN_CMPEQSD,
24665   IX86_BUILTIN_CMPLTSD,
24666   IX86_BUILTIN_CMPLESD,
24667   IX86_BUILTIN_CMPNEQSD,
24668   IX86_BUILTIN_CMPNLTSD,
24669   IX86_BUILTIN_CMPNLESD,
24670   IX86_BUILTIN_CMPORDSD,
24671   IX86_BUILTIN_CMPUNORDSD,
24672
24673   IX86_BUILTIN_COMIEQSD,
24674   IX86_BUILTIN_COMILTSD,
24675   IX86_BUILTIN_COMILESD,
24676   IX86_BUILTIN_COMIGTSD,
24677   IX86_BUILTIN_COMIGESD,
24678   IX86_BUILTIN_COMINEQSD,
24679   IX86_BUILTIN_UCOMIEQSD,
24680   IX86_BUILTIN_UCOMILTSD,
24681   IX86_BUILTIN_UCOMILESD,
24682   IX86_BUILTIN_UCOMIGTSD,
24683   IX86_BUILTIN_UCOMIGESD,
24684   IX86_BUILTIN_UCOMINEQSD,
24685
24686   IX86_BUILTIN_MAXPD,
24687   IX86_BUILTIN_MAXSD,
24688   IX86_BUILTIN_MINPD,
24689   IX86_BUILTIN_MINSD,
24690
24691   IX86_BUILTIN_ANDPD,
24692   IX86_BUILTIN_ANDNPD,
24693   IX86_BUILTIN_ORPD,
24694   IX86_BUILTIN_XORPD,
24695
24696   IX86_BUILTIN_SQRTPD,
24697   IX86_BUILTIN_SQRTSD,
24698
24699   IX86_BUILTIN_UNPCKHPD,
24700   IX86_BUILTIN_UNPCKLPD,
24701
24702   IX86_BUILTIN_SHUFPD,
24703
24704   IX86_BUILTIN_LOADUPD,
24705   IX86_BUILTIN_STOREUPD,
24706   IX86_BUILTIN_MOVSD,
24707
24708   IX86_BUILTIN_LOADHPD,
24709   IX86_BUILTIN_LOADLPD,
24710
24711   IX86_BUILTIN_CVTDQ2PD,
24712   IX86_BUILTIN_CVTDQ2PS,
24713
24714   IX86_BUILTIN_CVTPD2DQ,
24715   IX86_BUILTIN_CVTPD2PI,
24716   IX86_BUILTIN_CVTPD2PS,
24717   IX86_BUILTIN_CVTTPD2DQ,
24718   IX86_BUILTIN_CVTTPD2PI,
24719
24720   IX86_BUILTIN_CVTPI2PD,
24721   IX86_BUILTIN_CVTSI2SD,
24722   IX86_BUILTIN_CVTSI642SD,
24723
24724   IX86_BUILTIN_CVTSD2SI,
24725   IX86_BUILTIN_CVTSD2SI64,
24726   IX86_BUILTIN_CVTSD2SS,
24727   IX86_BUILTIN_CVTSS2SD,
24728   IX86_BUILTIN_CVTTSD2SI,
24729   IX86_BUILTIN_CVTTSD2SI64,
24730
24731   IX86_BUILTIN_CVTPS2DQ,
24732   IX86_BUILTIN_CVTPS2PD,
24733   IX86_BUILTIN_CVTTPS2DQ,
24734
24735   IX86_BUILTIN_MOVNTI,
24736   IX86_BUILTIN_MOVNTI64,
24737   IX86_BUILTIN_MOVNTPD,
24738   IX86_BUILTIN_MOVNTDQ,
24739
24740   IX86_BUILTIN_MOVQ128,
24741
24742   /* SSE2 MMX */
24743   IX86_BUILTIN_MASKMOVDQU,
24744   IX86_BUILTIN_MOVMSKPD,
24745   IX86_BUILTIN_PMOVMSKB128,
24746
24747   IX86_BUILTIN_PACKSSWB128,
24748   IX86_BUILTIN_PACKSSDW128,
24749   IX86_BUILTIN_PACKUSWB128,
24750
24751   IX86_BUILTIN_PADDB128,
24752   IX86_BUILTIN_PADDW128,
24753   IX86_BUILTIN_PADDD128,
24754   IX86_BUILTIN_PADDQ128,
24755   IX86_BUILTIN_PADDSB128,
24756   IX86_BUILTIN_PADDSW128,
24757   IX86_BUILTIN_PADDUSB128,
24758   IX86_BUILTIN_PADDUSW128,
24759   IX86_BUILTIN_PSUBB128,
24760   IX86_BUILTIN_PSUBW128,
24761   IX86_BUILTIN_PSUBD128,
24762   IX86_BUILTIN_PSUBQ128,
24763   IX86_BUILTIN_PSUBSB128,
24764   IX86_BUILTIN_PSUBSW128,
24765   IX86_BUILTIN_PSUBUSB128,
24766   IX86_BUILTIN_PSUBUSW128,
24767
24768   IX86_BUILTIN_PAND128,
24769   IX86_BUILTIN_PANDN128,
24770   IX86_BUILTIN_POR128,
24771   IX86_BUILTIN_PXOR128,
24772
24773   IX86_BUILTIN_PAVGB128,
24774   IX86_BUILTIN_PAVGW128,
24775
24776   IX86_BUILTIN_PCMPEQB128,
24777   IX86_BUILTIN_PCMPEQW128,
24778   IX86_BUILTIN_PCMPEQD128,
24779   IX86_BUILTIN_PCMPGTB128,
24780   IX86_BUILTIN_PCMPGTW128,
24781   IX86_BUILTIN_PCMPGTD128,
24782
24783   IX86_BUILTIN_PMADDWD128,
24784
24785   IX86_BUILTIN_PMAXSW128,
24786   IX86_BUILTIN_PMAXUB128,
24787   IX86_BUILTIN_PMINSW128,
24788   IX86_BUILTIN_PMINUB128,
24789
24790   IX86_BUILTIN_PMULUDQ,
24791   IX86_BUILTIN_PMULUDQ128,
24792   IX86_BUILTIN_PMULHUW128,
24793   IX86_BUILTIN_PMULHW128,
24794   IX86_BUILTIN_PMULLW128,
24795
24796   IX86_BUILTIN_PSADBW128,
24797   IX86_BUILTIN_PSHUFHW,
24798   IX86_BUILTIN_PSHUFLW,
24799   IX86_BUILTIN_PSHUFD,
24800
24801   IX86_BUILTIN_PSLLDQI128,
24802   IX86_BUILTIN_PSLLWI128,
24803   IX86_BUILTIN_PSLLDI128,
24804   IX86_BUILTIN_PSLLQI128,
24805   IX86_BUILTIN_PSRAWI128,
24806   IX86_BUILTIN_PSRADI128,
24807   IX86_BUILTIN_PSRLDQI128,
24808   IX86_BUILTIN_PSRLWI128,
24809   IX86_BUILTIN_PSRLDI128,
24810   IX86_BUILTIN_PSRLQI128,
24811
24812   IX86_BUILTIN_PSLLDQ128,
24813   IX86_BUILTIN_PSLLW128,
24814   IX86_BUILTIN_PSLLD128,
24815   IX86_BUILTIN_PSLLQ128,
24816   IX86_BUILTIN_PSRAW128,
24817   IX86_BUILTIN_PSRAD128,
24818   IX86_BUILTIN_PSRLW128,
24819   IX86_BUILTIN_PSRLD128,
24820   IX86_BUILTIN_PSRLQ128,
24821
24822   IX86_BUILTIN_PUNPCKHBW128,
24823   IX86_BUILTIN_PUNPCKHWD128,
24824   IX86_BUILTIN_PUNPCKHDQ128,
24825   IX86_BUILTIN_PUNPCKHQDQ128,
24826   IX86_BUILTIN_PUNPCKLBW128,
24827   IX86_BUILTIN_PUNPCKLWD128,
24828   IX86_BUILTIN_PUNPCKLDQ128,
24829   IX86_BUILTIN_PUNPCKLQDQ128,
24830
24831   IX86_BUILTIN_CLFLUSH,
24832   IX86_BUILTIN_MFENCE,
24833   IX86_BUILTIN_LFENCE,
24834   IX86_BUILTIN_PAUSE,
24835
24836   IX86_BUILTIN_BSRSI,
24837   IX86_BUILTIN_BSRDI,
24838   IX86_BUILTIN_RDPMC,
24839   IX86_BUILTIN_RDTSC,
24840   IX86_BUILTIN_RDTSCP,
24841   IX86_BUILTIN_ROLQI,
24842   IX86_BUILTIN_ROLHI,
24843   IX86_BUILTIN_RORQI,
24844   IX86_BUILTIN_RORHI,
24845
24846   /* SSE3.  */
24847   IX86_BUILTIN_ADDSUBPS,
24848   IX86_BUILTIN_HADDPS,
24849   IX86_BUILTIN_HSUBPS,
24850   IX86_BUILTIN_MOVSHDUP,
24851   IX86_BUILTIN_MOVSLDUP,
24852   IX86_BUILTIN_ADDSUBPD,
24853   IX86_BUILTIN_HADDPD,
24854   IX86_BUILTIN_HSUBPD,
24855   IX86_BUILTIN_LDDQU,
24856
24857   IX86_BUILTIN_MONITOR,
24858   IX86_BUILTIN_MWAIT,
24859
24860   /* SSSE3.  */
24861   IX86_BUILTIN_PHADDW,
24862   IX86_BUILTIN_PHADDD,
24863   IX86_BUILTIN_PHADDSW,
24864   IX86_BUILTIN_PHSUBW,
24865   IX86_BUILTIN_PHSUBD,
24866   IX86_BUILTIN_PHSUBSW,
24867   IX86_BUILTIN_PMADDUBSW,
24868   IX86_BUILTIN_PMULHRSW,
24869   IX86_BUILTIN_PSHUFB,
24870   IX86_BUILTIN_PSIGNB,
24871   IX86_BUILTIN_PSIGNW,
24872   IX86_BUILTIN_PSIGND,
24873   IX86_BUILTIN_PALIGNR,
24874   IX86_BUILTIN_PABSB,
24875   IX86_BUILTIN_PABSW,
24876   IX86_BUILTIN_PABSD,
24877
24878   IX86_BUILTIN_PHADDW128,
24879   IX86_BUILTIN_PHADDD128,
24880   IX86_BUILTIN_PHADDSW128,
24881   IX86_BUILTIN_PHSUBW128,
24882   IX86_BUILTIN_PHSUBD128,
24883   IX86_BUILTIN_PHSUBSW128,
24884   IX86_BUILTIN_PMADDUBSW128,
24885   IX86_BUILTIN_PMULHRSW128,
24886   IX86_BUILTIN_PSHUFB128,
24887   IX86_BUILTIN_PSIGNB128,
24888   IX86_BUILTIN_PSIGNW128,
24889   IX86_BUILTIN_PSIGND128,
24890   IX86_BUILTIN_PALIGNR128,
24891   IX86_BUILTIN_PABSB128,
24892   IX86_BUILTIN_PABSW128,
24893   IX86_BUILTIN_PABSD128,
24894
24895   /* AMDFAM10 - SSE4A New Instructions.  */
24896   IX86_BUILTIN_MOVNTSD,
24897   IX86_BUILTIN_MOVNTSS,
24898   IX86_BUILTIN_EXTRQI,
24899   IX86_BUILTIN_EXTRQ,
24900   IX86_BUILTIN_INSERTQI,
24901   IX86_BUILTIN_INSERTQ,
24902
24903   /* SSE4.1.  */
24904   IX86_BUILTIN_BLENDPD,
24905   IX86_BUILTIN_BLENDPS,
24906   IX86_BUILTIN_BLENDVPD,
24907   IX86_BUILTIN_BLENDVPS,
24908   IX86_BUILTIN_PBLENDVB128,
24909   IX86_BUILTIN_PBLENDW128,
24910
24911   IX86_BUILTIN_DPPD,
24912   IX86_BUILTIN_DPPS,
24913
24914   IX86_BUILTIN_INSERTPS128,
24915
24916   IX86_BUILTIN_MOVNTDQA,
24917   IX86_BUILTIN_MPSADBW128,
24918   IX86_BUILTIN_PACKUSDW128,
24919   IX86_BUILTIN_PCMPEQQ,
24920   IX86_BUILTIN_PHMINPOSUW128,
24921
24922   IX86_BUILTIN_PMAXSB128,
24923   IX86_BUILTIN_PMAXSD128,
24924   IX86_BUILTIN_PMAXUD128,
24925   IX86_BUILTIN_PMAXUW128,
24926
24927   IX86_BUILTIN_PMINSB128,
24928   IX86_BUILTIN_PMINSD128,
24929   IX86_BUILTIN_PMINUD128,
24930   IX86_BUILTIN_PMINUW128,
24931
24932   IX86_BUILTIN_PMOVSXBW128,
24933   IX86_BUILTIN_PMOVSXBD128,
24934   IX86_BUILTIN_PMOVSXBQ128,
24935   IX86_BUILTIN_PMOVSXWD128,
24936   IX86_BUILTIN_PMOVSXWQ128,
24937   IX86_BUILTIN_PMOVSXDQ128,
24938
24939   IX86_BUILTIN_PMOVZXBW128,
24940   IX86_BUILTIN_PMOVZXBD128,
24941   IX86_BUILTIN_PMOVZXBQ128,
24942   IX86_BUILTIN_PMOVZXWD128,
24943   IX86_BUILTIN_PMOVZXWQ128,
24944   IX86_BUILTIN_PMOVZXDQ128,
24945
24946   IX86_BUILTIN_PMULDQ128,
24947   IX86_BUILTIN_PMULLD128,
24948
24949   IX86_BUILTIN_ROUNDSD,
24950   IX86_BUILTIN_ROUNDSS,
24951
24952   IX86_BUILTIN_ROUNDPD,
24953   IX86_BUILTIN_ROUNDPS,
24954
24955   IX86_BUILTIN_FLOORPD,
24956   IX86_BUILTIN_CEILPD,
24957   IX86_BUILTIN_TRUNCPD,
24958   IX86_BUILTIN_RINTPD,
24959   IX86_BUILTIN_ROUNDPD_AZ,
24960
24961   IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX,
24962   IX86_BUILTIN_CEILPD_VEC_PACK_SFIX,
24963   IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX,
24964
24965   IX86_BUILTIN_FLOORPS,
24966   IX86_BUILTIN_CEILPS,
24967   IX86_BUILTIN_TRUNCPS,
24968   IX86_BUILTIN_RINTPS,
24969   IX86_BUILTIN_ROUNDPS_AZ,
24970
24971   IX86_BUILTIN_FLOORPS_SFIX,
24972   IX86_BUILTIN_CEILPS_SFIX,
24973   IX86_BUILTIN_ROUNDPS_AZ_SFIX,
24974
24975   IX86_BUILTIN_PTESTZ,
24976   IX86_BUILTIN_PTESTC,
24977   IX86_BUILTIN_PTESTNZC,
24978
24979   IX86_BUILTIN_VEC_INIT_V2SI,
24980   IX86_BUILTIN_VEC_INIT_V4HI,
24981   IX86_BUILTIN_VEC_INIT_V8QI,
24982   IX86_BUILTIN_VEC_EXT_V2DF,
24983   IX86_BUILTIN_VEC_EXT_V2DI,
24984   IX86_BUILTIN_VEC_EXT_V4SF,
24985   IX86_BUILTIN_VEC_EXT_V4SI,
24986   IX86_BUILTIN_VEC_EXT_V8HI,
24987   IX86_BUILTIN_VEC_EXT_V2SI,
24988   IX86_BUILTIN_VEC_EXT_V4HI,
24989   IX86_BUILTIN_VEC_EXT_V16QI,
24990   IX86_BUILTIN_VEC_SET_V2DI,
24991   IX86_BUILTIN_VEC_SET_V4SF,
24992   IX86_BUILTIN_VEC_SET_V4SI,
24993   IX86_BUILTIN_VEC_SET_V8HI,
24994   IX86_BUILTIN_VEC_SET_V4HI,
24995   IX86_BUILTIN_VEC_SET_V16QI,
24996
24997   IX86_BUILTIN_VEC_PACK_SFIX,
24998   IX86_BUILTIN_VEC_PACK_SFIX256,
24999
25000   /* SSE4.2.  */
25001   IX86_BUILTIN_CRC32QI,
25002   IX86_BUILTIN_CRC32HI,
25003   IX86_BUILTIN_CRC32SI,
25004   IX86_BUILTIN_CRC32DI,
25005
25006   IX86_BUILTIN_PCMPESTRI128,
25007   IX86_BUILTIN_PCMPESTRM128,
25008   IX86_BUILTIN_PCMPESTRA128,
25009   IX86_BUILTIN_PCMPESTRC128,
25010   IX86_BUILTIN_PCMPESTRO128,
25011   IX86_BUILTIN_PCMPESTRS128,
25012   IX86_BUILTIN_PCMPESTRZ128,
25013   IX86_BUILTIN_PCMPISTRI128,
25014   IX86_BUILTIN_PCMPISTRM128,
25015   IX86_BUILTIN_PCMPISTRA128,
25016   IX86_BUILTIN_PCMPISTRC128,
25017   IX86_BUILTIN_PCMPISTRO128,
25018   IX86_BUILTIN_PCMPISTRS128,
25019   IX86_BUILTIN_PCMPISTRZ128,
25020
25021   IX86_BUILTIN_PCMPGTQ,
25022
25023   /* AES instructions */
25024   IX86_BUILTIN_AESENC128,
25025   IX86_BUILTIN_AESENCLAST128,
25026   IX86_BUILTIN_AESDEC128,
25027   IX86_BUILTIN_AESDECLAST128,
25028   IX86_BUILTIN_AESIMC128,
25029   IX86_BUILTIN_AESKEYGENASSIST128,
25030
25031   /* PCLMUL instruction */
25032   IX86_BUILTIN_PCLMULQDQ128,
25033
25034   /* AVX */
25035   IX86_BUILTIN_ADDPD256,
25036   IX86_BUILTIN_ADDPS256,
25037   IX86_BUILTIN_ADDSUBPD256,
25038   IX86_BUILTIN_ADDSUBPS256,
25039   IX86_BUILTIN_ANDPD256,
25040   IX86_BUILTIN_ANDPS256,
25041   IX86_BUILTIN_ANDNPD256,
25042   IX86_BUILTIN_ANDNPS256,
25043   IX86_BUILTIN_BLENDPD256,
25044   IX86_BUILTIN_BLENDPS256,
25045   IX86_BUILTIN_BLENDVPD256,
25046   IX86_BUILTIN_BLENDVPS256,
25047   IX86_BUILTIN_DIVPD256,
25048   IX86_BUILTIN_DIVPS256,
25049   IX86_BUILTIN_DPPS256,
25050   IX86_BUILTIN_HADDPD256,
25051   IX86_BUILTIN_HADDPS256,
25052   IX86_BUILTIN_HSUBPD256,
25053   IX86_BUILTIN_HSUBPS256,
25054   IX86_BUILTIN_MAXPD256,
25055   IX86_BUILTIN_MAXPS256,
25056   IX86_BUILTIN_MINPD256,
25057   IX86_BUILTIN_MINPS256,
25058   IX86_BUILTIN_MULPD256,
25059   IX86_BUILTIN_MULPS256,
25060   IX86_BUILTIN_ORPD256,
25061   IX86_BUILTIN_ORPS256,
25062   IX86_BUILTIN_SHUFPD256,
25063   IX86_BUILTIN_SHUFPS256,
25064   IX86_BUILTIN_SUBPD256,
25065   IX86_BUILTIN_SUBPS256,
25066   IX86_BUILTIN_XORPD256,
25067   IX86_BUILTIN_XORPS256,
25068   IX86_BUILTIN_CMPSD,
25069   IX86_BUILTIN_CMPSS,
25070   IX86_BUILTIN_CMPPD,
25071   IX86_BUILTIN_CMPPS,
25072   IX86_BUILTIN_CMPPD256,
25073   IX86_BUILTIN_CMPPS256,
25074   IX86_BUILTIN_CVTDQ2PD256,
25075   IX86_BUILTIN_CVTDQ2PS256,
25076   IX86_BUILTIN_CVTPD2PS256,
25077   IX86_BUILTIN_CVTPS2DQ256,
25078   IX86_BUILTIN_CVTPS2PD256,
25079   IX86_BUILTIN_CVTTPD2DQ256,
25080   IX86_BUILTIN_CVTPD2DQ256,
25081   IX86_BUILTIN_CVTTPS2DQ256,
25082   IX86_BUILTIN_EXTRACTF128PD256,
25083   IX86_BUILTIN_EXTRACTF128PS256,
25084   IX86_BUILTIN_EXTRACTF128SI256,
25085   IX86_BUILTIN_VZEROALL,
25086   IX86_BUILTIN_VZEROUPPER,
25087   IX86_BUILTIN_VPERMILVARPD,
25088   IX86_BUILTIN_VPERMILVARPS,
25089   IX86_BUILTIN_VPERMILVARPD256,
25090   IX86_BUILTIN_VPERMILVARPS256,
25091   IX86_BUILTIN_VPERMILPD,
25092   IX86_BUILTIN_VPERMILPS,
25093   IX86_BUILTIN_VPERMILPD256,
25094   IX86_BUILTIN_VPERMILPS256,
25095   IX86_BUILTIN_VPERMIL2PD,
25096   IX86_BUILTIN_VPERMIL2PS,
25097   IX86_BUILTIN_VPERMIL2PD256,
25098   IX86_BUILTIN_VPERMIL2PS256,
25099   IX86_BUILTIN_VPERM2F128PD256,
25100   IX86_BUILTIN_VPERM2F128PS256,
25101   IX86_BUILTIN_VPERM2F128SI256,
25102   IX86_BUILTIN_VBROADCASTSS,
25103   IX86_BUILTIN_VBROADCASTSD256,
25104   IX86_BUILTIN_VBROADCASTSS256,
25105   IX86_BUILTIN_VBROADCASTPD256,
25106   IX86_BUILTIN_VBROADCASTPS256,
25107   IX86_BUILTIN_VINSERTF128PD256,
25108   IX86_BUILTIN_VINSERTF128PS256,
25109   IX86_BUILTIN_VINSERTF128SI256,
25110   IX86_BUILTIN_LOADUPD256,
25111   IX86_BUILTIN_LOADUPS256,
25112   IX86_BUILTIN_STOREUPD256,
25113   IX86_BUILTIN_STOREUPS256,
25114   IX86_BUILTIN_LDDQU256,
25115   IX86_BUILTIN_MOVNTDQ256,
25116   IX86_BUILTIN_MOVNTPD256,
25117   IX86_BUILTIN_MOVNTPS256,
25118   IX86_BUILTIN_LOADDQU256,
25119   IX86_BUILTIN_STOREDQU256,
25120   IX86_BUILTIN_MASKLOADPD,
25121   IX86_BUILTIN_MASKLOADPS,
25122   IX86_BUILTIN_MASKSTOREPD,
25123   IX86_BUILTIN_MASKSTOREPS,
25124   IX86_BUILTIN_MASKLOADPD256,
25125   IX86_BUILTIN_MASKLOADPS256,
25126   IX86_BUILTIN_MASKSTOREPD256,
25127   IX86_BUILTIN_MASKSTOREPS256,
25128   IX86_BUILTIN_MOVSHDUP256,
25129   IX86_BUILTIN_MOVSLDUP256,
25130   IX86_BUILTIN_MOVDDUP256,
25131
25132   IX86_BUILTIN_SQRTPD256,
25133   IX86_BUILTIN_SQRTPS256,
25134   IX86_BUILTIN_SQRTPS_NR256,
25135   IX86_BUILTIN_RSQRTPS256,
25136   IX86_BUILTIN_RSQRTPS_NR256,
25137
25138   IX86_BUILTIN_RCPPS256,
25139
25140   IX86_BUILTIN_ROUNDPD256,
25141   IX86_BUILTIN_ROUNDPS256,
25142
25143   IX86_BUILTIN_FLOORPD256,
25144   IX86_BUILTIN_CEILPD256,
25145   IX86_BUILTIN_TRUNCPD256,
25146   IX86_BUILTIN_RINTPD256,
25147   IX86_BUILTIN_ROUNDPD_AZ256,
25148
25149   IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX256,
25150   IX86_BUILTIN_CEILPD_VEC_PACK_SFIX256,
25151   IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX256,
25152
25153   IX86_BUILTIN_FLOORPS256,
25154   IX86_BUILTIN_CEILPS256,
25155   IX86_BUILTIN_TRUNCPS256,
25156   IX86_BUILTIN_RINTPS256,
25157   IX86_BUILTIN_ROUNDPS_AZ256,
25158
25159   IX86_BUILTIN_FLOORPS_SFIX256,
25160   IX86_BUILTIN_CEILPS_SFIX256,
25161   IX86_BUILTIN_ROUNDPS_AZ_SFIX256,
25162
25163   IX86_BUILTIN_UNPCKHPD256,
25164   IX86_BUILTIN_UNPCKLPD256,
25165   IX86_BUILTIN_UNPCKHPS256,
25166   IX86_BUILTIN_UNPCKLPS256,
25167
25168   IX86_BUILTIN_SI256_SI,
25169   IX86_BUILTIN_PS256_PS,
25170   IX86_BUILTIN_PD256_PD,
25171   IX86_BUILTIN_SI_SI256,
25172   IX86_BUILTIN_PS_PS256,
25173   IX86_BUILTIN_PD_PD256,
25174
25175   IX86_BUILTIN_VTESTZPD,
25176   IX86_BUILTIN_VTESTCPD,
25177   IX86_BUILTIN_VTESTNZCPD,
25178   IX86_BUILTIN_VTESTZPS,
25179   IX86_BUILTIN_VTESTCPS,
25180   IX86_BUILTIN_VTESTNZCPS,
25181   IX86_BUILTIN_VTESTZPD256,
25182   IX86_BUILTIN_VTESTCPD256,
25183   IX86_BUILTIN_VTESTNZCPD256,
25184   IX86_BUILTIN_VTESTZPS256,
25185   IX86_BUILTIN_VTESTCPS256,
25186   IX86_BUILTIN_VTESTNZCPS256,
25187   IX86_BUILTIN_PTESTZ256,
25188   IX86_BUILTIN_PTESTC256,
25189   IX86_BUILTIN_PTESTNZC256,
25190
25191   IX86_BUILTIN_MOVMSKPD256,
25192   IX86_BUILTIN_MOVMSKPS256,
25193
25194   /* AVX2 */
25195   IX86_BUILTIN_MPSADBW256,
25196   IX86_BUILTIN_PABSB256,
25197   IX86_BUILTIN_PABSW256,
25198   IX86_BUILTIN_PABSD256,
25199   IX86_BUILTIN_PACKSSDW256,
25200   IX86_BUILTIN_PACKSSWB256,
25201   IX86_BUILTIN_PACKUSDW256,
25202   IX86_BUILTIN_PACKUSWB256,
25203   IX86_BUILTIN_PADDB256,
25204   IX86_BUILTIN_PADDW256,
25205   IX86_BUILTIN_PADDD256,
25206   IX86_BUILTIN_PADDQ256,
25207   IX86_BUILTIN_PADDSB256,
25208   IX86_BUILTIN_PADDSW256,
25209   IX86_BUILTIN_PADDUSB256,
25210   IX86_BUILTIN_PADDUSW256,
25211   IX86_BUILTIN_PALIGNR256,
25212   IX86_BUILTIN_AND256I,
25213   IX86_BUILTIN_ANDNOT256I,
25214   IX86_BUILTIN_PAVGB256,
25215   IX86_BUILTIN_PAVGW256,
25216   IX86_BUILTIN_PBLENDVB256,
25217   IX86_BUILTIN_PBLENDVW256,
25218   IX86_BUILTIN_PCMPEQB256,
25219   IX86_BUILTIN_PCMPEQW256,
25220   IX86_BUILTIN_PCMPEQD256,
25221   IX86_BUILTIN_PCMPEQQ256,
25222   IX86_BUILTIN_PCMPGTB256,
25223   IX86_BUILTIN_PCMPGTW256,
25224   IX86_BUILTIN_PCMPGTD256,
25225   IX86_BUILTIN_PCMPGTQ256,
25226   IX86_BUILTIN_PHADDW256,
25227   IX86_BUILTIN_PHADDD256,
25228   IX86_BUILTIN_PHADDSW256,
25229   IX86_BUILTIN_PHSUBW256,
25230   IX86_BUILTIN_PHSUBD256,
25231   IX86_BUILTIN_PHSUBSW256,
25232   IX86_BUILTIN_PMADDUBSW256,
25233   IX86_BUILTIN_PMADDWD256,
25234   IX86_BUILTIN_PMAXSB256,
25235   IX86_BUILTIN_PMAXSW256,
25236   IX86_BUILTIN_PMAXSD256,
25237   IX86_BUILTIN_PMAXUB256,
25238   IX86_BUILTIN_PMAXUW256,
25239   IX86_BUILTIN_PMAXUD256,
25240   IX86_BUILTIN_PMINSB256,
25241   IX86_BUILTIN_PMINSW256,
25242   IX86_BUILTIN_PMINSD256,
25243   IX86_BUILTIN_PMINUB256,
25244   IX86_BUILTIN_PMINUW256,
25245   IX86_BUILTIN_PMINUD256,
25246   IX86_BUILTIN_PMOVMSKB256,
25247   IX86_BUILTIN_PMOVSXBW256,
25248   IX86_BUILTIN_PMOVSXBD256,
25249   IX86_BUILTIN_PMOVSXBQ256,
25250   IX86_BUILTIN_PMOVSXWD256,
25251   IX86_BUILTIN_PMOVSXWQ256,
25252   IX86_BUILTIN_PMOVSXDQ256,
25253   IX86_BUILTIN_PMOVZXBW256,
25254   IX86_BUILTIN_PMOVZXBD256,
25255   IX86_BUILTIN_PMOVZXBQ256,
25256   IX86_BUILTIN_PMOVZXWD256,
25257   IX86_BUILTIN_PMOVZXWQ256,
25258   IX86_BUILTIN_PMOVZXDQ256,
25259   IX86_BUILTIN_PMULDQ256,
25260   IX86_BUILTIN_PMULHRSW256,
25261   IX86_BUILTIN_PMULHUW256,
25262   IX86_BUILTIN_PMULHW256,
25263   IX86_BUILTIN_PMULLW256,
25264   IX86_BUILTIN_PMULLD256,
25265   IX86_BUILTIN_PMULUDQ256,
25266   IX86_BUILTIN_POR256,
25267   IX86_BUILTIN_PSADBW256,
25268   IX86_BUILTIN_PSHUFB256,
25269   IX86_BUILTIN_PSHUFD256,
25270   IX86_BUILTIN_PSHUFHW256,
25271   IX86_BUILTIN_PSHUFLW256,
25272   IX86_BUILTIN_PSIGNB256,
25273   IX86_BUILTIN_PSIGNW256,
25274   IX86_BUILTIN_PSIGND256,
25275   IX86_BUILTIN_PSLLDQI256,
25276   IX86_BUILTIN_PSLLWI256,
25277   IX86_BUILTIN_PSLLW256,
25278   IX86_BUILTIN_PSLLDI256,
25279   IX86_BUILTIN_PSLLD256,
25280   IX86_BUILTIN_PSLLQI256,
25281   IX86_BUILTIN_PSLLQ256,
25282   IX86_BUILTIN_PSRAWI256,
25283   IX86_BUILTIN_PSRAW256,
25284   IX86_BUILTIN_PSRADI256,
25285   IX86_BUILTIN_PSRAD256,
25286   IX86_BUILTIN_PSRLDQI256,
25287   IX86_BUILTIN_PSRLWI256,
25288   IX86_BUILTIN_PSRLW256,
25289   IX86_BUILTIN_PSRLDI256,
25290   IX86_BUILTIN_PSRLD256,
25291   IX86_BUILTIN_PSRLQI256,
25292   IX86_BUILTIN_PSRLQ256,
25293   IX86_BUILTIN_PSUBB256,
25294   IX86_BUILTIN_PSUBW256,
25295   IX86_BUILTIN_PSUBD256,
25296   IX86_BUILTIN_PSUBQ256,
25297   IX86_BUILTIN_PSUBSB256,
25298   IX86_BUILTIN_PSUBSW256,
25299   IX86_BUILTIN_PSUBUSB256,
25300   IX86_BUILTIN_PSUBUSW256,
25301   IX86_BUILTIN_PUNPCKHBW256,
25302   IX86_BUILTIN_PUNPCKHWD256,
25303   IX86_BUILTIN_PUNPCKHDQ256,
25304   IX86_BUILTIN_PUNPCKHQDQ256,
25305   IX86_BUILTIN_PUNPCKLBW256,
25306   IX86_BUILTIN_PUNPCKLWD256,
25307   IX86_BUILTIN_PUNPCKLDQ256,
25308   IX86_BUILTIN_PUNPCKLQDQ256,
25309   IX86_BUILTIN_PXOR256,
25310   IX86_BUILTIN_MOVNTDQA256,
25311   IX86_BUILTIN_VBROADCASTSS_PS,
25312   IX86_BUILTIN_VBROADCASTSS_PS256,
25313   IX86_BUILTIN_VBROADCASTSD_PD256,
25314   IX86_BUILTIN_VBROADCASTSI256,
25315   IX86_BUILTIN_PBLENDD256,
25316   IX86_BUILTIN_PBLENDD128,
25317   IX86_BUILTIN_PBROADCASTB256,
25318   IX86_BUILTIN_PBROADCASTW256,
25319   IX86_BUILTIN_PBROADCASTD256,
25320   IX86_BUILTIN_PBROADCASTQ256,
25321   IX86_BUILTIN_PBROADCASTB128,
25322   IX86_BUILTIN_PBROADCASTW128,
25323   IX86_BUILTIN_PBROADCASTD128,
25324   IX86_BUILTIN_PBROADCASTQ128,
25325   IX86_BUILTIN_VPERMVARSI256,
25326   IX86_BUILTIN_VPERMDF256,
25327   IX86_BUILTIN_VPERMVARSF256,
25328   IX86_BUILTIN_VPERMDI256,
25329   IX86_BUILTIN_VPERMTI256,
25330   IX86_BUILTIN_VEXTRACT128I256,
25331   IX86_BUILTIN_VINSERT128I256,
25332   IX86_BUILTIN_MASKLOADD,
25333   IX86_BUILTIN_MASKLOADQ,
25334   IX86_BUILTIN_MASKLOADD256,
25335   IX86_BUILTIN_MASKLOADQ256,
25336   IX86_BUILTIN_MASKSTORED,
25337   IX86_BUILTIN_MASKSTOREQ,
25338   IX86_BUILTIN_MASKSTORED256,
25339   IX86_BUILTIN_MASKSTOREQ256,
25340   IX86_BUILTIN_PSLLVV4DI,
25341   IX86_BUILTIN_PSLLVV2DI,
25342   IX86_BUILTIN_PSLLVV8SI,
25343   IX86_BUILTIN_PSLLVV4SI,
25344   IX86_BUILTIN_PSRAVV8SI,
25345   IX86_BUILTIN_PSRAVV4SI,
25346   IX86_BUILTIN_PSRLVV4DI,
25347   IX86_BUILTIN_PSRLVV2DI,
25348   IX86_BUILTIN_PSRLVV8SI,
25349   IX86_BUILTIN_PSRLVV4SI,
25350
25351   IX86_BUILTIN_GATHERSIV2DF,
25352   IX86_BUILTIN_GATHERSIV4DF,
25353   IX86_BUILTIN_GATHERDIV2DF,
25354   IX86_BUILTIN_GATHERDIV4DF,
25355   IX86_BUILTIN_GATHERSIV4SF,
25356   IX86_BUILTIN_GATHERSIV8SF,
25357   IX86_BUILTIN_GATHERDIV4SF,
25358   IX86_BUILTIN_GATHERDIV8SF,
25359   IX86_BUILTIN_GATHERSIV2DI,
25360   IX86_BUILTIN_GATHERSIV4DI,
25361   IX86_BUILTIN_GATHERDIV2DI,
25362   IX86_BUILTIN_GATHERDIV4DI,
25363   IX86_BUILTIN_GATHERSIV4SI,
25364   IX86_BUILTIN_GATHERSIV8SI,
25365   IX86_BUILTIN_GATHERDIV4SI,
25366   IX86_BUILTIN_GATHERDIV8SI,
25367
25368   /* Alternate 4 element gather for the vectorizer where
25369      all operands are 32-byte wide.  */
25370   IX86_BUILTIN_GATHERALTSIV4DF,
25371   IX86_BUILTIN_GATHERALTDIV8SF,
25372   IX86_BUILTIN_GATHERALTSIV4DI,
25373   IX86_BUILTIN_GATHERALTDIV8SI,
25374
25375   /* TFmode support builtins.  */
25376   IX86_BUILTIN_INFQ,
25377   IX86_BUILTIN_HUGE_VALQ,
25378   IX86_BUILTIN_FABSQ,
25379   IX86_BUILTIN_COPYSIGNQ,
25380
25381   /* Vectorizer support builtins.  */
25382   IX86_BUILTIN_CPYSGNPS,
25383   IX86_BUILTIN_CPYSGNPD,
25384   IX86_BUILTIN_CPYSGNPS256,
25385   IX86_BUILTIN_CPYSGNPD256,
25386
25387   /* FMA4 instructions.  */
25388   IX86_BUILTIN_VFMADDSS,
25389   IX86_BUILTIN_VFMADDSD,
25390   IX86_BUILTIN_VFMADDPS,
25391   IX86_BUILTIN_VFMADDPD,
25392   IX86_BUILTIN_VFMADDPS256,
25393   IX86_BUILTIN_VFMADDPD256,
25394   IX86_BUILTIN_VFMADDSUBPS,
25395   IX86_BUILTIN_VFMADDSUBPD,
25396   IX86_BUILTIN_VFMADDSUBPS256,
25397   IX86_BUILTIN_VFMADDSUBPD256,
25398
25399   /* FMA3 instructions.  */
25400   IX86_BUILTIN_VFMADDSS3,
25401   IX86_BUILTIN_VFMADDSD3,
25402
25403   /* XOP instructions.  */
25404   IX86_BUILTIN_VPCMOV,
25405   IX86_BUILTIN_VPCMOV_V2DI,
25406   IX86_BUILTIN_VPCMOV_V4SI,
25407   IX86_BUILTIN_VPCMOV_V8HI,
25408   IX86_BUILTIN_VPCMOV_V16QI,
25409   IX86_BUILTIN_VPCMOV_V4SF,
25410   IX86_BUILTIN_VPCMOV_V2DF,
25411   IX86_BUILTIN_VPCMOV256,
25412   IX86_BUILTIN_VPCMOV_V4DI256,
25413   IX86_BUILTIN_VPCMOV_V8SI256,
25414   IX86_BUILTIN_VPCMOV_V16HI256,
25415   IX86_BUILTIN_VPCMOV_V32QI256,
25416   IX86_BUILTIN_VPCMOV_V8SF256,
25417   IX86_BUILTIN_VPCMOV_V4DF256,
25418
25419   IX86_BUILTIN_VPPERM,
25420
25421   IX86_BUILTIN_VPMACSSWW,
25422   IX86_BUILTIN_VPMACSWW,
25423   IX86_BUILTIN_VPMACSSWD,
25424   IX86_BUILTIN_VPMACSWD,
25425   IX86_BUILTIN_VPMACSSDD,
25426   IX86_BUILTIN_VPMACSDD,
25427   IX86_BUILTIN_VPMACSSDQL,
25428   IX86_BUILTIN_VPMACSSDQH,
25429   IX86_BUILTIN_VPMACSDQL,
25430   IX86_BUILTIN_VPMACSDQH,
25431   IX86_BUILTIN_VPMADCSSWD,
25432   IX86_BUILTIN_VPMADCSWD,
25433
25434   IX86_BUILTIN_VPHADDBW,
25435   IX86_BUILTIN_VPHADDBD,
25436   IX86_BUILTIN_VPHADDBQ,
25437   IX86_BUILTIN_VPHADDWD,
25438   IX86_BUILTIN_VPHADDWQ,
25439   IX86_BUILTIN_VPHADDDQ,
25440   IX86_BUILTIN_VPHADDUBW,
25441   IX86_BUILTIN_VPHADDUBD,
25442   IX86_BUILTIN_VPHADDUBQ,
25443   IX86_BUILTIN_VPHADDUWD,
25444   IX86_BUILTIN_VPHADDUWQ,
25445   IX86_BUILTIN_VPHADDUDQ,
25446   IX86_BUILTIN_VPHSUBBW,
25447   IX86_BUILTIN_VPHSUBWD,
25448   IX86_BUILTIN_VPHSUBDQ,
25449
25450   IX86_BUILTIN_VPROTB,
25451   IX86_BUILTIN_VPROTW,
25452   IX86_BUILTIN_VPROTD,
25453   IX86_BUILTIN_VPROTQ,
25454   IX86_BUILTIN_VPROTB_IMM,
25455   IX86_BUILTIN_VPROTW_IMM,
25456   IX86_BUILTIN_VPROTD_IMM,
25457   IX86_BUILTIN_VPROTQ_IMM,
25458
25459   IX86_BUILTIN_VPSHLB,
25460   IX86_BUILTIN_VPSHLW,
25461   IX86_BUILTIN_VPSHLD,
25462   IX86_BUILTIN_VPSHLQ,
25463   IX86_BUILTIN_VPSHAB,
25464   IX86_BUILTIN_VPSHAW,
25465   IX86_BUILTIN_VPSHAD,
25466   IX86_BUILTIN_VPSHAQ,
25467
25468   IX86_BUILTIN_VFRCZSS,
25469   IX86_BUILTIN_VFRCZSD,
25470   IX86_BUILTIN_VFRCZPS,
25471   IX86_BUILTIN_VFRCZPD,
25472   IX86_BUILTIN_VFRCZPS256,
25473   IX86_BUILTIN_VFRCZPD256,
25474
25475   IX86_BUILTIN_VPCOMEQUB,
25476   IX86_BUILTIN_VPCOMNEUB,
25477   IX86_BUILTIN_VPCOMLTUB,
25478   IX86_BUILTIN_VPCOMLEUB,
25479   IX86_BUILTIN_VPCOMGTUB,
25480   IX86_BUILTIN_VPCOMGEUB,
25481   IX86_BUILTIN_VPCOMFALSEUB,
25482   IX86_BUILTIN_VPCOMTRUEUB,
25483
25484   IX86_BUILTIN_VPCOMEQUW,
25485   IX86_BUILTIN_VPCOMNEUW,
25486   IX86_BUILTIN_VPCOMLTUW,
25487   IX86_BUILTIN_VPCOMLEUW,
25488   IX86_BUILTIN_VPCOMGTUW,
25489   IX86_BUILTIN_VPCOMGEUW,
25490   IX86_BUILTIN_VPCOMFALSEUW,
25491   IX86_BUILTIN_VPCOMTRUEUW,
25492
25493   IX86_BUILTIN_VPCOMEQUD,
25494   IX86_BUILTIN_VPCOMNEUD,
25495   IX86_BUILTIN_VPCOMLTUD,
25496   IX86_BUILTIN_VPCOMLEUD,
25497   IX86_BUILTIN_VPCOMGTUD,
25498   IX86_BUILTIN_VPCOMGEUD,
25499   IX86_BUILTIN_VPCOMFALSEUD,
25500   IX86_BUILTIN_VPCOMTRUEUD,
25501
25502   IX86_BUILTIN_VPCOMEQUQ,
25503   IX86_BUILTIN_VPCOMNEUQ,
25504   IX86_BUILTIN_VPCOMLTUQ,
25505   IX86_BUILTIN_VPCOMLEUQ,
25506   IX86_BUILTIN_VPCOMGTUQ,
25507   IX86_BUILTIN_VPCOMGEUQ,
25508   IX86_BUILTIN_VPCOMFALSEUQ,
25509   IX86_BUILTIN_VPCOMTRUEUQ,
25510
25511   IX86_BUILTIN_VPCOMEQB,
25512   IX86_BUILTIN_VPCOMNEB,
25513   IX86_BUILTIN_VPCOMLTB,
25514   IX86_BUILTIN_VPCOMLEB,
25515   IX86_BUILTIN_VPCOMGTB,
25516   IX86_BUILTIN_VPCOMGEB,
25517   IX86_BUILTIN_VPCOMFALSEB,
25518   IX86_BUILTIN_VPCOMTRUEB,
25519
25520   IX86_BUILTIN_VPCOMEQW,
25521   IX86_BUILTIN_VPCOMNEW,
25522   IX86_BUILTIN_VPCOMLTW,
25523   IX86_BUILTIN_VPCOMLEW,
25524   IX86_BUILTIN_VPCOMGTW,
25525   IX86_BUILTIN_VPCOMGEW,
25526   IX86_BUILTIN_VPCOMFALSEW,
25527   IX86_BUILTIN_VPCOMTRUEW,
25528
25529   IX86_BUILTIN_VPCOMEQD,
25530   IX86_BUILTIN_VPCOMNED,
25531   IX86_BUILTIN_VPCOMLTD,
25532   IX86_BUILTIN_VPCOMLED,
25533   IX86_BUILTIN_VPCOMGTD,
25534   IX86_BUILTIN_VPCOMGED,
25535   IX86_BUILTIN_VPCOMFALSED,
25536   IX86_BUILTIN_VPCOMTRUED,
25537
25538   IX86_BUILTIN_VPCOMEQQ,
25539   IX86_BUILTIN_VPCOMNEQ,
25540   IX86_BUILTIN_VPCOMLTQ,
25541   IX86_BUILTIN_VPCOMLEQ,
25542   IX86_BUILTIN_VPCOMGTQ,
25543   IX86_BUILTIN_VPCOMGEQ,
25544   IX86_BUILTIN_VPCOMFALSEQ,
25545   IX86_BUILTIN_VPCOMTRUEQ,
25546
25547   /* LWP instructions.  */
25548   IX86_BUILTIN_LLWPCB,
25549   IX86_BUILTIN_SLWPCB,
25550   IX86_BUILTIN_LWPVAL32,
25551   IX86_BUILTIN_LWPVAL64,
25552   IX86_BUILTIN_LWPINS32,
25553   IX86_BUILTIN_LWPINS64,
25554
25555   IX86_BUILTIN_CLZS,
25556
25557   /* BMI instructions.  */
25558   IX86_BUILTIN_BEXTR32,
25559   IX86_BUILTIN_BEXTR64,
25560   IX86_BUILTIN_CTZS,
25561
25562   /* TBM instructions.  */
25563   IX86_BUILTIN_BEXTRI32,
25564   IX86_BUILTIN_BEXTRI64,
25565
25566   /* BMI2 instructions. */
25567   IX86_BUILTIN_BZHI32,
25568   IX86_BUILTIN_BZHI64,
25569   IX86_BUILTIN_PDEP32,
25570   IX86_BUILTIN_PDEP64,
25571   IX86_BUILTIN_PEXT32,
25572   IX86_BUILTIN_PEXT64,
25573
25574   /* FSGSBASE instructions.  */
25575   IX86_BUILTIN_RDFSBASE32,
25576   IX86_BUILTIN_RDFSBASE64,
25577   IX86_BUILTIN_RDGSBASE32,
25578   IX86_BUILTIN_RDGSBASE64,
25579   IX86_BUILTIN_WRFSBASE32,
25580   IX86_BUILTIN_WRFSBASE64,
25581   IX86_BUILTIN_WRGSBASE32,
25582   IX86_BUILTIN_WRGSBASE64,
25583
25584   /* RDRND instructions.  */
25585   IX86_BUILTIN_RDRAND16_STEP,
25586   IX86_BUILTIN_RDRAND32_STEP,
25587   IX86_BUILTIN_RDRAND64_STEP,
25588
25589   /* F16C instructions.  */
25590   IX86_BUILTIN_CVTPH2PS,
25591   IX86_BUILTIN_CVTPH2PS256,
25592   IX86_BUILTIN_CVTPS2PH,
25593   IX86_BUILTIN_CVTPS2PH256,
25594
25595   /* CFString built-in for darwin */
25596   IX86_BUILTIN_CFSTRING,
25597
25598   IX86_BUILTIN_MAX
25599 };
25600
25601 /* Table for the ix86 builtin decls.  */
25602 static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX];
25603
25604 /* Table of all of the builtin functions that are possible with different ISA's
25605    but are waiting to be built until a function is declared to use that
25606    ISA.  */
25607 struct builtin_isa {
25608   const char *name;             /* function name */
25609   enum ix86_builtin_func_type tcode; /* type to use in the declaration */
25610   HOST_WIDE_INT isa;            /* isa_flags this builtin is defined for */
25611   bool const_p;                 /* true if the declaration is constant */
25612   bool set_and_not_built_p;
25613 };
25614
25615 static struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX];
25616
25617
25618 /* Add an ix86 target builtin function with CODE, NAME and TYPE.  Save the MASK
25619    of which isa_flags to use in the ix86_builtins_isa array.  Stores the
25620    function decl in the ix86_builtins array.  Returns the function decl or
25621    NULL_TREE, if the builtin was not added.
25622
25623    If the front end has a special hook for builtin functions, delay adding
25624    builtin functions that aren't in the current ISA until the ISA is changed
25625    with function specific optimization.  Doing so, can save about 300K for the
25626    default compiler.  When the builtin is expanded, check at that time whether
25627    it is valid.
25628
25629    If the front end doesn't have a special hook, record all builtins, even if
25630    it isn't an instruction set in the current ISA in case the user uses
25631    function specific options for a different ISA, so that we don't get scope
25632    errors if a builtin is added in the middle of a function scope.  */
25633
25634 static inline tree
25635 def_builtin (HOST_WIDE_INT mask, const char *name,
25636              enum ix86_builtin_func_type tcode,
25637              enum ix86_builtins code)
25638 {
25639   tree decl = NULL_TREE;
25640
25641   if (!(mask & OPTION_MASK_ISA_64BIT) || TARGET_64BIT)
25642     {
25643       ix86_builtins_isa[(int) code].isa = mask;
25644
25645       mask &= ~OPTION_MASK_ISA_64BIT;
25646       if (mask == 0
25647           || (mask & ix86_isa_flags) != 0
25648           || (lang_hooks.builtin_function
25649               == lang_hooks.builtin_function_ext_scope))
25650
25651         {
25652           tree type = ix86_get_builtin_func_type (tcode);
25653           decl = add_builtin_function (name, type, code, BUILT_IN_MD,
25654                                        NULL, NULL_TREE);
25655           ix86_builtins[(int) code] = decl;
25656           ix86_builtins_isa[(int) code].set_and_not_built_p = false;
25657         }
25658       else
25659         {
25660           ix86_builtins[(int) code] = NULL_TREE;
25661           ix86_builtins_isa[(int) code].tcode = tcode;
25662           ix86_builtins_isa[(int) code].name = name;
25663           ix86_builtins_isa[(int) code].const_p = false;
25664           ix86_builtins_isa[(int) code].set_and_not_built_p = true;
25665         }
25666     }
25667
25668   return decl;
25669 }
25670
25671 /* Like def_builtin, but also marks the function decl "const".  */
25672
25673 static inline tree
25674 def_builtin_const (HOST_WIDE_INT mask, const char *name,
25675                    enum ix86_builtin_func_type tcode, enum ix86_builtins code)
25676 {
25677   tree decl = def_builtin (mask, name, tcode, code);
25678   if (decl)
25679     TREE_READONLY (decl) = 1;
25680   else
25681     ix86_builtins_isa[(int) code].const_p = true;
25682
25683   return decl;
25684 }
25685
25686 /* Add any new builtin functions for a given ISA that may not have been
25687    declared.  This saves a bit of space compared to adding all of the
25688    declarations to the tree, even if we didn't use them.  */
25689
25690 static void
25691 ix86_add_new_builtins (HOST_WIDE_INT isa)
25692 {
25693   int i;
25694
25695   for (i = 0; i < (int)IX86_BUILTIN_MAX; i++)
25696     {
25697       if ((ix86_builtins_isa[i].isa & isa) != 0
25698           && ix86_builtins_isa[i].set_and_not_built_p)
25699         {
25700           tree decl, type;
25701
25702           /* Don't define the builtin again.  */
25703           ix86_builtins_isa[i].set_and_not_built_p = false;
25704
25705           type = ix86_get_builtin_func_type (ix86_builtins_isa[i].tcode);
25706           decl = add_builtin_function_ext_scope (ix86_builtins_isa[i].name,
25707                                                  type, i, BUILT_IN_MD, NULL,
25708                                                  NULL_TREE);
25709
25710           ix86_builtins[i] = decl;
25711           if (ix86_builtins_isa[i].const_p)
25712             TREE_READONLY (decl) = 1;
25713         }
25714     }
25715 }
25716
25717 /* Bits for builtin_description.flag.  */
25718
25719 /* Set when we don't support the comparison natively, and should
25720    swap_comparison in order to support it.  */
25721 #define BUILTIN_DESC_SWAP_OPERANDS      1
25722
25723 struct builtin_description
25724 {
25725   const HOST_WIDE_INT mask;
25726   const enum insn_code icode;
25727   const char *const name;
25728   const enum ix86_builtins code;
25729   const enum rtx_code comparison;
25730   const int flag;
25731 };
25732
25733 static const struct builtin_description bdesc_comi[] =
25734 {
25735   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comieq", IX86_BUILTIN_COMIEQSS, UNEQ, 0 },
25736   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comilt", IX86_BUILTIN_COMILTSS, UNLT, 0 },
25737   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comile", IX86_BUILTIN_COMILESS, UNLE, 0 },
25738   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comigt", IX86_BUILTIN_COMIGTSS, GT, 0 },
25739   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comige", IX86_BUILTIN_COMIGESS, GE, 0 },
25740   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_comi, "__builtin_ia32_comineq", IX86_BUILTIN_COMINEQSS, LTGT, 0 },
25741   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomieq", IX86_BUILTIN_UCOMIEQSS, UNEQ, 0 },
25742   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomilt", IX86_BUILTIN_UCOMILTSS, UNLT, 0 },
25743   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomile", IX86_BUILTIN_UCOMILESS, UNLE, 0 },
25744   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomigt", IX86_BUILTIN_UCOMIGTSS, GT, 0 },
25745   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomige", IX86_BUILTIN_UCOMIGESS, GE, 0 },
25746   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_ucomi, "__builtin_ia32_ucomineq", IX86_BUILTIN_UCOMINEQSS, LTGT, 0 },
25747   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdeq", IX86_BUILTIN_COMIEQSD, UNEQ, 0 },
25748   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdlt", IX86_BUILTIN_COMILTSD, UNLT, 0 },
25749   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdle", IX86_BUILTIN_COMILESD, UNLE, 0 },
25750   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdgt", IX86_BUILTIN_COMIGTSD, GT, 0 },
25751   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdge", IX86_BUILTIN_COMIGESD, GE, 0 },
25752   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_comi, "__builtin_ia32_comisdneq", IX86_BUILTIN_COMINEQSD, LTGT, 0 },
25753   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdeq", IX86_BUILTIN_UCOMIEQSD, UNEQ, 0 },
25754   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdlt", IX86_BUILTIN_UCOMILTSD, UNLT, 0 },
25755   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdle", IX86_BUILTIN_UCOMILESD, UNLE, 0 },
25756   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdgt", IX86_BUILTIN_UCOMIGTSD, GT, 0 },
25757   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdge", IX86_BUILTIN_UCOMIGESD, GE, 0 },
25758   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ucomi, "__builtin_ia32_ucomisdneq", IX86_BUILTIN_UCOMINEQSD, LTGT, 0 },
25759 };
25760
25761 static const struct builtin_description bdesc_pcmpestr[] =
25762 {
25763   /* SSE4.2 */
25764   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestri128", IX86_BUILTIN_PCMPESTRI128, UNKNOWN, 0 },
25765   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrm128", IX86_BUILTIN_PCMPESTRM128, UNKNOWN, 0 },
25766   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestria128", IX86_BUILTIN_PCMPESTRA128, UNKNOWN, (int) CCAmode },
25767   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestric128", IX86_BUILTIN_PCMPESTRC128, UNKNOWN, (int) CCCmode },
25768   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestrio128", IX86_BUILTIN_PCMPESTRO128, UNKNOWN, (int) CCOmode },
25769   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestris128", IX86_BUILTIN_PCMPESTRS128, UNKNOWN, (int) CCSmode },
25770   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpestr, "__builtin_ia32_pcmpestriz128", IX86_BUILTIN_PCMPESTRZ128, UNKNOWN, (int) CCZmode },
25771 };
25772
25773 static const struct builtin_description bdesc_pcmpistr[] =
25774 {
25775   /* SSE4.2 */
25776   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistri128", IX86_BUILTIN_PCMPISTRI128, UNKNOWN, 0 },
25777   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrm128", IX86_BUILTIN_PCMPISTRM128, UNKNOWN, 0 },
25778   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistria128", IX86_BUILTIN_PCMPISTRA128, UNKNOWN, (int) CCAmode },
25779   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistric128", IX86_BUILTIN_PCMPISTRC128, UNKNOWN, (int) CCCmode },
25780   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistrio128", IX86_BUILTIN_PCMPISTRO128, UNKNOWN, (int) CCOmode },
25781   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistris128", IX86_BUILTIN_PCMPISTRS128, UNKNOWN, (int) CCSmode },
25782   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_pcmpistr, "__builtin_ia32_pcmpistriz128", IX86_BUILTIN_PCMPISTRZ128, UNKNOWN, (int) CCZmode },
25783 };
25784
25785 /* Special builtins with variable number of arguments.  */
25786 static const struct builtin_description bdesc_special_args[] =
25787 {
25788   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtsc, "__builtin_ia32_rdtsc", IX86_BUILTIN_RDTSC, UNKNOWN, (int) UINT64_FTYPE_VOID },
25789   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdtscp, "__builtin_ia32_rdtscp", IX86_BUILTIN_RDTSCP, UNKNOWN, (int) UINT64_FTYPE_PUNSIGNED },
25790   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_pause, "__builtin_ia32_pause", IX86_BUILTIN_PAUSE, UNKNOWN, (int) VOID_FTYPE_VOID },
25791
25792   /* MMX */
25793   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_emms, "__builtin_ia32_emms", IX86_BUILTIN_EMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
25794
25795   /* 3DNow! */
25796   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_femms, "__builtin_ia32_femms", IX86_BUILTIN_FEMMS, UNKNOWN, (int) VOID_FTYPE_VOID },
25797
25798   /* SSE */
25799   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_storeups", IX86_BUILTIN_STOREUPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25800   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movntv4sf, "__builtin_ia32_movntps", IX86_BUILTIN_MOVNTPS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25801   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movups, "__builtin_ia32_loadups", IX86_BUILTIN_LOADUPS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
25802
25803   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadhps_exp, "__builtin_ia32_loadhps", IX86_BUILTIN_LOADHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
25804   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_loadlps_exp, "__builtin_ia32_loadlps", IX86_BUILTIN_LOADLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_PCV2SF },
25805   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storehps, "__builtin_ia32_storehps", IX86_BUILTIN_STOREHPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
25806   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_storelps, "__builtin_ia32_storelps", IX86_BUILTIN_STORELPS, UNKNOWN, (int) VOID_FTYPE_PV2SF_V4SF },
25807
25808   /* SSE or 3DNow!A  */
25809   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_sfence, "__builtin_ia32_sfence", IX86_BUILTIN_SFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25810   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_sse_movntq, "__builtin_ia32_movntq", IX86_BUILTIN_MOVNTQ, UNKNOWN, (int) VOID_FTYPE_PULONGLONG_ULONGLONG },
25811
25812   /* SSE2 */
25813   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lfence, "__builtin_ia32_lfence", IX86_BUILTIN_LFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25814   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_mfence, 0, IX86_BUILTIN_MFENCE, UNKNOWN, (int) VOID_FTYPE_VOID },
25815   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_storeupd", IX86_BUILTIN_STOREUPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25816   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_storedqu", IX86_BUILTIN_STOREDQU, UNKNOWN, (int) VOID_FTYPE_PCHAR_V16QI },
25817   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2df, "__builtin_ia32_movntpd", IX86_BUILTIN_MOVNTPD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25818   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntv2di, "__builtin_ia32_movntdq", IX86_BUILTIN_MOVNTDQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI },
25819   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movntisi, "__builtin_ia32_movnti", IX86_BUILTIN_MOVNTI, UNKNOWN, (int) VOID_FTYPE_PINT_INT },
25820   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_movntidi, "__builtin_ia32_movnti64", IX86_BUILTIN_MOVNTI64, UNKNOWN, (int) VOID_FTYPE_PLONGLONG_LONGLONG },
25821   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movupd, "__builtin_ia32_loadupd", IX86_BUILTIN_LOADUPD, UNKNOWN, (int) V2DF_FTYPE_PCDOUBLE },
25822   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movdqu, "__builtin_ia32_loaddqu", IX86_BUILTIN_LOADDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
25823
25824   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadhpd_exp, "__builtin_ia32_loadhpd", IX86_BUILTIN_LOADHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
25825   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_loadlpd_exp, "__builtin_ia32_loadlpd", IX86_BUILTIN_LOADLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_PCDOUBLE },
25826
25827   /* SSE3 */
25828   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_lddqu, "__builtin_ia32_lddqu", IX86_BUILTIN_LDDQU, UNKNOWN, (int) V16QI_FTYPE_PCCHAR },
25829
25830   /* SSE4.1 */
25831   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_movntdqa, "__builtin_ia32_movntdqa", IX86_BUILTIN_MOVNTDQA, UNKNOWN, (int) V2DI_FTYPE_PV2DI },
25832
25833   /* SSE4A */
25834   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv2df, "__builtin_ia32_movntsd", IX86_BUILTIN_MOVNTSD, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V2DF },
25835   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_vmmovntv4sf, "__builtin_ia32_movntss", IX86_BUILTIN_MOVNTSS, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V4SF },
25836
25837   /* AVX */
25838   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroall, "__builtin_ia32_vzeroall", IX86_BUILTIN_VZEROALL, UNKNOWN, (int) VOID_FTYPE_VOID },
25839   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vzeroupper, "__builtin_ia32_vzeroupper", IX86_BUILTIN_VZEROUPPER, UNKNOWN, (int) VOID_FTYPE_VOID },
25840
25841   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4sf, "__builtin_ia32_vbroadcastss", IX86_BUILTIN_VBROADCASTSS, UNKNOWN, (int) V4SF_FTYPE_PCFLOAT },
25842   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv4df, "__builtin_ia32_vbroadcastsd256", IX86_BUILTIN_VBROADCASTSD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
25843   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_dupv8sf, "__builtin_ia32_vbroadcastss256", IX86_BUILTIN_VBROADCASTSS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
25844   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v4df, "__builtin_ia32_vbroadcastf128_pd256", IX86_BUILTIN_VBROADCASTPD256, UNKNOWN, (int) V4DF_FTYPE_PCV2DF },
25845   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vbroadcastf128_v8sf, "__builtin_ia32_vbroadcastf128_ps256", IX86_BUILTIN_VBROADCASTPS256, UNKNOWN, (int) V8SF_FTYPE_PCV4SF },
25846
25847   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_loadupd256", IX86_BUILTIN_LOADUPD256, UNKNOWN, (int) V4DF_FTYPE_PCDOUBLE },
25848   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_loadups256", IX86_BUILTIN_LOADUPS256, UNKNOWN, (int) V8SF_FTYPE_PCFLOAT },
25849   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movupd256, "__builtin_ia32_storeupd256", IX86_BUILTIN_STOREUPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
25850   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movups256, "__builtin_ia32_storeups256", IX86_BUILTIN_STOREUPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
25851   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_loaddqu256", IX86_BUILTIN_LOADDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
25852   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movdqu256, "__builtin_ia32_storedqu256", IX86_BUILTIN_STOREDQU256, UNKNOWN, (int) VOID_FTYPE_PCHAR_V32QI },
25853   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_lddqu256, "__builtin_ia32_lddqu256", IX86_BUILTIN_LDDQU256, UNKNOWN, (int) V32QI_FTYPE_PCCHAR },
25854
25855   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4di, "__builtin_ia32_movntdq256", IX86_BUILTIN_MOVNTDQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI },
25856   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv4df, "__builtin_ia32_movntpd256", IX86_BUILTIN_MOVNTPD256, UNKNOWN, (int) VOID_FTYPE_PDOUBLE_V4DF },
25857   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movntv8sf, "__builtin_ia32_movntps256", IX86_BUILTIN_MOVNTPS256, UNKNOWN, (int) VOID_FTYPE_PFLOAT_V8SF },
25858
25859   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd, "__builtin_ia32_maskloadpd", IX86_BUILTIN_MASKLOADPD, UNKNOWN, (int) V2DF_FTYPE_PCV2DF_V2DI },
25860   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps, "__builtin_ia32_maskloadps", IX86_BUILTIN_MASKLOADPS, UNKNOWN, (int) V4SF_FTYPE_PCV4SF_V4SI },
25861   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadpd256, "__builtin_ia32_maskloadpd256", IX86_BUILTIN_MASKLOADPD256, UNKNOWN, (int) V4DF_FTYPE_PCV4DF_V4DI },
25862   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskloadps256, "__builtin_ia32_maskloadps256", IX86_BUILTIN_MASKLOADPS256, UNKNOWN, (int) V8SF_FTYPE_PCV8SF_V8SI },
25863   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd, "__builtin_ia32_maskstorepd", IX86_BUILTIN_MASKSTOREPD, UNKNOWN, (int) VOID_FTYPE_PV2DF_V2DI_V2DF },
25864   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps, "__builtin_ia32_maskstoreps", IX86_BUILTIN_MASKSTOREPS, UNKNOWN, (int) VOID_FTYPE_PV4SF_V4SI_V4SF },
25865   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstorepd256, "__builtin_ia32_maskstorepd256", IX86_BUILTIN_MASKSTOREPD256, UNKNOWN, (int) VOID_FTYPE_PV4DF_V4DI_V4DF },
25866   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_maskstoreps256, "__builtin_ia32_maskstoreps256", IX86_BUILTIN_MASKSTOREPS256, UNKNOWN, (int) VOID_FTYPE_PV8SF_V8SI_V8SF },
25867
25868   /* AVX2 */
25869   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_movntdqa, "__builtin_ia32_movntdqa256", IX86_BUILTIN_MOVNTDQA256, UNKNOWN, (int) V4DI_FTYPE_PV4DI },
25870   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadd, "__builtin_ia32_maskloadd", IX86_BUILTIN_MASKLOADD, UNKNOWN, (int) V4SI_FTYPE_PCV4SI_V4SI },
25871   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadq, "__builtin_ia32_maskloadq", IX86_BUILTIN_MASKLOADQ, UNKNOWN, (int) V2DI_FTYPE_PCV2DI_V2DI },
25872   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadd256, "__builtin_ia32_maskloadd256", IX86_BUILTIN_MASKLOADD256, UNKNOWN, (int) V8SI_FTYPE_PCV8SI_V8SI },
25873   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskloadq256, "__builtin_ia32_maskloadq256", IX86_BUILTIN_MASKLOADQ256, UNKNOWN, (int) V4DI_FTYPE_PCV4DI_V4DI },
25874   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstored, "__builtin_ia32_maskstored", IX86_BUILTIN_MASKSTORED, UNKNOWN, (int) VOID_FTYPE_PV4SI_V4SI_V4SI },
25875   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstoreq, "__builtin_ia32_maskstoreq", IX86_BUILTIN_MASKSTOREQ, UNKNOWN, (int) VOID_FTYPE_PV2DI_V2DI_V2DI },
25876   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstored256, "__builtin_ia32_maskstored256", IX86_BUILTIN_MASKSTORED256, UNKNOWN, (int) VOID_FTYPE_PV8SI_V8SI_V8SI },
25877   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_maskstoreq256, "__builtin_ia32_maskstoreq256", IX86_BUILTIN_MASKSTOREQ256, UNKNOWN, (int) VOID_FTYPE_PV4DI_V4DI_V4DI },
25878
25879   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_llwpcb, "__builtin_ia32_llwpcb", IX86_BUILTIN_LLWPCB, UNKNOWN, (int) VOID_FTYPE_PVOID },
25880   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_slwpcb, "__builtin_ia32_slwpcb", IX86_BUILTIN_SLWPCB, UNKNOWN, (int) PVOID_FTYPE_VOID },
25881   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvalsi3, "__builtin_ia32_lwpval32", IX86_BUILTIN_LWPVAL32, UNKNOWN, (int) VOID_FTYPE_UINT_UINT_UINT },
25882   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpvaldi3, "__builtin_ia32_lwpval64", IX86_BUILTIN_LWPVAL64, UNKNOWN, (int) VOID_FTYPE_UINT64_UINT_UINT },
25883   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinssi3, "__builtin_ia32_lwpins32", IX86_BUILTIN_LWPINS32, UNKNOWN, (int) UCHAR_FTYPE_UINT_UINT_UINT },
25884   { OPTION_MASK_ISA_LWP, CODE_FOR_lwp_lwpinsdi3, "__builtin_ia32_lwpins64", IX86_BUILTIN_LWPINS64, UNKNOWN, (int) UCHAR_FTYPE_UINT64_UINT_UINT },
25885
25886   /* FSGSBASE */
25887   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasesi, "__builtin_ia32_rdfsbase32", IX86_BUILTIN_RDFSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
25888   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdfsbasedi, "__builtin_ia32_rdfsbase64", IX86_BUILTIN_RDFSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
25889   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasesi, "__builtin_ia32_rdgsbase32", IX86_BUILTIN_RDGSBASE32, UNKNOWN, (int) UNSIGNED_FTYPE_VOID },
25890   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_rdgsbasedi, "__builtin_ia32_rdgsbase64", IX86_BUILTIN_RDGSBASE64, UNKNOWN, (int) UINT64_FTYPE_VOID },
25891   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasesi, "__builtin_ia32_wrfsbase32", IX86_BUILTIN_WRFSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
25892   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrfsbasedi, "__builtin_ia32_wrfsbase64", IX86_BUILTIN_WRFSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
25893   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasesi, "__builtin_ia32_wrgsbase32", IX86_BUILTIN_WRGSBASE32, UNKNOWN, (int) VOID_FTYPE_UNSIGNED },
25894   { OPTION_MASK_ISA_FSGSBASE | OPTION_MASK_ISA_64BIT, CODE_FOR_wrgsbasedi, "__builtin_ia32_wrgsbase64", IX86_BUILTIN_WRGSBASE64, UNKNOWN, (int) VOID_FTYPE_UINT64 },
25895 };
25896
25897 /* Builtins with variable number of arguments.  */
25898 static const struct builtin_description bdesc_args[] =
25899 {
25900   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_bsr, "__builtin_ia32_bsrsi", IX86_BUILTIN_BSRSI, UNKNOWN, (int) INT_FTYPE_INT },
25901   { OPTION_MASK_ISA_64BIT, CODE_FOR_bsr_rex64, "__builtin_ia32_bsrdi", IX86_BUILTIN_BSRDI, UNKNOWN, (int) INT64_FTYPE_INT64 },
25902   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rdpmc, "__builtin_ia32_rdpmc", IX86_BUILTIN_RDPMC, UNKNOWN, (int) UINT64_FTYPE_INT },
25903   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlqi3, "__builtin_ia32_rolqi", IX86_BUILTIN_ROLQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
25904   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotlhi3, "__builtin_ia32_rolhi", IX86_BUILTIN_ROLHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
25905   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrqi3, "__builtin_ia32_rorqi", IX86_BUILTIN_RORQI, UNKNOWN, (int) UINT8_FTYPE_UINT8_INT },
25906   { ~OPTION_MASK_ISA_64BIT, CODE_FOR_rotrhi3, "__builtin_ia32_rorhi", IX86_BUILTIN_RORHI, UNKNOWN, (int) UINT16_FTYPE_UINT16_INT },
25907
25908   /* MMX */
25909   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv8qi3, "__builtin_ia32_paddb", IX86_BUILTIN_PADDB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25910   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv4hi3, "__builtin_ia32_paddw", IX86_BUILTIN_PADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25911   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_addv2si3, "__builtin_ia32_paddd", IX86_BUILTIN_PADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25912   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv8qi3, "__builtin_ia32_psubb", IX86_BUILTIN_PSUBB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25913   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv4hi3, "__builtin_ia32_psubw", IX86_BUILTIN_PSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25914   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_subv2si3, "__builtin_ia32_psubd", IX86_BUILTIN_PSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25915
25916   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv8qi3, "__builtin_ia32_paddsb", IX86_BUILTIN_PADDSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25917   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ssaddv4hi3, "__builtin_ia32_paddsw", IX86_BUILTIN_PADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25918   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv8qi3, "__builtin_ia32_psubsb", IX86_BUILTIN_PSUBSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25919   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_sssubv4hi3, "__builtin_ia32_psubsw", IX86_BUILTIN_PSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25920   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv8qi3, "__builtin_ia32_paddusb", IX86_BUILTIN_PADDUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25921   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_usaddv4hi3, "__builtin_ia32_paddusw", IX86_BUILTIN_PADDUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25922   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv8qi3, "__builtin_ia32_psubusb", IX86_BUILTIN_PSUBUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25923   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ussubv4hi3, "__builtin_ia32_psubusw", IX86_BUILTIN_PSUBUSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25924
25925   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_mulv4hi3, "__builtin_ia32_pmullw", IX86_BUILTIN_PMULLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25926   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_smulv4hi3_highpart, "__builtin_ia32_pmulhw", IX86_BUILTIN_PMULHW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25927
25928   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andv2si3, "__builtin_ia32_pand", IX86_BUILTIN_PAND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25929   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_andnotv2si3, "__builtin_ia32_pandn", IX86_BUILTIN_PANDN, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25930   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_iorv2si3, "__builtin_ia32_por", IX86_BUILTIN_POR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25931   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_xorv2si3, "__builtin_ia32_pxor", IX86_BUILTIN_PXOR, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25932
25933   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv8qi3, "__builtin_ia32_pcmpeqb", IX86_BUILTIN_PCMPEQB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25934   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv4hi3, "__builtin_ia32_pcmpeqw", IX86_BUILTIN_PCMPEQW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25935   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_eqv2si3, "__builtin_ia32_pcmpeqd", IX86_BUILTIN_PCMPEQD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25936   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv8qi3, "__builtin_ia32_pcmpgtb", IX86_BUILTIN_PCMPGTB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25937   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv4hi3, "__builtin_ia32_pcmpgtw", IX86_BUILTIN_PCMPGTW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25938   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_gtv2si3, "__builtin_ia32_pcmpgtd", IX86_BUILTIN_PCMPGTD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25939
25940   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhbw, "__builtin_ia32_punpckhbw", IX86_BUILTIN_PUNPCKHBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25941   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhwd, "__builtin_ia32_punpckhwd", IX86_BUILTIN_PUNPCKHWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25942   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckhdq, "__builtin_ia32_punpckhdq", IX86_BUILTIN_PUNPCKHDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
25943   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklbw, "__builtin_ia32_punpcklbw", IX86_BUILTIN_PUNPCKLBW, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25944   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpcklwd, "__builtin_ia32_punpcklwd", IX86_BUILTIN_PUNPCKLWD, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI},
25945   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_punpckldq, "__builtin_ia32_punpckldq", IX86_BUILTIN_PUNPCKLDQ, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI},
25946
25947   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packsswb, "__builtin_ia32_packsswb", IX86_BUILTIN_PACKSSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
25948   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packssdw, "__builtin_ia32_packssdw", IX86_BUILTIN_PACKSSDW, UNKNOWN, (int) V4HI_FTYPE_V2SI_V2SI },
25949   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_packuswb, "__builtin_ia32_packuswb", IX86_BUILTIN_PACKUSWB, UNKNOWN, (int) V8QI_FTYPE_V4HI_V4HI },
25950
25951   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_pmaddwd, "__builtin_ia32_pmaddwd", IX86_BUILTIN_PMADDWD, UNKNOWN, (int) V2SI_FTYPE_V4HI_V4HI },
25952
25953   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllwi", IX86_BUILTIN_PSLLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25954   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslldi", IX86_BUILTIN_PSLLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25955   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllqi", IX86_BUILTIN_PSLLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
25956   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv4hi3, "__builtin_ia32_psllw", IX86_BUILTIN_PSLLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25957   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv2si3, "__builtin_ia32_pslld", IX86_BUILTIN_PSLLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25958   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashlv1di3, "__builtin_ia32_psllq", IX86_BUILTIN_PSLLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
25959
25960   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlwi", IX86_BUILTIN_PSRLWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25961   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrldi", IX86_BUILTIN_PSRLDI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25962   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlqi", IX86_BUILTIN_PSRLQI, UNKNOWN, (int) V1DI_FTYPE_V1DI_SI_COUNT },
25963   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv4hi3, "__builtin_ia32_psrlw", IX86_BUILTIN_PSRLW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25964   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv2si3, "__builtin_ia32_psrld", IX86_BUILTIN_PSRLD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25965   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_lshrv1di3, "__builtin_ia32_psrlq", IX86_BUILTIN_PSRLQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_COUNT },
25966
25967   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psrawi", IX86_BUILTIN_PSRAWI, UNKNOWN, (int) V4HI_FTYPE_V4HI_SI_COUNT },
25968   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psradi", IX86_BUILTIN_PSRADI, UNKNOWN, (int) V2SI_FTYPE_V2SI_SI_COUNT },
25969   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv4hi3, "__builtin_ia32_psraw", IX86_BUILTIN_PSRAW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI_COUNT },
25970   { OPTION_MASK_ISA_MMX, CODE_FOR_mmx_ashrv2si3, "__builtin_ia32_psrad", IX86_BUILTIN_PSRAD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI_COUNT },
25971
25972   /* 3DNow! */
25973   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pf2id, "__builtin_ia32_pf2id", IX86_BUILTIN_PF2ID, UNKNOWN, (int) V2SI_FTYPE_V2SF },
25974   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_floatv2si2, "__builtin_ia32_pi2fd", IX86_BUILTIN_PI2FD, UNKNOWN, (int) V2SF_FTYPE_V2SI },
25975   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpv2sf2, "__builtin_ia32_pfrcp", IX86_BUILTIN_PFRCP, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25976   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqrtv2sf2, "__builtin_ia32_pfrsqrt", IX86_BUILTIN_PFRSQRT, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25977
25978   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_uavgv8qi3, "__builtin_ia32_pavgusb", IX86_BUILTIN_PAVGUSB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
25979   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_haddv2sf3, "__builtin_ia32_pfacc", IX86_BUILTIN_PFACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25980   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_addv2sf3, "__builtin_ia32_pfadd", IX86_BUILTIN_PFADD, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25981   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_eqv2sf3, "__builtin_ia32_pfcmpeq", IX86_BUILTIN_PFCMPEQ, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25982   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gev2sf3, "__builtin_ia32_pfcmpge", IX86_BUILTIN_PFCMPGE, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25983   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_gtv2sf3, "__builtin_ia32_pfcmpgt", IX86_BUILTIN_PFCMPGT, UNKNOWN, (int) V2SI_FTYPE_V2SF_V2SF },
25984   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_smaxv2sf3, "__builtin_ia32_pfmax", IX86_BUILTIN_PFMAX, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25985   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_sminv2sf3, "__builtin_ia32_pfmin", IX86_BUILTIN_PFMIN, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25986   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_mulv2sf3, "__builtin_ia32_pfmul", IX86_BUILTIN_PFMUL, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25987   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit1v2sf3, "__builtin_ia32_pfrcpit1", IX86_BUILTIN_PFRCPIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25988   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rcpit2v2sf3, "__builtin_ia32_pfrcpit2", IX86_BUILTIN_PFRCPIT2, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25989   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_rsqit1v2sf3, "__builtin_ia32_pfrsqit1", IX86_BUILTIN_PFRSQIT1, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25990   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subv2sf3, "__builtin_ia32_pfsub", IX86_BUILTIN_PFSUB, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25991   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_subrv2sf3, "__builtin_ia32_pfsubr", IX86_BUILTIN_PFSUBR, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
25992   { OPTION_MASK_ISA_3DNOW, CODE_FOR_mmx_pmulhrwv4hi3, "__builtin_ia32_pmulhrw", IX86_BUILTIN_PMULHRW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
25993
25994   /* 3DNow!A */
25995   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pf2iw, "__builtin_ia32_pf2iw", IX86_BUILTIN_PF2IW, UNKNOWN, (int) V2SI_FTYPE_V2SF },
25996   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pi2fw, "__builtin_ia32_pi2fw", IX86_BUILTIN_PI2FW, UNKNOWN, (int) V2SF_FTYPE_V2SI },
25997   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2si2, "__builtin_ia32_pswapdsi", IX86_BUILTIN_PSWAPDSI, UNKNOWN, (int) V2SI_FTYPE_V2SI },
25998   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pswapdv2sf2, "__builtin_ia32_pswapdsf", IX86_BUILTIN_PSWAPDSF, UNKNOWN, (int) V2SF_FTYPE_V2SF },
25999   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_hsubv2sf3, "__builtin_ia32_pfnacc", IX86_BUILTIN_PFNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
26000   { OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_addsubv2sf3, "__builtin_ia32_pfpnacc", IX86_BUILTIN_PFPNACC, UNKNOWN, (int) V2SF_FTYPE_V2SF_V2SF },
26001
26002   /* SSE */
26003   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movmskps, "__builtin_ia32_movmskps", IX86_BUILTIN_MOVMSKPS, UNKNOWN, (int) INT_FTYPE_V4SF },
26004   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_sqrtv4sf2, "__builtin_ia32_sqrtps", IX86_BUILTIN_SQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26005   { OPTION_MASK_ISA_SSE, CODE_FOR_sqrtv4sf2, "__builtin_ia32_sqrtps_nr", IX86_BUILTIN_SQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26006   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rsqrtv4sf2, "__builtin_ia32_rsqrtps", IX86_BUILTIN_RSQRTPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26007   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtv4sf2, "__builtin_ia32_rsqrtps_nr", IX86_BUILTIN_RSQRTPS_NR, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26008   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_rcpv4sf2, "__builtin_ia32_rcpps", IX86_BUILTIN_RCPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26009   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtps2pi, "__builtin_ia32_cvtps2pi", IX86_BUILTIN_CVTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
26010   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtss2si, "__builtin_ia32_cvtss2si", IX86_BUILTIN_CVTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
26011   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtss2siq, "__builtin_ia32_cvtss2si64", IX86_BUILTIN_CVTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
26012   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttps2pi, "__builtin_ia32_cvttps2pi", IX86_BUILTIN_CVTTPS2PI, UNKNOWN, (int) V2SI_FTYPE_V4SF },
26013   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvttss2si, "__builtin_ia32_cvttss2si", IX86_BUILTIN_CVTTSS2SI, UNKNOWN, (int) INT_FTYPE_V4SF },
26014   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvttss2siq, "__builtin_ia32_cvttss2si64", IX86_BUILTIN_CVTTSS2SI64, UNKNOWN, (int) INT64_FTYPE_V4SF },
26015
26016   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_shufps, "__builtin_ia32_shufps", IX86_BUILTIN_SHUFPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26017
26018   { OPTION_MASK_ISA_SSE, CODE_FOR_addv4sf3, "__builtin_ia32_addps", IX86_BUILTIN_ADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26019   { OPTION_MASK_ISA_SSE, CODE_FOR_subv4sf3, "__builtin_ia32_subps", IX86_BUILTIN_SUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26020   { OPTION_MASK_ISA_SSE, CODE_FOR_mulv4sf3, "__builtin_ia32_mulps", IX86_BUILTIN_MULPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26021   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_divv4sf3, "__builtin_ia32_divps", IX86_BUILTIN_DIVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26022   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmaddv4sf3,  "__builtin_ia32_addss", IX86_BUILTIN_ADDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26023   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsubv4sf3,  "__builtin_ia32_subss", IX86_BUILTIN_SUBSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26024   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmulv4sf3,  "__builtin_ia32_mulss", IX86_BUILTIN_MULSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26025   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmdivv4sf3,  "__builtin_ia32_divss", IX86_BUILTIN_DIVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26026
26027   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpeqps", IX86_BUILTIN_CMPEQPS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
26028   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpltps", IX86_BUILTIN_CMPLTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
26029   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpleps", IX86_BUILTIN_CMPLEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
26030   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgtps", IX86_BUILTIN_CMPGTPS, LT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
26031   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpgeps", IX86_BUILTIN_CMPGEPS, LE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
26032   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpunordps", IX86_BUILTIN_CMPUNORDPS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
26033   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpneqps", IX86_BUILTIN_CMPNEQPS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
26034   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnltps", IX86_BUILTIN_CMPNLTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
26035   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpnleps", IX86_BUILTIN_CMPNLEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
26036   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngtps", IX86_BUILTIN_CMPNGTPS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
26037   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpngeps", IX86_BUILTIN_CMPNGEPS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP},
26038   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_maskcmpv4sf3, "__builtin_ia32_cmpordps", IX86_BUILTIN_CMPORDPS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
26039   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpeqss", IX86_BUILTIN_CMPEQSS, EQ, (int) V4SF_FTYPE_V4SF_V4SF },
26040   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpltss", IX86_BUILTIN_CMPLTSS, LT, (int) V4SF_FTYPE_V4SF_V4SF },
26041   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpless", IX86_BUILTIN_CMPLESS, LE, (int) V4SF_FTYPE_V4SF_V4SF },
26042   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpunordss", IX86_BUILTIN_CMPUNORDSS, UNORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
26043   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpneqss", IX86_BUILTIN_CMPNEQSS, NE, (int) V4SF_FTYPE_V4SF_V4SF },
26044   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnltss", IX86_BUILTIN_CMPNLTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF },
26045   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpnless", IX86_BUILTIN_CMPNLESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF },
26046   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngtss", IX86_BUILTIN_CMPNGTSS, UNGE, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
26047   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpngess", IX86_BUILTIN_CMPNGESS, UNGT, (int) V4SF_FTYPE_V4SF_V4SF_SWAP },
26048   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmmaskcmpv4sf3, "__builtin_ia32_cmpordss", IX86_BUILTIN_CMPORDSS, ORDERED, (int) V4SF_FTYPE_V4SF_V4SF },
26049
26050   { OPTION_MASK_ISA_SSE, CODE_FOR_sminv4sf3, "__builtin_ia32_minps", IX86_BUILTIN_MINPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26051   { OPTION_MASK_ISA_SSE, CODE_FOR_smaxv4sf3, "__builtin_ia32_maxps", IX86_BUILTIN_MAXPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26052   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsminv4sf3, "__builtin_ia32_minss", IX86_BUILTIN_MINSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26053   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsmaxv4sf3, "__builtin_ia32_maxss", IX86_BUILTIN_MAXSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26054
26055   { OPTION_MASK_ISA_SSE, CODE_FOR_andv4sf3, "__builtin_ia32_andps", IX86_BUILTIN_ANDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26056   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_andnotv4sf3,  "__builtin_ia32_andnps", IX86_BUILTIN_ANDNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26057   { OPTION_MASK_ISA_SSE, CODE_FOR_iorv4sf3, "__builtin_ia32_orps", IX86_BUILTIN_ORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26058   { OPTION_MASK_ISA_SSE, CODE_FOR_xorv4sf3,  "__builtin_ia32_xorps", IX86_BUILTIN_XORPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26059
26060   { OPTION_MASK_ISA_SSE, CODE_FOR_copysignv4sf3,  "__builtin_ia32_copysignps", IX86_BUILTIN_CPYSGNPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26061
26062   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movss,  "__builtin_ia32_movss", IX86_BUILTIN_MOVSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26063   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movhlps_exp,  "__builtin_ia32_movhlps", IX86_BUILTIN_MOVHLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26064   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_movlhps_exp,  "__builtin_ia32_movlhps", IX86_BUILTIN_MOVLHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26065   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_highv4sf, "__builtin_ia32_unpckhps", IX86_BUILTIN_UNPCKHPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26066   { OPTION_MASK_ISA_SSE, CODE_FOR_vec_interleave_lowv4sf, "__builtin_ia32_unpcklps", IX86_BUILTIN_UNPCKLPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26067
26068   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtpi2ps, "__builtin_ia32_cvtpi2ps", IX86_BUILTIN_CVTPI2PS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2SI },
26069   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_cvtsi2ss, "__builtin_ia32_cvtsi2ss", IX86_BUILTIN_CVTSI2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_SI },
26070   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_64BIT, CODE_FOR_sse_cvtsi2ssq, "__builtin_ia32_cvtsi642ss", IX86_BUILTIN_CVTSI642SS, UNKNOWN, V4SF_FTYPE_V4SF_DI },
26071
26072   { OPTION_MASK_ISA_SSE, CODE_FOR_rsqrtsf2, "__builtin_ia32_rsqrtf", IX86_BUILTIN_RSQRTF, UNKNOWN, (int) FLOAT_FTYPE_FLOAT },
26073
26074   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmsqrtv4sf2, "__builtin_ia32_sqrtss", IX86_BUILTIN_SQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
26075   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrsqrtv4sf2, "__builtin_ia32_rsqrtss", IX86_BUILTIN_RSQRTSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
26076   { OPTION_MASK_ISA_SSE, CODE_FOR_sse_vmrcpv4sf2, "__builtin_ia32_rcpss", IX86_BUILTIN_RCPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_VEC_MERGE },
26077
26078   /* SSE MMX or 3Dnow!A */
26079   { 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 },
26080   { 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 },
26081   { 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 },
26082
26083   { 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 },
26084   { 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 },
26085   { 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 },
26086   { 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 },
26087
26088   { 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 },
26089   { OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A, CODE_FOR_mmx_pmovmskb, "__builtin_ia32_pmovmskb", IX86_BUILTIN_PMOVMSKB, UNKNOWN, (int) INT_FTYPE_V8QI },
26090
26091   { 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 },
26092
26093   /* SSE2 */
26094   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_shufpd, "__builtin_ia32_shufpd", IX86_BUILTIN_SHUFPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26095
26096   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movmskpd, "__builtin_ia32_movmskpd", IX86_BUILTIN_MOVMSKPD, UNKNOWN, (int) INT_FTYPE_V2DF  },
26097   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmovmskb, "__builtin_ia32_pmovmskb128", IX86_BUILTIN_PMOVMSKB128, UNKNOWN, (int) INT_FTYPE_V16QI },
26098   { OPTION_MASK_ISA_SSE2, CODE_FOR_sqrtv2df2, "__builtin_ia32_sqrtpd", IX86_BUILTIN_SQRTPD, UNKNOWN, (int) V2DF_FTYPE_V2DF },
26099   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtdq2pd, "__builtin_ia32_cvtdq2pd", IX86_BUILTIN_CVTDQ2PD, UNKNOWN, (int) V2DF_FTYPE_V4SI },
26100   { OPTION_MASK_ISA_SSE2, CODE_FOR_floatv4siv4sf2, "__builtin_ia32_cvtdq2ps", IX86_BUILTIN_CVTDQ2PS, UNKNOWN, (int) V4SF_FTYPE_V4SI },
26101
26102   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2dq, "__builtin_ia32_cvtpd2dq", IX86_BUILTIN_CVTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
26103   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2pi, "__builtin_ia32_cvtpd2pi", IX86_BUILTIN_CVTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
26104   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpd2ps, "__builtin_ia32_cvtpd2ps", IX86_BUILTIN_CVTPD2PS, UNKNOWN, (int) V4SF_FTYPE_V2DF },
26105   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2dq, "__builtin_ia32_cvttpd2dq", IX86_BUILTIN_CVTTPD2DQ, UNKNOWN, (int) V4SI_FTYPE_V2DF },
26106   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttpd2pi, "__builtin_ia32_cvttpd2pi", IX86_BUILTIN_CVTTPD2PI, UNKNOWN, (int) V2SI_FTYPE_V2DF },
26107
26108   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtpi2pd, "__builtin_ia32_cvtpi2pd", IX86_BUILTIN_CVTPI2PD, UNKNOWN, (int) V2DF_FTYPE_V2SI },
26109
26110   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2si, "__builtin_ia32_cvtsd2si", IX86_BUILTIN_CVTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
26111   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvttsd2si, "__builtin_ia32_cvttsd2si", IX86_BUILTIN_CVTTSD2SI, UNKNOWN, (int) INT_FTYPE_V2DF },
26112   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsd2siq, "__builtin_ia32_cvtsd2si64", IX86_BUILTIN_CVTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
26113   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvttsd2siq, "__builtin_ia32_cvttsd2si64", IX86_BUILTIN_CVTTSD2SI64, UNKNOWN, (int) INT64_FTYPE_V2DF },
26114
26115   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2dq, "__builtin_ia32_cvtps2dq", IX86_BUILTIN_CVTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
26116   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtps2pd, "__builtin_ia32_cvtps2pd", IX86_BUILTIN_CVTPS2PD, UNKNOWN, (int) V2DF_FTYPE_V4SF },
26117   { OPTION_MASK_ISA_SSE2, CODE_FOR_fix_truncv4sfv4si2, "__builtin_ia32_cvttps2dq", IX86_BUILTIN_CVTTPS2DQ, UNKNOWN, (int) V4SI_FTYPE_V4SF },
26118
26119   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2df3, "__builtin_ia32_addpd", IX86_BUILTIN_ADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26120   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2df3, "__builtin_ia32_subpd", IX86_BUILTIN_SUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26121   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv2df3, "__builtin_ia32_mulpd", IX86_BUILTIN_MULPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26122   { OPTION_MASK_ISA_SSE2, CODE_FOR_divv2df3, "__builtin_ia32_divpd", IX86_BUILTIN_DIVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26123   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmaddv2df3,  "__builtin_ia32_addsd", IX86_BUILTIN_ADDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26124   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsubv2df3,  "__builtin_ia32_subsd", IX86_BUILTIN_SUBSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26125   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmulv2df3,  "__builtin_ia32_mulsd", IX86_BUILTIN_MULSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26126   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmdivv2df3,  "__builtin_ia32_divsd", IX86_BUILTIN_DIVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26127
26128   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpeqpd", IX86_BUILTIN_CMPEQPD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
26129   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpltpd", IX86_BUILTIN_CMPLTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
26130   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmplepd", IX86_BUILTIN_CMPLEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
26131   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgtpd", IX86_BUILTIN_CMPGTPD, LT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
26132   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpgepd", IX86_BUILTIN_CMPGEPD, LE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP},
26133   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpunordpd", IX86_BUILTIN_CMPUNORDPD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
26134   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpneqpd", IX86_BUILTIN_CMPNEQPD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
26135   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnltpd", IX86_BUILTIN_CMPNLTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
26136   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpnlepd", IX86_BUILTIN_CMPNLEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
26137   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngtpd", IX86_BUILTIN_CMPNGTPD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
26138   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpngepd", IX86_BUILTIN_CMPNGEPD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF_SWAP },
26139   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_maskcmpv2df3, "__builtin_ia32_cmpordpd", IX86_BUILTIN_CMPORDPD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
26140   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpeqsd", IX86_BUILTIN_CMPEQSD, EQ, (int) V2DF_FTYPE_V2DF_V2DF },
26141   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpltsd", IX86_BUILTIN_CMPLTSD, LT, (int) V2DF_FTYPE_V2DF_V2DF },
26142   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmplesd", IX86_BUILTIN_CMPLESD, LE, (int) V2DF_FTYPE_V2DF_V2DF },
26143   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpunordsd", IX86_BUILTIN_CMPUNORDSD, UNORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
26144   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpneqsd", IX86_BUILTIN_CMPNEQSD, NE, (int) V2DF_FTYPE_V2DF_V2DF },
26145   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnltsd", IX86_BUILTIN_CMPNLTSD, UNGE, (int) V2DF_FTYPE_V2DF_V2DF },
26146   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpnlesd", IX86_BUILTIN_CMPNLESD, UNGT, (int) V2DF_FTYPE_V2DF_V2DF },
26147   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmmaskcmpv2df3, "__builtin_ia32_cmpordsd", IX86_BUILTIN_CMPORDSD, ORDERED, (int) V2DF_FTYPE_V2DF_V2DF },
26148
26149   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv2df3, "__builtin_ia32_minpd", IX86_BUILTIN_MINPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26150   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv2df3, "__builtin_ia32_maxpd", IX86_BUILTIN_MAXPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26151   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsminv2df3, "__builtin_ia32_minsd", IX86_BUILTIN_MINSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26152   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsmaxv2df3, "__builtin_ia32_maxsd", IX86_BUILTIN_MAXSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26153
26154   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2df3, "__builtin_ia32_andpd", IX86_BUILTIN_ANDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26155   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2df3,  "__builtin_ia32_andnpd", IX86_BUILTIN_ANDNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26156   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2df3, "__builtin_ia32_orpd", IX86_BUILTIN_ORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26157   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2df3,  "__builtin_ia32_xorpd", IX86_BUILTIN_XORPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26158
26159   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysignv2df3,  "__builtin_ia32_copysignpd", IX86_BUILTIN_CPYSGNPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26160
26161   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_movsd,  "__builtin_ia32_movsd", IX86_BUILTIN_MOVSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26162   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2df, "__builtin_ia32_unpckhpd", IX86_BUILTIN_UNPCKHPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26163   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2df, "__builtin_ia32_unpcklpd", IX86_BUILTIN_UNPCKLPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26164
26165   { 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 },
26166
26167   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv16qi3, "__builtin_ia32_paddb128", IX86_BUILTIN_PADDB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26168   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv8hi3, "__builtin_ia32_paddw128", IX86_BUILTIN_PADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26169   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv4si3, "__builtin_ia32_paddd128", IX86_BUILTIN_PADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26170   { OPTION_MASK_ISA_SSE2, CODE_FOR_addv2di3, "__builtin_ia32_paddq128", IX86_BUILTIN_PADDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26171   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv16qi3, "__builtin_ia32_psubb128", IX86_BUILTIN_PSUBB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26172   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv8hi3, "__builtin_ia32_psubw128", IX86_BUILTIN_PSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26173   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv4si3, "__builtin_ia32_psubd128", IX86_BUILTIN_PSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26174   { OPTION_MASK_ISA_SSE2, CODE_FOR_subv2di3, "__builtin_ia32_psubq128", IX86_BUILTIN_PSUBQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26175
26176   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv16qi3, "__builtin_ia32_paddsb128", IX86_BUILTIN_PADDSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26177   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ssaddv8hi3, "__builtin_ia32_paddsw128", IX86_BUILTIN_PADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26178   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv16qi3, "__builtin_ia32_psubsb128", IX86_BUILTIN_PSUBSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26179   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_sssubv8hi3, "__builtin_ia32_psubsw128", IX86_BUILTIN_PSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26180   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv16qi3, "__builtin_ia32_paddusb128", IX86_BUILTIN_PADDUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26181   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_usaddv8hi3, "__builtin_ia32_paddusw128", IX86_BUILTIN_PADDUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26182   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv16qi3, "__builtin_ia32_psubusb128", IX86_BUILTIN_PSUBUSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26183   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ussubv8hi3, "__builtin_ia32_psubusw128", IX86_BUILTIN_PSUBUSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26184
26185   { OPTION_MASK_ISA_SSE2, CODE_FOR_mulv8hi3, "__builtin_ia32_pmullw128", IX86_BUILTIN_PMULLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26186   { OPTION_MASK_ISA_SSE2, CODE_FOR_smulv8hi3_highpart, "__builtin_ia32_pmulhw128", IX86_BUILTIN_PMULHW128, UNKNOWN,(int) V8HI_FTYPE_V8HI_V8HI },
26187
26188   { OPTION_MASK_ISA_SSE2, CODE_FOR_andv2di3, "__builtin_ia32_pand128", IX86_BUILTIN_PAND128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26189   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_andnotv2di3, "__builtin_ia32_pandn128", IX86_BUILTIN_PANDN128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26190   { OPTION_MASK_ISA_SSE2, CODE_FOR_iorv2di3, "__builtin_ia32_por128", IX86_BUILTIN_POR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26191   { OPTION_MASK_ISA_SSE2, CODE_FOR_xorv2di3, "__builtin_ia32_pxor128", IX86_BUILTIN_PXOR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26192
26193   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv16qi3, "__builtin_ia32_pavgb128", IX86_BUILTIN_PAVGB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26194   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_uavgv8hi3, "__builtin_ia32_pavgw128", IX86_BUILTIN_PAVGW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26195
26196   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv16qi3, "__builtin_ia32_pcmpeqb128", IX86_BUILTIN_PCMPEQB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26197   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv8hi3, "__builtin_ia32_pcmpeqw128", IX86_BUILTIN_PCMPEQW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26198   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_eqv4si3, "__builtin_ia32_pcmpeqd128", IX86_BUILTIN_PCMPEQD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
26199   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv16qi3, "__builtin_ia32_pcmpgtb128", IX86_BUILTIN_PCMPGTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26200   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv8hi3, "__builtin_ia32_pcmpgtw128", IX86_BUILTIN_PCMPGTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26201   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_gtv4si3, "__builtin_ia32_pcmpgtd128", IX86_BUILTIN_PCMPGTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI  },
26202
26203   { OPTION_MASK_ISA_SSE2, CODE_FOR_umaxv16qi3, "__builtin_ia32_pmaxub128", IX86_BUILTIN_PMAXUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26204   { OPTION_MASK_ISA_SSE2, CODE_FOR_smaxv8hi3, "__builtin_ia32_pmaxsw128", IX86_BUILTIN_PMAXSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26205   { OPTION_MASK_ISA_SSE2, CODE_FOR_uminv16qi3, "__builtin_ia32_pminub128", IX86_BUILTIN_PMINUB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26206   { OPTION_MASK_ISA_SSE2, CODE_FOR_sminv8hi3, "__builtin_ia32_pminsw128", IX86_BUILTIN_PMINSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26207
26208   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv16qi, "__builtin_ia32_punpckhbw128", IX86_BUILTIN_PUNPCKHBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26209   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv8hi, "__builtin_ia32_punpckhwd128", IX86_BUILTIN_PUNPCKHWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI  },
26210   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv4si, "__builtin_ia32_punpckhdq128", IX86_BUILTIN_PUNPCKHDQ128, UNKNOWN,  (int) V4SI_FTYPE_V4SI_V4SI },
26211   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_highv2di, "__builtin_ia32_punpckhqdq128", IX86_BUILTIN_PUNPCKHQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26212   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv16qi, "__builtin_ia32_punpcklbw128", IX86_BUILTIN_PUNPCKLBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26213   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv8hi, "__builtin_ia32_punpcklwd128", IX86_BUILTIN_PUNPCKLWD128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26214   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv4si, "__builtin_ia32_punpckldq128", IX86_BUILTIN_PUNPCKLDQ128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26215   { OPTION_MASK_ISA_SSE2, CODE_FOR_vec_interleave_lowv2di, "__builtin_ia32_punpcklqdq128", IX86_BUILTIN_PUNPCKLQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26216
26217   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packsswb, "__builtin_ia32_packsswb128", IX86_BUILTIN_PACKSSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
26218   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packssdw, "__builtin_ia32_packssdw128", IX86_BUILTIN_PACKSSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
26219   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_packuswb, "__builtin_ia32_packuswb128", IX86_BUILTIN_PACKUSWB128, UNKNOWN, (int) V16QI_FTYPE_V8HI_V8HI },
26220
26221   { OPTION_MASK_ISA_SSE2, CODE_FOR_umulv8hi3_highpart, "__builtin_ia32_pmulhuw128", IX86_BUILTIN_PMULHUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26222   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_psadbw, "__builtin_ia32_psadbw128", IX86_BUILTIN_PSADBW128, UNKNOWN, (int) V2DI_FTYPE_V16QI_V16QI },
26223
26224   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv1siv1di3, "__builtin_ia32_pmuludq", IX86_BUILTIN_PMULUDQ, UNKNOWN, (int) V1DI_FTYPE_V2SI_V2SI },
26225   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_umulv2siv2di3, "__builtin_ia32_pmuludq128", IX86_BUILTIN_PMULUDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
26226
26227   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pmaddwd, "__builtin_ia32_pmaddwd128", IX86_BUILTIN_PMADDWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI_V8HI },
26228
26229   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsi2sd, "__builtin_ia32_cvtsi2sd", IX86_BUILTIN_CVTSI2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_SI },
26230   { OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_64BIT, CODE_FOR_sse2_cvtsi2sdq, "__builtin_ia32_cvtsi642sd", IX86_BUILTIN_CVTSI642SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_DI },
26231   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtsd2ss, "__builtin_ia32_cvtsd2ss", IX86_BUILTIN_CVTSD2SS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF },
26232   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_cvtss2sd, "__builtin_ia32_cvtss2sd", IX86_BUILTIN_CVTSS2SD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V4SF },
26233
26234   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_ashlv1ti3, "__builtin_ia32_pslldqi128", IX86_BUILTIN_PSLLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
26235   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllwi128", IX86_BUILTIN_PSLLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
26236   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslldi128", IX86_BUILTIN_PSLLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
26237   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllqi128", IX86_BUILTIN_PSLLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
26238   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv8hi3, "__builtin_ia32_psllw128", IX86_BUILTIN_PSLLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
26239   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv4si3, "__builtin_ia32_pslld128", IX86_BUILTIN_PSLLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
26240   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashlv2di3, "__builtin_ia32_psllq128", IX86_BUILTIN_PSLLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
26241
26242   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_lshrv1ti3, "__builtin_ia32_psrldqi128", IX86_BUILTIN_PSRLDQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT_CONVERT },
26243   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlwi128", IX86_BUILTIN_PSRLWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
26244   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrldi128", IX86_BUILTIN_PSRLDI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
26245   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlqi128", IX86_BUILTIN_PSRLQI128, UNKNOWN, (int) V2DI_FTYPE_V2DI_SI_COUNT },
26246   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv8hi3, "__builtin_ia32_psrlw128", IX86_BUILTIN_PSRLW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
26247   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv4si3, "__builtin_ia32_psrld128", IX86_BUILTIN_PSRLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
26248   { OPTION_MASK_ISA_SSE2, CODE_FOR_lshrv2di3, "__builtin_ia32_psrlq128", IX86_BUILTIN_PSRLQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_COUNT },
26249
26250   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psrawi128", IX86_BUILTIN_PSRAWI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_SI_COUNT },
26251   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psradi128", IX86_BUILTIN_PSRADI128, UNKNOWN, (int) V4SI_FTYPE_V4SI_SI_COUNT },
26252   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv8hi3, "__builtin_ia32_psraw128", IX86_BUILTIN_PSRAW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_COUNT },
26253   { OPTION_MASK_ISA_SSE2, CODE_FOR_ashrv4si3, "__builtin_ia32_psrad128", IX86_BUILTIN_PSRAD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_COUNT },
26254
26255   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufd, "__builtin_ia32_pshufd", IX86_BUILTIN_PSHUFD, UNKNOWN, (int) V4SI_FTYPE_V4SI_INT },
26256   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshuflw, "__builtin_ia32_pshuflw", IX86_BUILTIN_PSHUFLW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
26257   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_pshufhw, "__builtin_ia32_pshufhw", IX86_BUILTIN_PSHUFHW, UNKNOWN, (int) V8HI_FTYPE_V8HI_INT },
26258
26259   { OPTION_MASK_ISA_SSE2, CODE_FOR_sse2_vmsqrtv2df2, "__builtin_ia32_sqrtsd", IX86_BUILTIN_SQRTSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_VEC_MERGE },
26260
26261   { OPTION_MASK_ISA_SSE2, CODE_FOR_abstf2, 0, IX86_BUILTIN_FABSQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128 },
26262   { OPTION_MASK_ISA_SSE2, CODE_FOR_copysigntf3, 0, IX86_BUILTIN_COPYSIGNQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128_FLOAT128 },
26263
26264   { OPTION_MASK_ISA_SSE, CODE_FOR_sse2_movq128, "__builtin_ia32_movq128", IX86_BUILTIN_MOVQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
26265
26266   /* SSE2 MMX */
26267   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_addv1di3, "__builtin_ia32_paddq", IX86_BUILTIN_PADDQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
26268   { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_subv1di3, "__builtin_ia32_psubq", IX86_BUILTIN_PSUBQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI },
26269
26270   /* SSE3 */
26271   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movshdup, "__builtin_ia32_movshdup", IX86_BUILTIN_MOVSHDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF},
26272   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_movsldup, "__builtin_ia32_movsldup", IX86_BUILTIN_MOVSLDUP, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26273
26274   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv4sf3, "__builtin_ia32_addsubps", IX86_BUILTIN_ADDSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26275   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_addsubv2df3, "__builtin_ia32_addsubpd", IX86_BUILTIN_ADDSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26276   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv4sf3, "__builtin_ia32_haddps", IX86_BUILTIN_HADDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26277   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_haddv2df3, "__builtin_ia32_haddpd", IX86_BUILTIN_HADDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26278   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv4sf3, "__builtin_ia32_hsubps", IX86_BUILTIN_HSUBPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF },
26279   { OPTION_MASK_ISA_SSE3, CODE_FOR_sse3_hsubv2df3, "__builtin_ia32_hsubpd", IX86_BUILTIN_HSUBPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF },
26280
26281   /* SSSE3 */
26282   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv16qi2, "__builtin_ia32_pabsb128", IX86_BUILTIN_PABSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
26283   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8qi2, "__builtin_ia32_pabsb", IX86_BUILTIN_PABSB, UNKNOWN, (int) V8QI_FTYPE_V8QI },
26284   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv8hi2, "__builtin_ia32_pabsw128", IX86_BUILTIN_PABSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
26285   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4hi2, "__builtin_ia32_pabsw", IX86_BUILTIN_PABSW, UNKNOWN, (int) V4HI_FTYPE_V4HI },
26286   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv4si2, "__builtin_ia32_pabsd128", IX86_BUILTIN_PABSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
26287   { OPTION_MASK_ISA_SSSE3, CODE_FOR_absv2si2, "__builtin_ia32_pabsd", IX86_BUILTIN_PABSD, UNKNOWN, (int) V2SI_FTYPE_V2SI },
26288
26289   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv8hi3, "__builtin_ia32_phaddw128", IX86_BUILTIN_PHADDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26290   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddwv4hi3, "__builtin_ia32_phaddw", IX86_BUILTIN_PHADDW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26291   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv4si3, "__builtin_ia32_phaddd128", IX86_BUILTIN_PHADDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26292   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phadddv2si3, "__builtin_ia32_phaddd", IX86_BUILTIN_PHADDD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
26293   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv8hi3, "__builtin_ia32_phaddsw128", IX86_BUILTIN_PHADDSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26294   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phaddswv4hi3, "__builtin_ia32_phaddsw", IX86_BUILTIN_PHADDSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26295   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv8hi3, "__builtin_ia32_phsubw128", IX86_BUILTIN_PHSUBW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26296   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubwv4hi3, "__builtin_ia32_phsubw", IX86_BUILTIN_PHSUBW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26297   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv4si3, "__builtin_ia32_phsubd128", IX86_BUILTIN_PHSUBD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26298   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubdv2si3, "__builtin_ia32_phsubd", IX86_BUILTIN_PHSUBD, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
26299   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv8hi3, "__builtin_ia32_phsubsw128", IX86_BUILTIN_PHSUBSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26300   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_phsubswv4hi3, "__builtin_ia32_phsubsw", IX86_BUILTIN_PHSUBSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26301   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw128, "__builtin_ia32_pmaddubsw128", IX86_BUILTIN_PMADDUBSW128, UNKNOWN, (int) V8HI_FTYPE_V16QI_V16QI },
26302   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmaddubsw, "__builtin_ia32_pmaddubsw", IX86_BUILTIN_PMADDUBSW, UNKNOWN, (int) V4HI_FTYPE_V8QI_V8QI },
26303   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv8hi3, "__builtin_ia32_pmulhrsw128", IX86_BUILTIN_PMULHRSW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26304   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pmulhrswv4hi3, "__builtin_ia32_pmulhrsw", IX86_BUILTIN_PMULHRSW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26305   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv16qi3, "__builtin_ia32_pshufb128", IX86_BUILTIN_PSHUFB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26306   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_pshufbv8qi3, "__builtin_ia32_pshufb", IX86_BUILTIN_PSHUFB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
26307   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv16qi3, "__builtin_ia32_psignb128", IX86_BUILTIN_PSIGNB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26308   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8qi3, "__builtin_ia32_psignb", IX86_BUILTIN_PSIGNB, UNKNOWN, (int) V8QI_FTYPE_V8QI_V8QI },
26309   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv8hi3, "__builtin_ia32_psignw128", IX86_BUILTIN_PSIGNW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26310   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4hi3, "__builtin_ia32_psignw", IX86_BUILTIN_PSIGNW, UNKNOWN, (int) V4HI_FTYPE_V4HI_V4HI },
26311   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv4si3, "__builtin_ia32_psignd128", IX86_BUILTIN_PSIGND128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26312   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_psignv2si3, "__builtin_ia32_psignd", IX86_BUILTIN_PSIGND, UNKNOWN, (int) V2SI_FTYPE_V2SI_V2SI },
26313
26314   /* SSSE3.  */
26315   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrti, "__builtin_ia32_palignr128", IX86_BUILTIN_PALIGNR128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT_CONVERT },
26316   { OPTION_MASK_ISA_SSSE3, CODE_FOR_ssse3_palignrdi, "__builtin_ia32_palignr", IX86_BUILTIN_PALIGNR, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI_INT_CONVERT },
26317
26318   /* SSE4.1 */
26319   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendpd, "__builtin_ia32_blendpd", IX86_BUILTIN_BLENDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26320   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendps, "__builtin_ia32_blendps", IX86_BUILTIN_BLENDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26321   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvpd, "__builtin_ia32_blendvpd", IX86_BUILTIN_BLENDVPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_V2DF },
26322   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_blendvps, "__builtin_ia32_blendvps", IX86_BUILTIN_BLENDVPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_V4SF },
26323   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dppd, "__builtin_ia32_dppd", IX86_BUILTIN_DPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26324   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_dpps, "__builtin_ia32_dpps", IX86_BUILTIN_DPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26325   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_insertps, "__builtin_ia32_insertps128", IX86_BUILTIN_INSERTPS128, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26326   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mpsadbw, "__builtin_ia32_mpsadbw128", IX86_BUILTIN_MPSADBW128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_INT },
26327   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendvb, "__builtin_ia32_pblendvb128", IX86_BUILTIN_PBLENDVB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI },
26328   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_pblendw, "__builtin_ia32_pblendw128", IX86_BUILTIN_PBLENDW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_INT },
26329
26330   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv8qiv8hi2, "__builtin_ia32_pmovsxbw128", IX86_BUILTIN_PMOVSXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
26331   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4qiv4si2, "__builtin_ia32_pmovsxbd128", IX86_BUILTIN_PMOVSXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
26332   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2qiv2di2, "__builtin_ia32_pmovsxbq128", IX86_BUILTIN_PMOVSXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
26333   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv4hiv4si2, "__builtin_ia32_pmovsxwd128", IX86_BUILTIN_PMOVSXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
26334   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2hiv2di2, "__builtin_ia32_pmovsxwq128", IX86_BUILTIN_PMOVSXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
26335   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_sign_extendv2siv2di2, "__builtin_ia32_pmovsxdq128", IX86_BUILTIN_PMOVSXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
26336   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv8qiv8hi2, "__builtin_ia32_pmovzxbw128", IX86_BUILTIN_PMOVZXBW128, UNKNOWN, (int) V8HI_FTYPE_V16QI },
26337   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4qiv4si2, "__builtin_ia32_pmovzxbd128", IX86_BUILTIN_PMOVZXBD128, UNKNOWN, (int) V4SI_FTYPE_V16QI },
26338   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2qiv2di2, "__builtin_ia32_pmovzxbq128", IX86_BUILTIN_PMOVZXBQ128, UNKNOWN, (int) V2DI_FTYPE_V16QI },
26339   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv4hiv4si2, "__builtin_ia32_pmovzxwd128", IX86_BUILTIN_PMOVZXWD128, UNKNOWN, (int) V4SI_FTYPE_V8HI },
26340   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2hiv2di2, "__builtin_ia32_pmovzxwq128", IX86_BUILTIN_PMOVZXWQ128, UNKNOWN, (int) V2DI_FTYPE_V8HI },
26341   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_zero_extendv2siv2di2, "__builtin_ia32_pmovzxdq128", IX86_BUILTIN_PMOVZXDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI },
26342   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_phminposuw, "__builtin_ia32_phminposuw128", IX86_BUILTIN_PHMINPOSUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
26343
26344   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_packusdw, "__builtin_ia32_packusdw128", IX86_BUILTIN_PACKUSDW128, UNKNOWN, (int) V8HI_FTYPE_V4SI_V4SI },
26345   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_eqv2di3, "__builtin_ia32_pcmpeqq", IX86_BUILTIN_PCMPEQQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26346   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv16qi3, "__builtin_ia32_pmaxsb128", IX86_BUILTIN_PMAXSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26347   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_smaxv4si3, "__builtin_ia32_pmaxsd128", IX86_BUILTIN_PMAXSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26348   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv4si3, "__builtin_ia32_pmaxud128", IX86_BUILTIN_PMAXUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26349   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_umaxv8hi3, "__builtin_ia32_pmaxuw128", IX86_BUILTIN_PMAXUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26350   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv16qi3, "__builtin_ia32_pminsb128", IX86_BUILTIN_PMINSB128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI },
26351   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sminv4si3, "__builtin_ia32_pminsd128", IX86_BUILTIN_PMINSD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26352   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv4si3, "__builtin_ia32_pminud128", IX86_BUILTIN_PMINUD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26353   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_uminv8hi3, "__builtin_ia32_pminuw128", IX86_BUILTIN_PMINUW128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI },
26354   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_sse4_1_mulv2siv2di3, "__builtin_ia32_pmuldq128", IX86_BUILTIN_PMULDQ128, UNKNOWN, (int) V2DI_FTYPE_V4SI_V4SI },
26355   { OPTION_MASK_ISA_SSE4_1, CODE_FOR_mulv4si3, "__builtin_ia32_pmulld128", IX86_BUILTIN_PMULLD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26356
26357   /* SSE4.1 */
26358   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd, "__builtin_ia32_roundpd", IX86_BUILTIN_ROUNDPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
26359   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps, "__builtin_ia32_roundps", IX86_BUILTIN_ROUNDPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
26360   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundsd, "__builtin_ia32_roundsd", IX86_BUILTIN_ROUNDSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26361   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundss, "__builtin_ia32_roundss", IX86_BUILTIN_ROUNDSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26362
26363   { 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 },
26364   { 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 },
26365   { 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 },
26366   { 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 },
26367
26368   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd_vec_pack_sfix, "__builtin_ia32_floorpd_vec_pack_sfix", IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX, (enum rtx_code) ROUND_FLOOR, (int) V4SI_FTYPE_V2DF_V2DF_ROUND },
26369   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundpd_vec_pack_sfix, "__builtin_ia32_ceilpd_vec_pack_sfix", IX86_BUILTIN_CEILPD_VEC_PACK_SFIX, (enum rtx_code) ROUND_CEIL, (int) V4SI_FTYPE_V2DF_V2DF_ROUND },
26370
26371   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv2df2, "__builtin_ia32_roundpd_az", IX86_BUILTIN_ROUNDPD_AZ, UNKNOWN, (int) V2DF_FTYPE_V2DF },
26372   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv2df2_vec_pack_sfix, "__builtin_ia32_roundpd_az_vec_pack_sfix", IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX, UNKNOWN, (int) V4SI_FTYPE_V2DF_V2DF },
26373
26374   { 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 },
26375   { 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 },
26376   { 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 },
26377   { 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 },
26378
26379   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps_sfix, "__builtin_ia32_floorps_sfix", IX86_BUILTIN_FLOORPS_SFIX, (enum rtx_code) ROUND_FLOOR, (int) V4SI_FTYPE_V4SF_ROUND },
26380   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_roundps_sfix, "__builtin_ia32_ceilps_sfix", IX86_BUILTIN_CEILPS_SFIX, (enum rtx_code) ROUND_CEIL, (int) V4SI_FTYPE_V4SF_ROUND },
26381
26382   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv4sf2, "__builtin_ia32_roundps_az", IX86_BUILTIN_ROUNDPS_AZ, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26383   { OPTION_MASK_ISA_ROUND, CODE_FOR_roundv4sf2_sfix, "__builtin_ia32_roundps_az_sfix", IX86_BUILTIN_ROUNDPS_AZ_SFIX, UNKNOWN, (int) V4SI_FTYPE_V4SF },
26384
26385   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestz128", IX86_BUILTIN_PTESTZ, EQ, (int) INT_FTYPE_V2DI_V2DI_PTEST },
26386   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestc128", IX86_BUILTIN_PTESTC, LTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
26387   { OPTION_MASK_ISA_ROUND, CODE_FOR_sse4_1_ptest, "__builtin_ia32_ptestnzc128", IX86_BUILTIN_PTESTNZC, GTU, (int) INT_FTYPE_V2DI_V2DI_PTEST },
26388
26389   /* SSE4.2 */
26390   { OPTION_MASK_ISA_SSE4_2, CODE_FOR_sse4_2_gtv2di3, "__builtin_ia32_pcmpgtq", IX86_BUILTIN_PCMPGTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26391   { 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 },
26392   { 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 },
26393   { 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 },
26394   { 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 },
26395
26396   /* SSE4A */
26397   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrqi, "__builtin_ia32_extrqi", IX86_BUILTIN_EXTRQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_UINT_UINT },
26398   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_extrq, "__builtin_ia32_extrq", IX86_BUILTIN_EXTRQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V16QI },
26399   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertqi, "__builtin_ia32_insertqi", IX86_BUILTIN_INSERTQI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_UINT_UINT },
26400   { OPTION_MASK_ISA_SSE4A, CODE_FOR_sse4a_insertq, "__builtin_ia32_insertq", IX86_BUILTIN_INSERTQ, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26401
26402   /* AES */
26403   { OPTION_MASK_ISA_SSE2, CODE_FOR_aeskeygenassist, 0, IX86_BUILTIN_AESKEYGENASSIST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_INT },
26404   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesimc, 0, IX86_BUILTIN_AESIMC128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
26405
26406   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenc, 0, IX86_BUILTIN_AESENC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26407   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesenclast, 0, IX86_BUILTIN_AESENCLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26408   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdec, 0, IX86_BUILTIN_AESDEC128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26409   { OPTION_MASK_ISA_SSE2, CODE_FOR_aesdeclast, 0, IX86_BUILTIN_AESDECLAST128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26410
26411   /* PCLMUL */
26412   { OPTION_MASK_ISA_SSE2, CODE_FOR_pclmulqdq, 0, IX86_BUILTIN_PCLMULQDQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI_INT },
26413
26414   /* AVX */
26415   { OPTION_MASK_ISA_AVX, CODE_FOR_addv4df3, "__builtin_ia32_addpd256", IX86_BUILTIN_ADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26416   { OPTION_MASK_ISA_AVX, CODE_FOR_addv8sf3, "__builtin_ia32_addps256", IX86_BUILTIN_ADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26417   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv4df3, "__builtin_ia32_addsubpd256", IX86_BUILTIN_ADDSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26418   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_addsubv8sf3, "__builtin_ia32_addsubps256", IX86_BUILTIN_ADDSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26419   { OPTION_MASK_ISA_AVX, CODE_FOR_andv4df3, "__builtin_ia32_andpd256", IX86_BUILTIN_ANDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26420   { OPTION_MASK_ISA_AVX, CODE_FOR_andv8sf3, "__builtin_ia32_andps256", IX86_BUILTIN_ANDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26421   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv4df3, "__builtin_ia32_andnpd256", IX86_BUILTIN_ANDNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26422   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_andnotv8sf3, "__builtin_ia32_andnps256", IX86_BUILTIN_ANDNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26423   { OPTION_MASK_ISA_AVX, CODE_FOR_divv4df3, "__builtin_ia32_divpd256", IX86_BUILTIN_DIVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26424   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_divv8sf3, "__builtin_ia32_divps256", IX86_BUILTIN_DIVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26425   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv4df3, "__builtin_ia32_haddpd256", IX86_BUILTIN_HADDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26426   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv8sf3, "__builtin_ia32_hsubps256", IX86_BUILTIN_HSUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26427   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_hsubv4df3, "__builtin_ia32_hsubpd256", IX86_BUILTIN_HSUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26428   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_haddv8sf3, "__builtin_ia32_haddps256", IX86_BUILTIN_HADDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26429   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv4df3, "__builtin_ia32_maxpd256", IX86_BUILTIN_MAXPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26430   { OPTION_MASK_ISA_AVX, CODE_FOR_smaxv8sf3, "__builtin_ia32_maxps256", IX86_BUILTIN_MAXPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26431   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv4df3, "__builtin_ia32_minpd256", IX86_BUILTIN_MINPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26432   { OPTION_MASK_ISA_AVX, CODE_FOR_sminv8sf3, "__builtin_ia32_minps256", IX86_BUILTIN_MINPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26433   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv4df3, "__builtin_ia32_mulpd256", IX86_BUILTIN_MULPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26434   { OPTION_MASK_ISA_AVX, CODE_FOR_mulv8sf3, "__builtin_ia32_mulps256", IX86_BUILTIN_MULPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26435   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv4df3, "__builtin_ia32_orpd256", IX86_BUILTIN_ORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26436   { OPTION_MASK_ISA_AVX, CODE_FOR_iorv8sf3, "__builtin_ia32_orps256", IX86_BUILTIN_ORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26437   { OPTION_MASK_ISA_AVX, CODE_FOR_subv4df3, "__builtin_ia32_subpd256", IX86_BUILTIN_SUBPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26438   { OPTION_MASK_ISA_AVX, CODE_FOR_subv8sf3, "__builtin_ia32_subps256", IX86_BUILTIN_SUBPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26439   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv4df3, "__builtin_ia32_xorpd256", IX86_BUILTIN_XORPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26440   { OPTION_MASK_ISA_AVX, CODE_FOR_xorv8sf3, "__builtin_ia32_xorps256", IX86_BUILTIN_XORPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26441
26442   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv2df3, "__builtin_ia32_vpermilvarpd", IX86_BUILTIN_VPERMILVARPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DI },
26443   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4sf3, "__builtin_ia32_vpermilvarps", IX86_BUILTIN_VPERMILVARPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SI },
26444   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv4df3, "__builtin_ia32_vpermilvarpd256", IX86_BUILTIN_VPERMILVARPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DI },
26445   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilvarv8sf3, "__builtin_ia32_vpermilvarps256", IX86_BUILTIN_VPERMILVARPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SI },
26446
26447   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendpd256, "__builtin_ia32_blendpd256", IX86_BUILTIN_BLENDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
26448   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendps256, "__builtin_ia32_blendps256", IX86_BUILTIN_BLENDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
26449   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvpd256, "__builtin_ia32_blendvpd256", IX86_BUILTIN_BLENDVPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_V4DF },
26450   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_blendvps256, "__builtin_ia32_blendvps256", IX86_BUILTIN_BLENDVPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_V8SF },
26451   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_dpps256, "__builtin_ia32_dpps256", IX86_BUILTIN_DPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
26452   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufpd256, "__builtin_ia32_shufpd256", IX86_BUILTIN_SHUFPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
26453   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_shufps256, "__builtin_ia32_shufps256", IX86_BUILTIN_SHUFPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
26454   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv2df3, "__builtin_ia32_cmpsd", IX86_BUILTIN_CMPSD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26455   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vmcmpv4sf3, "__builtin_ia32_cmpss", IX86_BUILTIN_CMPSS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26456   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv2df3, "__builtin_ia32_cmppd", IX86_BUILTIN_CMPPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_V2DF_INT },
26457   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4sf3, "__builtin_ia32_cmpps", IX86_BUILTIN_CMPPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_V4SF_INT },
26458   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv4df3, "__builtin_ia32_cmppd256", IX86_BUILTIN_CMPPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
26459   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cmpv8sf3, "__builtin_ia32_cmpps256", IX86_BUILTIN_CMPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
26460   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v4df, "__builtin_ia32_vextractf128_pd256", IX86_BUILTIN_EXTRACTF128PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF_INT },
26461   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8sf, "__builtin_ia32_vextractf128_ps256", IX86_BUILTIN_EXTRACTF128PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF_INT },
26462   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vextractf128v8si, "__builtin_ia32_vextractf128_si256", IX86_BUILTIN_EXTRACTF128SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI_INT },
26463   { OPTION_MASK_ISA_AVX, CODE_FOR_floatv4siv4df2, "__builtin_ia32_cvtdq2pd256", IX86_BUILTIN_CVTDQ2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SI },
26464   { OPTION_MASK_ISA_AVX, CODE_FOR_floatv8siv8sf2, "__builtin_ia32_cvtdq2ps256", IX86_BUILTIN_CVTDQ2PS256, UNKNOWN, (int) V8SF_FTYPE_V8SI },
26465   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2ps256, "__builtin_ia32_cvtpd2ps256", IX86_BUILTIN_CVTPD2PS256, UNKNOWN, (int) V4SF_FTYPE_V4DF },
26466   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2dq256, "__builtin_ia32_cvtps2dq256", IX86_BUILTIN_CVTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
26467   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtps2pd256, "__builtin_ia32_cvtps2pd256", IX86_BUILTIN_CVTPS2PD256, UNKNOWN, (int) V4DF_FTYPE_V4SF },
26468   { OPTION_MASK_ISA_AVX, CODE_FOR_fix_truncv4dfv4si2, "__builtin_ia32_cvttpd2dq256", IX86_BUILTIN_CVTTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
26469   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_cvtpd2dq256, "__builtin_ia32_cvtpd2dq256", IX86_BUILTIN_CVTPD2DQ256, UNKNOWN, (int) V4SI_FTYPE_V4DF },
26470   { OPTION_MASK_ISA_AVX, CODE_FOR_fix_truncv8sfv8si2, "__builtin_ia32_cvttps2dq256", IX86_BUILTIN_CVTTPS2DQ256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
26471   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v4df3, "__builtin_ia32_vperm2f128_pd256", IX86_BUILTIN_VPERM2F128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_INT },
26472   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8sf3, "__builtin_ia32_vperm2f128_ps256", IX86_BUILTIN_VPERM2F128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF_INT },
26473   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vperm2f128v8si3, "__builtin_ia32_vperm2f128_si256", IX86_BUILTIN_VPERM2F128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
26474   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv2df, "__builtin_ia32_vpermilpd", IX86_BUILTIN_VPERMILPD, UNKNOWN, (int) V2DF_FTYPE_V2DF_INT },
26475   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4sf, "__builtin_ia32_vpermilps", IX86_BUILTIN_VPERMILPS, UNKNOWN, (int) V4SF_FTYPE_V4SF_INT },
26476   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv4df, "__builtin_ia32_vpermilpd256", IX86_BUILTIN_VPERMILPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
26477   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vpermilv8sf, "__builtin_ia32_vpermilps256", IX86_BUILTIN_VPERMILPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
26478   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v4df, "__builtin_ia32_vinsertf128_pd256", IX86_BUILTIN_VINSERTF128PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V2DF_INT },
26479   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8sf, "__builtin_ia32_vinsertf128_ps256", IX86_BUILTIN_VINSERTF128PS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V4SF_INT },
26480   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vinsertf128v8si, "__builtin_ia32_vinsertf128_si256", IX86_BUILTIN_VINSERTF128SI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_INT },
26481
26482   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movshdup256, "__builtin_ia32_movshdup256", IX86_BUILTIN_MOVSHDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26483   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movsldup256, "__builtin_ia32_movsldup256", IX86_BUILTIN_MOVSLDUP256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26484   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movddup256, "__builtin_ia32_movddup256", IX86_BUILTIN_MOVDDUP256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
26485
26486   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv4df2, "__builtin_ia32_sqrtpd256", IX86_BUILTIN_SQRTPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
26487   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_sqrtv8sf2, "__builtin_ia32_sqrtps256", IX86_BUILTIN_SQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26488   { OPTION_MASK_ISA_AVX, CODE_FOR_sqrtv8sf2, "__builtin_ia32_sqrtps_nr256", IX86_BUILTIN_SQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26489   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rsqrtv8sf2, "__builtin_ia32_rsqrtps256", IX86_BUILTIN_RSQRTPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26490   { OPTION_MASK_ISA_AVX, CODE_FOR_rsqrtv8sf2, "__builtin_ia32_rsqrtps_nr256", IX86_BUILTIN_RSQRTPS_NR256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26491
26492   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_rcpv8sf2, "__builtin_ia32_rcpps256", IX86_BUILTIN_RCPPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26493
26494   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_roundpd256", IX86_BUILTIN_ROUNDPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
26495   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_roundps256", IX86_BUILTIN_ROUNDPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_INT },
26496
26497   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_floorpd256", IX86_BUILTIN_FLOORPD256, (enum rtx_code) ROUND_FLOOR, (int) V4DF_FTYPE_V4DF_ROUND },
26498   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_ceilpd256", IX86_BUILTIN_CEILPD256, (enum rtx_code) ROUND_CEIL, (int) V4DF_FTYPE_V4DF_ROUND },
26499   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_truncpd256", IX86_BUILTIN_TRUNCPD256, (enum rtx_code) ROUND_TRUNC, (int) V4DF_FTYPE_V4DF_ROUND },
26500   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd256, "__builtin_ia32_rintpd256", IX86_BUILTIN_RINTPD256, (enum rtx_code) ROUND_MXCSR, (int) V4DF_FTYPE_V4DF_ROUND },
26501
26502   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv4df2, "__builtin_ia32_roundpd_az256", IX86_BUILTIN_ROUNDPD_AZ256, UNKNOWN, (int) V4DF_FTYPE_V4DF },
26503   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv4df2_vec_pack_sfix, "__builtin_ia32_roundpd_az_vec_pack_sfix256", IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX256, UNKNOWN, (int) V8SI_FTYPE_V4DF_V4DF },
26504
26505   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd_vec_pack_sfix256, "__builtin_ia32_floorpd_vec_pack_sfix256", IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX256, (enum rtx_code) ROUND_FLOOR, (int) V8SI_FTYPE_V4DF_V4DF_ROUND },
26506   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundpd_vec_pack_sfix256, "__builtin_ia32_ceilpd_vec_pack_sfix256", IX86_BUILTIN_CEILPD_VEC_PACK_SFIX256, (enum rtx_code) ROUND_CEIL, (int) V8SI_FTYPE_V4DF_V4DF_ROUND },
26507
26508   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_floorps256", IX86_BUILTIN_FLOORPS256, (enum rtx_code) ROUND_FLOOR, (int) V8SF_FTYPE_V8SF_ROUND },
26509   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_ceilps256", IX86_BUILTIN_CEILPS256, (enum rtx_code) ROUND_CEIL, (int) V8SF_FTYPE_V8SF_ROUND },
26510   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_truncps256", IX86_BUILTIN_TRUNCPS256, (enum rtx_code) ROUND_TRUNC, (int) V8SF_FTYPE_V8SF_ROUND },
26511   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps256, "__builtin_ia32_rintps256", IX86_BUILTIN_RINTPS256, (enum rtx_code) ROUND_MXCSR, (int) V8SF_FTYPE_V8SF_ROUND },
26512
26513   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps_sfix256, "__builtin_ia32_floorps_sfix256", IX86_BUILTIN_FLOORPS_SFIX256, (enum rtx_code) ROUND_FLOOR, (int) V8SI_FTYPE_V8SF_ROUND },
26514   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_roundps_sfix256, "__builtin_ia32_ceilps_sfix256", IX86_BUILTIN_CEILPS_SFIX256, (enum rtx_code) ROUND_CEIL, (int) V8SI_FTYPE_V8SF_ROUND },
26515
26516   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv8sf2, "__builtin_ia32_roundps_az256", IX86_BUILTIN_ROUNDPS_AZ256, UNKNOWN, (int) V8SF_FTYPE_V8SF },
26517   { OPTION_MASK_ISA_AVX, CODE_FOR_roundv8sf2_sfix, "__builtin_ia32_roundps_az_sfix256", IX86_BUILTIN_ROUNDPS_AZ_SFIX256, UNKNOWN, (int) V8SI_FTYPE_V8SF },
26518
26519   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhpd256,  "__builtin_ia32_unpckhpd256", IX86_BUILTIN_UNPCKHPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26520   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklpd256,  "__builtin_ia32_unpcklpd256", IX86_BUILTIN_UNPCKLPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26521   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpckhps256,  "__builtin_ia32_unpckhps256", IX86_BUILTIN_UNPCKHPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26522   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_unpcklps256,  "__builtin_ia32_unpcklps256", IX86_BUILTIN_UNPCKLPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26523
26524   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_si256_si, "__builtin_ia32_si256_si", IX86_BUILTIN_SI256_SI, UNKNOWN, (int) V8SI_FTYPE_V4SI },
26525   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ps256_ps, "__builtin_ia32_ps256_ps", IX86_BUILTIN_PS256_PS, UNKNOWN, (int) V8SF_FTYPE_V4SF },
26526   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_pd256_pd, "__builtin_ia32_pd256_pd", IX86_BUILTIN_PD256_PD, UNKNOWN, (int) V4DF_FTYPE_V2DF },
26527   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8si, "__builtin_ia32_si_si256", IX86_BUILTIN_SI_SI256, UNKNOWN, (int) V4SI_FTYPE_V8SI },
26528   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v8sf, "__builtin_ia32_ps_ps256", IX86_BUILTIN_PS_PS256, UNKNOWN, (int) V4SF_FTYPE_V8SF },
26529   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_extract_lo_v4df, "__builtin_ia32_pd_pd256", IX86_BUILTIN_PD_PD256, UNKNOWN, (int) V2DF_FTYPE_V4DF },
26530
26531   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestzpd", IX86_BUILTIN_VTESTZPD, EQ, (int) INT_FTYPE_V2DF_V2DF_PTEST },
26532   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestcpd", IX86_BUILTIN_VTESTCPD, LTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
26533   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd, "__builtin_ia32_vtestnzcpd", IX86_BUILTIN_VTESTNZCPD, GTU, (int) INT_FTYPE_V2DF_V2DF_PTEST },
26534   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestzps", IX86_BUILTIN_VTESTZPS, EQ, (int) INT_FTYPE_V4SF_V4SF_PTEST },
26535   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestcps", IX86_BUILTIN_VTESTCPS, LTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
26536   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps, "__builtin_ia32_vtestnzcps", IX86_BUILTIN_VTESTNZCPS, GTU, (int) INT_FTYPE_V4SF_V4SF_PTEST },
26537   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestzpd256", IX86_BUILTIN_VTESTZPD256, EQ, (int) INT_FTYPE_V4DF_V4DF_PTEST },
26538   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestcpd256", IX86_BUILTIN_VTESTCPD256, LTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
26539   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestpd256, "__builtin_ia32_vtestnzcpd256", IX86_BUILTIN_VTESTNZCPD256, GTU, (int) INT_FTYPE_V4DF_V4DF_PTEST },
26540   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestzps256", IX86_BUILTIN_VTESTZPS256, EQ, (int) INT_FTYPE_V8SF_V8SF_PTEST },
26541   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestcps256", IX86_BUILTIN_VTESTCPS256, LTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
26542   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_vtestps256, "__builtin_ia32_vtestnzcps256", IX86_BUILTIN_VTESTNZCPS256, GTU, (int) INT_FTYPE_V8SF_V8SF_PTEST },
26543   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestz256", IX86_BUILTIN_PTESTZ256, EQ, (int) INT_FTYPE_V4DI_V4DI_PTEST },
26544   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestc256", IX86_BUILTIN_PTESTC256, LTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
26545   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_ptest256, "__builtin_ia32_ptestnzc256", IX86_BUILTIN_PTESTNZC256, GTU, (int) INT_FTYPE_V4DI_V4DI_PTEST },
26546
26547   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskpd256, "__builtin_ia32_movmskpd256", IX86_BUILTIN_MOVMSKPD256, UNKNOWN, (int) INT_FTYPE_V4DF  },
26548   { OPTION_MASK_ISA_AVX, CODE_FOR_avx_movmskps256, "__builtin_ia32_movmskps256", IX86_BUILTIN_MOVMSKPS256, UNKNOWN, (int) INT_FTYPE_V8SF },
26549
26550   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv8sf3,  "__builtin_ia32_copysignps256", IX86_BUILTIN_CPYSGNPS256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26551   { OPTION_MASK_ISA_AVX, CODE_FOR_copysignv4df3,  "__builtin_ia32_copysignpd256", IX86_BUILTIN_CPYSGNPD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF },
26552
26553   { OPTION_MASK_ISA_AVX, CODE_FOR_vec_pack_sfix_v4df, "__builtin_ia32_vec_pack_sfix256 ", IX86_BUILTIN_VEC_PACK_SFIX256, UNKNOWN, (int) V8SI_FTYPE_V4DF_V4DF },
26554
26555   /* AVX2 */
26556   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_mpsadbw, "__builtin_ia32_mpsadbw256", IX86_BUILTIN_MPSADBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_INT },
26557   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv32qi2, "__builtin_ia32_pabsb256", IX86_BUILTIN_PABSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI },
26558   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv16hi2, "__builtin_ia32_pabsw256", IX86_BUILTIN_PABSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI },
26559   { OPTION_MASK_ISA_AVX2, CODE_FOR_absv8si2, "__builtin_ia32_pabsd256", IX86_BUILTIN_PABSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI },
26560   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packssdw, "__builtin_ia32_packssdw256",  IX86_BUILTIN_PACKSSDW256, UNKNOWN, (int) V16HI_FTYPE_V8SI_V8SI },
26561   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packsswb, "__builtin_ia32_packsswb256",  IX86_BUILTIN_PACKSSWB256, UNKNOWN, (int) V32QI_FTYPE_V16HI_V16HI },
26562   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packusdw, "__builtin_ia32_packusdw256",  IX86_BUILTIN_PACKUSDW256, UNKNOWN, (int) V16HI_FTYPE_V8SI_V8SI },
26563   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_packuswb, "__builtin_ia32_packuswb256",  IX86_BUILTIN_PACKUSWB256, UNKNOWN, (int) V32QI_FTYPE_V16HI_V16HI },
26564   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv32qi3, "__builtin_ia32_paddb256", IX86_BUILTIN_PADDB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26565   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv16hi3, "__builtin_ia32_paddw256", IX86_BUILTIN_PADDW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26566   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv8si3, "__builtin_ia32_paddd256", IX86_BUILTIN_PADDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26567   { OPTION_MASK_ISA_AVX2, CODE_FOR_addv4di3, "__builtin_ia32_paddq256", IX86_BUILTIN_PADDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26568   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ssaddv32qi3, "__builtin_ia32_paddsb256", IX86_BUILTIN_PADDSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26569   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ssaddv16hi3, "__builtin_ia32_paddsw256", IX86_BUILTIN_PADDSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26570   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_usaddv32qi3, "__builtin_ia32_paddusb256", IX86_BUILTIN_PADDUSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26571   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_usaddv16hi3, "__builtin_ia32_paddusw256", IX86_BUILTIN_PADDUSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26572   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_palignrv2ti, "__builtin_ia32_palignr256", IX86_BUILTIN_PALIGNR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI_INT_CONVERT },
26573   { OPTION_MASK_ISA_AVX2, CODE_FOR_andv4di3, "__builtin_ia32_andsi256", IX86_BUILTIN_AND256I, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26574   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_andnotv4di3, "__builtin_ia32_andnotsi256", IX86_BUILTIN_ANDNOT256I, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26575   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_uavgv32qi3, "__builtin_ia32_pavgb256",  IX86_BUILTIN_PAVGB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26576   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_uavgv16hi3, "__builtin_ia32_pavgw256",  IX86_BUILTIN_PAVGW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26577   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblendvb, "__builtin_ia32_pblendvb256", IX86_BUILTIN_PBLENDVB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI },
26578   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblendw, "__builtin_ia32_pblendw256", IX86_BUILTIN_PBLENDVW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_INT },
26579   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv32qi3, "__builtin_ia32_pcmpeqb256", IX86_BUILTIN_PCMPEQB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26580   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv16hi3, "__builtin_ia32_pcmpeqw256", IX86_BUILTIN_PCMPEQW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26581   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv8si3, "__builtin_ia32_pcmpeqd256", IX86_BUILTIN_PCMPEQD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI  },
26582   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_eqv4di3, "__builtin_ia32_pcmpeqq256", IX86_BUILTIN_PCMPEQQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI  },
26583   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv32qi3, "__builtin_ia32_pcmpgtb256", IX86_BUILTIN_PCMPGTB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26584   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv16hi3, "__builtin_ia32_pcmpgtw256", IX86_BUILTIN_PCMPGTW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26585   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv8si3, "__builtin_ia32_pcmpgtd256", IX86_BUILTIN_PCMPGTD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI  },
26586   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_gtv4di3, "__builtin_ia32_pcmpgtq256", IX86_BUILTIN_PCMPGTQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI  },
26587   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phaddwv16hi3, "__builtin_ia32_phaddw256", IX86_BUILTIN_PHADDW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26588   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phadddv8si3, "__builtin_ia32_phaddd256", IX86_BUILTIN_PHADDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26589   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phaddswv16hi3, "__builtin_ia32_phaddsw256", IX86_BUILTIN_PHADDSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26590   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubwv16hi3, "__builtin_ia32_phsubw256", IX86_BUILTIN_PHSUBW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26591   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubdv8si3, "__builtin_ia32_phsubd256", IX86_BUILTIN_PHSUBD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26592   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_phsubswv16hi3, "__builtin_ia32_phsubsw256", IX86_BUILTIN_PHSUBSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26593   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmaddubsw256, "__builtin_ia32_pmaddubsw256", IX86_BUILTIN_PMADDUBSW256, UNKNOWN, (int) V16HI_FTYPE_V32QI_V32QI },
26594   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmaddwd, "__builtin_ia32_pmaddwd256", IX86_BUILTIN_PMADDWD256, UNKNOWN, (int) V8SI_FTYPE_V16HI_V16HI },
26595   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv32qi3, "__builtin_ia32_pmaxsb256", IX86_BUILTIN_PMAXSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26596   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv16hi3, "__builtin_ia32_pmaxsw256", IX86_BUILTIN_PMAXSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26597   { OPTION_MASK_ISA_AVX2, CODE_FOR_smaxv8si3 , "__builtin_ia32_pmaxsd256", IX86_BUILTIN_PMAXSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26598   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv32qi3, "__builtin_ia32_pmaxub256", IX86_BUILTIN_PMAXUB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26599   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv16hi3, "__builtin_ia32_pmaxuw256", IX86_BUILTIN_PMAXUW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26600   { OPTION_MASK_ISA_AVX2, CODE_FOR_umaxv8si3 , "__builtin_ia32_pmaxud256", IX86_BUILTIN_PMAXUD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26601   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv32qi3, "__builtin_ia32_pminsb256", IX86_BUILTIN_PMINSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26602   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv16hi3, "__builtin_ia32_pminsw256", IX86_BUILTIN_PMINSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26603   { OPTION_MASK_ISA_AVX2, CODE_FOR_sminv8si3 , "__builtin_ia32_pminsd256", IX86_BUILTIN_PMINSD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26604   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv32qi3, "__builtin_ia32_pminub256", IX86_BUILTIN_PMINUB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26605   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv16hi3, "__builtin_ia32_pminuw256", IX86_BUILTIN_PMINUW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26606   { OPTION_MASK_ISA_AVX2, CODE_FOR_uminv8si3 , "__builtin_ia32_pminud256", IX86_BUILTIN_PMINUD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26607   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pmovmskb, "__builtin_ia32_pmovmskb256", IX86_BUILTIN_PMOVMSKB256, UNKNOWN, (int) INT_FTYPE_V32QI },
26608   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv16qiv16hi2, "__builtin_ia32_pmovsxbw256", IX86_BUILTIN_PMOVSXBW256, UNKNOWN, (int) V16HI_FTYPE_V16QI },
26609   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv8qiv8si2  , "__builtin_ia32_pmovsxbd256", IX86_BUILTIN_PMOVSXBD256, UNKNOWN, (int) V8SI_FTYPE_V16QI },
26610   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4qiv4di2  , "__builtin_ia32_pmovsxbq256", IX86_BUILTIN_PMOVSXBQ256, UNKNOWN, (int) V4DI_FTYPE_V16QI },
26611   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv8hiv8si2  , "__builtin_ia32_pmovsxwd256", IX86_BUILTIN_PMOVSXWD256, UNKNOWN, (int) V8SI_FTYPE_V8HI },
26612   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4hiv4di2  , "__builtin_ia32_pmovsxwq256", IX86_BUILTIN_PMOVSXWQ256, UNKNOWN, (int) V4DI_FTYPE_V8HI },
26613   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sign_extendv4siv4di2  , "__builtin_ia32_pmovsxdq256", IX86_BUILTIN_PMOVSXDQ256, UNKNOWN, (int) V4DI_FTYPE_V4SI },
26614   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv16qiv16hi2, "__builtin_ia32_pmovzxbw256", IX86_BUILTIN_PMOVZXBW256, UNKNOWN, (int) V16HI_FTYPE_V16QI },
26615   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv8qiv8si2  , "__builtin_ia32_pmovzxbd256", IX86_BUILTIN_PMOVZXBD256, UNKNOWN, (int) V8SI_FTYPE_V16QI },
26616   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4qiv4di2  , "__builtin_ia32_pmovzxbq256", IX86_BUILTIN_PMOVZXBQ256, UNKNOWN, (int) V4DI_FTYPE_V16QI },
26617   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv8hiv8si2  , "__builtin_ia32_pmovzxwd256", IX86_BUILTIN_PMOVZXWD256, UNKNOWN, (int) V8SI_FTYPE_V8HI },
26618   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4hiv4di2  , "__builtin_ia32_pmovzxwq256", IX86_BUILTIN_PMOVZXWQ256, UNKNOWN, (int) V4DI_FTYPE_V8HI },
26619   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_zero_extendv4siv4di2  , "__builtin_ia32_pmovzxdq256", IX86_BUILTIN_PMOVZXDQ256, UNKNOWN, (int) V4DI_FTYPE_V4SI },
26620   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_mulv4siv4di3  , "__builtin_ia32_pmuldq256"  , IX86_BUILTIN_PMULDQ256  , UNKNOWN, (int) V4DI_FTYPE_V8SI_V8SI },
26621   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_umulhrswv16hi3 , "__builtin_ia32_pmulhrsw256", IX86_BUILTIN_PMULHRSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26622   { OPTION_MASK_ISA_AVX2, CODE_FOR_umulv16hi3_highpart, "__builtin_ia32_pmulhuw256" , IX86_BUILTIN_PMULHUW256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26623   { OPTION_MASK_ISA_AVX2, CODE_FOR_smulv16hi3_highpart, "__builtin_ia32_pmulhw256"  , IX86_BUILTIN_PMULHW256  , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26624   { OPTION_MASK_ISA_AVX2, CODE_FOR_mulv16hi3, "__builtin_ia32_pmullw256"  , IX86_BUILTIN_PMULLW256  , UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26625   { OPTION_MASK_ISA_AVX2, CODE_FOR_mulv8si3, "__builtin_ia32_pmulld256"  , IX86_BUILTIN_PMULLD256  , UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26626   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_umulv4siv4di3  , "__builtin_ia32_pmuludq256" , IX86_BUILTIN_PMULUDQ256 , UNKNOWN, (int) V4DI_FTYPE_V8SI_V8SI },
26627   { OPTION_MASK_ISA_AVX2, CODE_FOR_iorv4di3, "__builtin_ia32_por256", IX86_BUILTIN_POR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26628   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psadbw, "__builtin_ia32_psadbw256", IX86_BUILTIN_PSADBW256, UNKNOWN, (int) V16HI_FTYPE_V32QI_V32QI },
26629   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufbv32qi3, "__builtin_ia32_pshufb256", IX86_BUILTIN_PSHUFB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26630   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufdv3, "__builtin_ia32_pshufd256", IX86_BUILTIN_PSHUFD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_INT },
26631   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshufhwv3, "__builtin_ia32_pshufhw256", IX86_BUILTIN_PSHUFHW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_INT },
26632   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pshuflwv3, "__builtin_ia32_pshuflw256", IX86_BUILTIN_PSHUFLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_INT },
26633   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv32qi3, "__builtin_ia32_psignb256", IX86_BUILTIN_PSIGNB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26634   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv16hi3, "__builtin_ia32_psignw256", IX86_BUILTIN_PSIGNW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26635   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_psignv8si3 , "__builtin_ia32_psignd256", IX86_BUILTIN_PSIGND256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26636   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashlv2ti3, "__builtin_ia32_pslldqi256", IX86_BUILTIN_PSLLDQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_CONVERT },
26637   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv16hi3, "__builtin_ia32_psllwi256", IX86_BUILTIN_PSLLWI256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
26638   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv16hi3, "__builtin_ia32_psllw256", IX86_BUILTIN_PSLLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
26639   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv8si3, "__builtin_ia32_pslldi256", IX86_BUILTIN_PSLLDI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
26640   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv8si3, "__builtin_ia32_pslld256", IX86_BUILTIN_PSLLD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
26641   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv4di3, "__builtin_ia32_psllqi256", IX86_BUILTIN_PSLLQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_COUNT },
26642   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashlv4di3, "__builtin_ia32_psllq256", IX86_BUILTIN_PSLLQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_COUNT },
26643   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv16hi3, "__builtin_ia32_psrawi256", IX86_BUILTIN_PSRAWI256, UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
26644   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv16hi3, "__builtin_ia32_psraw256", IX86_BUILTIN_PSRAW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
26645   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv8si3, "__builtin_ia32_psradi256", IX86_BUILTIN_PSRADI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
26646   { OPTION_MASK_ISA_AVX2, CODE_FOR_ashrv8si3, "__builtin_ia32_psrad256", IX86_BUILTIN_PSRAD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
26647   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrv2ti3, "__builtin_ia32_psrldqi256", IX86_BUILTIN_PSRLDQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_CONVERT },
26648   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv16hi3, "__builtin_ia32_psrlwi256", IX86_BUILTIN_PSRLWI256 , UNKNOWN, (int) V16HI_FTYPE_V16HI_SI_COUNT },
26649   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv16hi3, "__builtin_ia32_psrlw256", IX86_BUILTIN_PSRLW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V8HI_COUNT },
26650   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv8si3, "__builtin_ia32_psrldi256", IX86_BUILTIN_PSRLDI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_SI_COUNT },
26651   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv8si3, "__builtin_ia32_psrld256", IX86_BUILTIN_PSRLD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V4SI_COUNT },
26652   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv4di3, "__builtin_ia32_psrlqi256", IX86_BUILTIN_PSRLQI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT_COUNT },
26653   { OPTION_MASK_ISA_AVX2, CODE_FOR_lshrv4di3, "__builtin_ia32_psrlq256", IX86_BUILTIN_PSRLQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_COUNT },
26654   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv32qi3, "__builtin_ia32_psubb256", IX86_BUILTIN_PSUBB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26655   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv16hi3, "__builtin_ia32_psubw256", IX86_BUILTIN_PSUBW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26656   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv8si3, "__builtin_ia32_psubd256", IX86_BUILTIN_PSUBD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26657   { OPTION_MASK_ISA_AVX2, CODE_FOR_subv4di3, "__builtin_ia32_psubq256", IX86_BUILTIN_PSUBQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26658   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sssubv32qi3, "__builtin_ia32_psubsb256", IX86_BUILTIN_PSUBSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26659   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_sssubv16hi3, "__builtin_ia32_psubsw256", IX86_BUILTIN_PSUBSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26660   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ussubv32qi3, "__builtin_ia32_psubusb256", IX86_BUILTIN_PSUBUSB256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26661   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ussubv16hi3, "__builtin_ia32_psubusw256", IX86_BUILTIN_PSUBUSW256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26662   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv32qi, "__builtin_ia32_punpckhbw256", IX86_BUILTIN_PUNPCKHBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26663   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv16hi, "__builtin_ia32_punpckhwd256", IX86_BUILTIN_PUNPCKHWD256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI  },
26664   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv8si, "__builtin_ia32_punpckhdq256", IX86_BUILTIN_PUNPCKHDQ256, UNKNOWN,  (int) V8SI_FTYPE_V8SI_V8SI },
26665   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_highv4di, "__builtin_ia32_punpckhqdq256", IX86_BUILTIN_PUNPCKHQDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26666   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv32qi, "__builtin_ia32_punpcklbw256", IX86_BUILTIN_PUNPCKLBW256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI },
26667   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv16hi, "__builtin_ia32_punpcklwd256", IX86_BUILTIN_PUNPCKLWD256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI },
26668   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv8si, "__builtin_ia32_punpckldq256", IX86_BUILTIN_PUNPCKLDQ256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26669   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_interleave_lowv4di, "__builtin_ia32_punpcklqdq256", IX86_BUILTIN_PUNPCKLQDQ256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26670   { OPTION_MASK_ISA_AVX2, CODE_FOR_xorv4di3, "__builtin_ia32_pxor256", IX86_BUILTIN_PXOR256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26671   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv4sf, "__builtin_ia32_vbroadcastss_ps", IX86_BUILTIN_VBROADCASTSS_PS, UNKNOWN, (int) V4SF_FTYPE_V4SF },
26672   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv8sf, "__builtin_ia32_vbroadcastss_ps256", IX86_BUILTIN_VBROADCASTSS_PS256, UNKNOWN, (int) V8SF_FTYPE_V4SF },
26673   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vec_dupv4df, "__builtin_ia32_vbroadcastsd_pd256", IX86_BUILTIN_VBROADCASTSD_PD256, UNKNOWN, (int) V4DF_FTYPE_V2DF },
26674   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_vbroadcasti128_v4di, "__builtin_ia32_vbroadcastsi256", IX86_BUILTIN_VBROADCASTSI256, UNKNOWN, (int) V4DI_FTYPE_V2DI },
26675   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblenddv4si, "__builtin_ia32_pblendd128", IX86_BUILTIN_PBLENDD128, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI_INT },
26676   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pblenddv8si, "__builtin_ia32_pblendd256", IX86_BUILTIN_PBLENDD256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI_INT },
26677   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv32qi, "__builtin_ia32_pbroadcastb256", IX86_BUILTIN_PBROADCASTB256, UNKNOWN, (int) V32QI_FTYPE_V16QI },
26678   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv16hi, "__builtin_ia32_pbroadcastw256", IX86_BUILTIN_PBROADCASTW256, UNKNOWN, (int) V16HI_FTYPE_V8HI },
26679   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv8si, "__builtin_ia32_pbroadcastd256", IX86_BUILTIN_PBROADCASTD256, UNKNOWN, (int) V8SI_FTYPE_V4SI },
26680   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv4di, "__builtin_ia32_pbroadcastq256", IX86_BUILTIN_PBROADCASTQ256, UNKNOWN, (int) V4DI_FTYPE_V2DI },
26681   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv16qi, "__builtin_ia32_pbroadcastb128", IX86_BUILTIN_PBROADCASTB128, UNKNOWN, (int) V16QI_FTYPE_V16QI },
26682   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv8hi, "__builtin_ia32_pbroadcastw128", IX86_BUILTIN_PBROADCASTW128, UNKNOWN, (int) V8HI_FTYPE_V8HI },
26683   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv4si, "__builtin_ia32_pbroadcastd128", IX86_BUILTIN_PBROADCASTD128, UNKNOWN, (int) V4SI_FTYPE_V4SI },
26684   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_pbroadcastv2di, "__builtin_ia32_pbroadcastq128", IX86_BUILTIN_PBROADCASTQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI },
26685   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permvarv8si, "__builtin_ia32_permvarsi256", IX86_BUILTIN_VPERMVARSI256, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26686   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv4df, "__builtin_ia32_permdf256", IX86_BUILTIN_VPERMDF256, UNKNOWN, (int) V4DF_FTYPE_V4DF_INT },
26687   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permvarv8sf, "__builtin_ia32_permvarsf256", IX86_BUILTIN_VPERMVARSF256, UNKNOWN, (int) V8SF_FTYPE_V8SF_V8SF },
26688   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv4di, "__builtin_ia32_permdi256", IX86_BUILTIN_VPERMDI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_INT },
26689   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_permv2ti, "__builtin_ia32_permti256", IX86_BUILTIN_VPERMTI256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI_INT },
26690   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_extracti128, "__builtin_ia32_extract128i256", IX86_BUILTIN_VEXTRACT128I256, UNKNOWN, (int) V2DI_FTYPE_V4DI_INT },
26691   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_inserti128, "__builtin_ia32_insert128i256", IX86_BUILTIN_VINSERT128I256, UNKNOWN, (int) V4DI_FTYPE_V4DI_V2DI_INT },
26692   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashlvv4di, "__builtin_ia32_psllv4di", IX86_BUILTIN_PSLLVV4DI, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26693   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashlvv2di, "__builtin_ia32_psllv2di", IX86_BUILTIN_PSLLVV2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26694   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashlvv8si, "__builtin_ia32_psllv8si", IX86_BUILTIN_PSLLVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26695   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashlvv4si, "__builtin_ia32_psllv4si", IX86_BUILTIN_PSLLVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26696   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashrvv8si, "__builtin_ia32_psrav8si", IX86_BUILTIN_PSRAVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26697   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_ashrvv4si, "__builtin_ia32_psrav4si", IX86_BUILTIN_PSRAVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26698   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv4di, "__builtin_ia32_psrlv4di", IX86_BUILTIN_PSRLVV4DI, UNKNOWN, (int) V4DI_FTYPE_V4DI_V4DI },
26699   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv2di, "__builtin_ia32_psrlv2di", IX86_BUILTIN_PSRLVV2DI, UNKNOWN, (int) V2DI_FTYPE_V2DI_V2DI },
26700   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv8si, "__builtin_ia32_psrlv8si", IX86_BUILTIN_PSRLVV8SI, UNKNOWN, (int) V8SI_FTYPE_V8SI_V8SI },
26701   { OPTION_MASK_ISA_AVX2, CODE_FOR_avx2_lshrvv4si, "__builtin_ia32_psrlv4si", IX86_BUILTIN_PSRLVV4SI, UNKNOWN, (int) V4SI_FTYPE_V4SI_V4SI },
26702
26703   { OPTION_MASK_ISA_LZCNT, CODE_FOR_clzhi2_lzcnt,   "__builtin_clzs",   IX86_BUILTIN_CLZS,    UNKNOWN,     (int) UINT16_FTYPE_UINT16 },
26704
26705   /* BMI */
26706   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_si, "__builtin_ia32_bextr_u32", IX86_BUILTIN_BEXTR32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26707   { OPTION_MASK_ISA_BMI, CODE_FOR_bmi_bextr_di, "__builtin_ia32_bextr_u64", IX86_BUILTIN_BEXTR64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26708   { OPTION_MASK_ISA_BMI, CODE_FOR_ctzhi2,       "__builtin_ctzs",           IX86_BUILTIN_CTZS,    UNKNOWN, (int) UINT16_FTYPE_UINT16 },
26709
26710   /* TBM */
26711   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_si, "__builtin_ia32_bextri_u32", IX86_BUILTIN_BEXTRI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26712   { OPTION_MASK_ISA_TBM, CODE_FOR_tbm_bextri_di, "__builtin_ia32_bextri_u64", IX86_BUILTIN_BEXTRI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26713
26714   /* F16C */
26715   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps, "__builtin_ia32_vcvtph2ps", IX86_BUILTIN_CVTPH2PS, UNKNOWN, (int) V4SF_FTYPE_V8HI },
26716   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtph2ps256, "__builtin_ia32_vcvtph2ps256", IX86_BUILTIN_CVTPH2PS256, UNKNOWN, (int) V8SF_FTYPE_V8HI },
26717   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph, "__builtin_ia32_vcvtps2ph", IX86_BUILTIN_CVTPS2PH, UNKNOWN, (int) V8HI_FTYPE_V4SF_INT },
26718   { OPTION_MASK_ISA_F16C, CODE_FOR_vcvtps2ph256, "__builtin_ia32_vcvtps2ph256", IX86_BUILTIN_CVTPS2PH256, UNKNOWN, (int) V8HI_FTYPE_V8SF_INT },
26719
26720   /* BMI2 */
26721   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_bzhi_si3, "__builtin_ia32_bzhi_si", IX86_BUILTIN_BZHI32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26722   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_bzhi_di3, "__builtin_ia32_bzhi_di", IX86_BUILTIN_BZHI64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26723   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pdep_si3, "__builtin_ia32_pdep_si", IX86_BUILTIN_PDEP32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26724   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pdep_di3, "__builtin_ia32_pdep_di", IX86_BUILTIN_PDEP64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26725   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pext_si3, "__builtin_ia32_pext_si", IX86_BUILTIN_PEXT32, UNKNOWN, (int) UINT_FTYPE_UINT_UINT },
26726   { OPTION_MASK_ISA_BMI2, CODE_FOR_bmi2_pext_di3, "__builtin_ia32_pext_di", IX86_BUILTIN_PEXT64, UNKNOWN, (int) UINT64_FTYPE_UINT64_UINT64 },
26727 };
26728
26729 /* FMA4 and XOP.  */
26730 #define MULTI_ARG_4_DF2_DI_I    V2DF_FTYPE_V2DF_V2DF_V2DI_INT
26731 #define MULTI_ARG_4_DF2_DI_I1   V4DF_FTYPE_V4DF_V4DF_V4DI_INT
26732 #define MULTI_ARG_4_SF2_SI_I    V4SF_FTYPE_V4SF_V4SF_V4SI_INT
26733 #define MULTI_ARG_4_SF2_SI_I1   V8SF_FTYPE_V8SF_V8SF_V8SI_INT
26734 #define MULTI_ARG_3_SF          V4SF_FTYPE_V4SF_V4SF_V4SF
26735 #define MULTI_ARG_3_DF          V2DF_FTYPE_V2DF_V2DF_V2DF
26736 #define MULTI_ARG_3_SF2         V8SF_FTYPE_V8SF_V8SF_V8SF
26737 #define MULTI_ARG_3_DF2         V4DF_FTYPE_V4DF_V4DF_V4DF
26738 #define MULTI_ARG_3_DI          V2DI_FTYPE_V2DI_V2DI_V2DI
26739 #define MULTI_ARG_3_SI          V4SI_FTYPE_V4SI_V4SI_V4SI
26740 #define MULTI_ARG_3_SI_DI       V4SI_FTYPE_V4SI_V4SI_V2DI
26741 #define MULTI_ARG_3_HI          V8HI_FTYPE_V8HI_V8HI_V8HI
26742 #define MULTI_ARG_3_HI_SI       V8HI_FTYPE_V8HI_V8HI_V4SI
26743 #define MULTI_ARG_3_QI          V16QI_FTYPE_V16QI_V16QI_V16QI
26744 #define MULTI_ARG_3_DI2         V4DI_FTYPE_V4DI_V4DI_V4DI
26745 #define MULTI_ARG_3_SI2         V8SI_FTYPE_V8SI_V8SI_V8SI
26746 #define MULTI_ARG_3_HI2         V16HI_FTYPE_V16HI_V16HI_V16HI
26747 #define MULTI_ARG_3_QI2         V32QI_FTYPE_V32QI_V32QI_V32QI
26748 #define MULTI_ARG_2_SF          V4SF_FTYPE_V4SF_V4SF
26749 #define MULTI_ARG_2_DF          V2DF_FTYPE_V2DF_V2DF
26750 #define MULTI_ARG_2_DI          V2DI_FTYPE_V2DI_V2DI
26751 #define MULTI_ARG_2_SI          V4SI_FTYPE_V4SI_V4SI
26752 #define MULTI_ARG_2_HI          V8HI_FTYPE_V8HI_V8HI
26753 #define MULTI_ARG_2_QI          V16QI_FTYPE_V16QI_V16QI
26754 #define MULTI_ARG_2_DI_IMM      V2DI_FTYPE_V2DI_SI
26755 #define MULTI_ARG_2_SI_IMM      V4SI_FTYPE_V4SI_SI
26756 #define MULTI_ARG_2_HI_IMM      V8HI_FTYPE_V8HI_SI
26757 #define MULTI_ARG_2_QI_IMM      V16QI_FTYPE_V16QI_SI
26758 #define MULTI_ARG_2_DI_CMP      V2DI_FTYPE_V2DI_V2DI_CMP
26759 #define MULTI_ARG_2_SI_CMP      V4SI_FTYPE_V4SI_V4SI_CMP
26760 #define MULTI_ARG_2_HI_CMP      V8HI_FTYPE_V8HI_V8HI_CMP
26761 #define MULTI_ARG_2_QI_CMP      V16QI_FTYPE_V16QI_V16QI_CMP
26762 #define MULTI_ARG_2_SF_TF       V4SF_FTYPE_V4SF_V4SF_TF
26763 #define MULTI_ARG_2_DF_TF       V2DF_FTYPE_V2DF_V2DF_TF
26764 #define MULTI_ARG_2_DI_TF       V2DI_FTYPE_V2DI_V2DI_TF
26765 #define MULTI_ARG_2_SI_TF       V4SI_FTYPE_V4SI_V4SI_TF
26766 #define MULTI_ARG_2_HI_TF       V8HI_FTYPE_V8HI_V8HI_TF
26767 #define MULTI_ARG_2_QI_TF       V16QI_FTYPE_V16QI_V16QI_TF
26768 #define MULTI_ARG_1_SF          V4SF_FTYPE_V4SF
26769 #define MULTI_ARG_1_DF          V2DF_FTYPE_V2DF
26770 #define MULTI_ARG_1_SF2         V8SF_FTYPE_V8SF
26771 #define MULTI_ARG_1_DF2         V4DF_FTYPE_V4DF
26772 #define MULTI_ARG_1_DI          V2DI_FTYPE_V2DI
26773 #define MULTI_ARG_1_SI          V4SI_FTYPE_V4SI
26774 #define MULTI_ARG_1_HI          V8HI_FTYPE_V8HI
26775 #define MULTI_ARG_1_QI          V16QI_FTYPE_V16QI
26776 #define MULTI_ARG_1_SI_DI       V2DI_FTYPE_V4SI
26777 #define MULTI_ARG_1_HI_DI       V2DI_FTYPE_V8HI
26778 #define MULTI_ARG_1_HI_SI       V4SI_FTYPE_V8HI
26779 #define MULTI_ARG_1_QI_DI       V2DI_FTYPE_V16QI
26780 #define MULTI_ARG_1_QI_SI       V4SI_FTYPE_V16QI
26781 #define MULTI_ARG_1_QI_HI       V8HI_FTYPE_V16QI
26782
26783 static const struct builtin_description bdesc_multi_arg[] =
26784 {
26785   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v4sf,
26786     "__builtin_ia32_vfmaddss", IX86_BUILTIN_VFMADDSS,
26787     UNKNOWN, (int)MULTI_ARG_3_SF },
26788   { OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_vmfmadd_v2df,
26789     "__builtin_ia32_vfmaddsd", IX86_BUILTIN_VFMADDSD,
26790     UNKNOWN, (int)MULTI_ARG_3_DF },
26791
26792   { OPTION_MASK_ISA_FMA, CODE_FOR_fmai_vmfmadd_v4sf,
26793     "__builtin_ia32_vfmaddss3", IX86_BUILTIN_VFMADDSS3,
26794     UNKNOWN, (int)MULTI_ARG_3_SF },
26795   { OPTION_MASK_ISA_FMA, CODE_FOR_fmai_vmfmadd_v2df,
26796     "__builtin_ia32_vfmaddsd3", IX86_BUILTIN_VFMADDSD3,
26797     UNKNOWN, (int)MULTI_ARG_3_DF },
26798
26799   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4sf,
26800     "__builtin_ia32_vfmaddps", IX86_BUILTIN_VFMADDPS,
26801     UNKNOWN, (int)MULTI_ARG_3_SF },
26802   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v2df,
26803     "__builtin_ia32_vfmaddpd", IX86_BUILTIN_VFMADDPD,
26804     UNKNOWN, (int)MULTI_ARG_3_DF },
26805   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v8sf,
26806     "__builtin_ia32_vfmaddps256", IX86_BUILTIN_VFMADDPS256,
26807     UNKNOWN, (int)MULTI_ARG_3_SF2 },
26808   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fma4i_fmadd_v4df,
26809     "__builtin_ia32_vfmaddpd256", IX86_BUILTIN_VFMADDPD256,
26810     UNKNOWN, (int)MULTI_ARG_3_DF2 },
26811
26812   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4sf,
26813     "__builtin_ia32_vfmaddsubps", IX86_BUILTIN_VFMADDSUBPS,
26814     UNKNOWN, (int)MULTI_ARG_3_SF },
26815   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v2df,
26816     "__builtin_ia32_vfmaddsubpd", IX86_BUILTIN_VFMADDSUBPD,
26817     UNKNOWN, (int)MULTI_ARG_3_DF },
26818   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v8sf,
26819     "__builtin_ia32_vfmaddsubps256", IX86_BUILTIN_VFMADDSUBPS256,
26820     UNKNOWN, (int)MULTI_ARG_3_SF2 },
26821   { OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_FMA4, CODE_FOR_fmaddsub_v4df,
26822     "__builtin_ia32_vfmaddsubpd256", IX86_BUILTIN_VFMADDSUBPD256,
26823     UNKNOWN, (int)MULTI_ARG_3_DF2 },
26824
26825   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov",      IX86_BUILTIN_VPCMOV,      UNKNOWN,      (int)MULTI_ARG_3_DI },
26826   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2di,        "__builtin_ia32_vpcmov_v2di", IX86_BUILTIN_VPCMOV_V2DI, UNKNOWN,      (int)MULTI_ARG_3_DI },
26827   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4si,        "__builtin_ia32_vpcmov_v4si", IX86_BUILTIN_VPCMOV_V4SI, UNKNOWN,      (int)MULTI_ARG_3_SI },
26828   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8hi,        "__builtin_ia32_vpcmov_v8hi", IX86_BUILTIN_VPCMOV_V8HI, UNKNOWN,      (int)MULTI_ARG_3_HI },
26829   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16qi,       "__builtin_ia32_vpcmov_v16qi",IX86_BUILTIN_VPCMOV_V16QI,UNKNOWN,      (int)MULTI_ARG_3_QI },
26830   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v2df,        "__builtin_ia32_vpcmov_v2df", IX86_BUILTIN_VPCMOV_V2DF, UNKNOWN,      (int)MULTI_ARG_3_DF },
26831   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4sf,        "__builtin_ia32_vpcmov_v4sf", IX86_BUILTIN_VPCMOV_V4SF, UNKNOWN,      (int)MULTI_ARG_3_SF },
26832
26833   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov256",       IX86_BUILTIN_VPCMOV256,       UNKNOWN,      (int)MULTI_ARG_3_DI2 },
26834   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4di256,        "__builtin_ia32_vpcmov_v4di256",  IX86_BUILTIN_VPCMOV_V4DI256,  UNKNOWN,      (int)MULTI_ARG_3_DI2 },
26835   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8si256,        "__builtin_ia32_vpcmov_v8si256",  IX86_BUILTIN_VPCMOV_V8SI256,  UNKNOWN,      (int)MULTI_ARG_3_SI2 },
26836   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v16hi256,       "__builtin_ia32_vpcmov_v16hi256", IX86_BUILTIN_VPCMOV_V16HI256, UNKNOWN,      (int)MULTI_ARG_3_HI2 },
26837   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v32qi256,       "__builtin_ia32_vpcmov_v32qi256", IX86_BUILTIN_VPCMOV_V32QI256, UNKNOWN,      (int)MULTI_ARG_3_QI2 },
26838   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v4df256,        "__builtin_ia32_vpcmov_v4df256",  IX86_BUILTIN_VPCMOV_V4DF256,  UNKNOWN,      (int)MULTI_ARG_3_DF2 },
26839   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pcmov_v8sf256,        "__builtin_ia32_vpcmov_v8sf256",  IX86_BUILTIN_VPCMOV_V8SF256,  UNKNOWN,      (int)MULTI_ARG_3_SF2 },
26840
26841   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pperm,             "__builtin_ia32_vpperm",      IX86_BUILTIN_VPPERM,      UNKNOWN,      (int)MULTI_ARG_3_QI },
26842
26843   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssww,          "__builtin_ia32_vpmacssww",   IX86_BUILTIN_VPMACSSWW,   UNKNOWN,      (int)MULTI_ARG_3_HI },
26844   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsww,           "__builtin_ia32_vpmacsww",    IX86_BUILTIN_VPMACSWW,    UNKNOWN,      (int)MULTI_ARG_3_HI },
26845   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsswd,          "__builtin_ia32_vpmacsswd",   IX86_BUILTIN_VPMACSSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26846   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacswd,           "__builtin_ia32_vpmacswd",    IX86_BUILTIN_VPMACSWD,    UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26847   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdd,          "__builtin_ia32_vpmacssdd",   IX86_BUILTIN_VPMACSSDD,   UNKNOWN,      (int)MULTI_ARG_3_SI },
26848   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdd,           "__builtin_ia32_vpmacsdd",    IX86_BUILTIN_VPMACSDD,    UNKNOWN,      (int)MULTI_ARG_3_SI },
26849   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdql,         "__builtin_ia32_vpmacssdql",  IX86_BUILTIN_VPMACSSDQL,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26850   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacssdqh,         "__builtin_ia32_vpmacssdqh",  IX86_BUILTIN_VPMACSSDQH,  UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26851   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdql,          "__builtin_ia32_vpmacsdql",   IX86_BUILTIN_VPMACSDQL,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26852   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmacsdqh,          "__builtin_ia32_vpmacsdqh",   IX86_BUILTIN_VPMACSDQH,   UNKNOWN,      (int)MULTI_ARG_3_SI_DI },
26853   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcsswd,         "__builtin_ia32_vpmadcsswd",  IX86_BUILTIN_VPMADCSSWD,  UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26854   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_pmadcswd,          "__builtin_ia32_vpmadcswd",   IX86_BUILTIN_VPMADCSWD,   UNKNOWN,      (int)MULTI_ARG_3_HI_SI },
26855
26856   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv2di3,        "__builtin_ia32_vprotq",      IX86_BUILTIN_VPROTQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26857   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv4si3,        "__builtin_ia32_vprotd",      IX86_BUILTIN_VPROTD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26858   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv8hi3,        "__builtin_ia32_vprotw",      IX86_BUILTIN_VPROTW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26859   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vrotlv16qi3,       "__builtin_ia32_vprotb",      IX86_BUILTIN_VPROTB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26860   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv2di3,         "__builtin_ia32_vprotqi",     IX86_BUILTIN_VPROTQ_IMM,  UNKNOWN,      (int)MULTI_ARG_2_DI_IMM },
26861   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv4si3,         "__builtin_ia32_vprotdi",     IX86_BUILTIN_VPROTD_IMM,  UNKNOWN,      (int)MULTI_ARG_2_SI_IMM },
26862   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv8hi3,         "__builtin_ia32_vprotwi",     IX86_BUILTIN_VPROTW_IMM,  UNKNOWN,      (int)MULTI_ARG_2_HI_IMM },
26863   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_rotlv16qi3,        "__builtin_ia32_vprotbi",     IX86_BUILTIN_VPROTB_IMM,  UNKNOWN,      (int)MULTI_ARG_2_QI_IMM },
26864   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shav2di3,         "__builtin_ia32_vpshaq",      IX86_BUILTIN_VPSHAQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26865   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shav4si3,         "__builtin_ia32_vpshad",      IX86_BUILTIN_VPSHAD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26866   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shav8hi3,         "__builtin_ia32_vpshaw",      IX86_BUILTIN_VPSHAW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26867   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shav16qi3,        "__builtin_ia32_vpshab",      IX86_BUILTIN_VPSHAB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26868   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shlv2di3,         "__builtin_ia32_vpshlq",      IX86_BUILTIN_VPSHLQ,      UNKNOWN,      (int)MULTI_ARG_2_DI },
26869   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shlv4si3,         "__builtin_ia32_vpshld",      IX86_BUILTIN_VPSHLD,      UNKNOWN,      (int)MULTI_ARG_2_SI },
26870   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shlv8hi3,         "__builtin_ia32_vpshlw",      IX86_BUILTIN_VPSHLW,      UNKNOWN,      (int)MULTI_ARG_2_HI },
26871   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_shlv16qi3,        "__builtin_ia32_vpshlb",      IX86_BUILTIN_VPSHLB,      UNKNOWN,      (int)MULTI_ARG_2_QI },
26872
26873   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv4sf2,       "__builtin_ia32_vfrczss",     IX86_BUILTIN_VFRCZSS,     UNKNOWN,      (int)MULTI_ARG_2_SF },
26874   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vmfrczv2df2,       "__builtin_ia32_vfrczsd",     IX86_BUILTIN_VFRCZSD,     UNKNOWN,      (int)MULTI_ARG_2_DF },
26875   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4sf2,         "__builtin_ia32_vfrczps",     IX86_BUILTIN_VFRCZPS,     UNKNOWN,      (int)MULTI_ARG_1_SF },
26876   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv2df2,         "__builtin_ia32_vfrczpd",     IX86_BUILTIN_VFRCZPD,     UNKNOWN,      (int)MULTI_ARG_1_DF },
26877   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv8sf2,         "__builtin_ia32_vfrczps256",  IX86_BUILTIN_VFRCZPS256,  UNKNOWN,      (int)MULTI_ARG_1_SF2 },
26878   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_frczv4df2,         "__builtin_ia32_vfrczpd256",  IX86_BUILTIN_VFRCZPD256,  UNKNOWN,      (int)MULTI_ARG_1_DF2 },
26879
26880   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbw,           "__builtin_ia32_vphaddbw",    IX86_BUILTIN_VPHADDBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26881   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbd,           "__builtin_ia32_vphaddbd",    IX86_BUILTIN_VPHADDBD,    UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
26882   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddbq,           "__builtin_ia32_vphaddbq",    IX86_BUILTIN_VPHADDBQ,    UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
26883   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwd,           "__builtin_ia32_vphaddwd",    IX86_BUILTIN_VPHADDWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26884   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddwq,           "__builtin_ia32_vphaddwq",    IX86_BUILTIN_VPHADDWQ,    UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
26885   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadddq,           "__builtin_ia32_vphadddq",    IX86_BUILTIN_VPHADDDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26886   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubw,          "__builtin_ia32_vphaddubw",   IX86_BUILTIN_VPHADDUBW,   UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26887   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubd,          "__builtin_ia32_vphaddubd",   IX86_BUILTIN_VPHADDUBD,   UNKNOWN,      (int)MULTI_ARG_1_QI_SI },
26888   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddubq,          "__builtin_ia32_vphaddubq",   IX86_BUILTIN_VPHADDUBQ,   UNKNOWN,      (int)MULTI_ARG_1_QI_DI },
26889   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwd,          "__builtin_ia32_vphadduwd",   IX86_BUILTIN_VPHADDUWD,   UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26890   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phadduwq,          "__builtin_ia32_vphadduwq",   IX86_BUILTIN_VPHADDUWQ,   UNKNOWN,      (int)MULTI_ARG_1_HI_DI },
26891   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phaddudq,          "__builtin_ia32_vphaddudq",   IX86_BUILTIN_VPHADDUDQ,   UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26892   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubbw,           "__builtin_ia32_vphsubbw",    IX86_BUILTIN_VPHSUBBW,    UNKNOWN,      (int)MULTI_ARG_1_QI_HI },
26893   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubwd,           "__builtin_ia32_vphsubwd",    IX86_BUILTIN_VPHSUBWD,    UNKNOWN,      (int)MULTI_ARG_1_HI_SI },
26894   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_phsubdq,           "__builtin_ia32_vphsubdq",    IX86_BUILTIN_VPHSUBDQ,    UNKNOWN,      (int)MULTI_ARG_1_SI_DI },
26895
26896   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomeqb",    IX86_BUILTIN_VPCOMEQB,    EQ,           (int)MULTI_ARG_2_QI_CMP },
26897   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneb",    IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
26898   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomneqb",   IX86_BUILTIN_VPCOMNEB,    NE,           (int)MULTI_ARG_2_QI_CMP },
26899   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomltb",    IX86_BUILTIN_VPCOMLTB,    LT,           (int)MULTI_ARG_2_QI_CMP },
26900   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomleb",    IX86_BUILTIN_VPCOMLEB,    LE,           (int)MULTI_ARG_2_QI_CMP },
26901   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgtb",    IX86_BUILTIN_VPCOMGTB,    GT,           (int)MULTI_ARG_2_QI_CMP },
26902   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv16qi3,     "__builtin_ia32_vpcomgeb",    IX86_BUILTIN_VPCOMGEB,    GE,           (int)MULTI_ARG_2_QI_CMP },
26903
26904   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomeqw",    IX86_BUILTIN_VPCOMEQW,    EQ,           (int)MULTI_ARG_2_HI_CMP },
26905   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomnew",    IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
26906   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomneqw",   IX86_BUILTIN_VPCOMNEW,    NE,           (int)MULTI_ARG_2_HI_CMP },
26907   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomltw",    IX86_BUILTIN_VPCOMLTW,    LT,           (int)MULTI_ARG_2_HI_CMP },
26908   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomlew",    IX86_BUILTIN_VPCOMLEW,    LE,           (int)MULTI_ARG_2_HI_CMP },
26909   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgtw",    IX86_BUILTIN_VPCOMGTW,    GT,           (int)MULTI_ARG_2_HI_CMP },
26910   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv8hi3,      "__builtin_ia32_vpcomgew",    IX86_BUILTIN_VPCOMGEW,    GE,           (int)MULTI_ARG_2_HI_CMP },
26911
26912   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomeqd",    IX86_BUILTIN_VPCOMEQD,    EQ,           (int)MULTI_ARG_2_SI_CMP },
26913   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomned",    IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
26914   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomneqd",   IX86_BUILTIN_VPCOMNED,    NE,           (int)MULTI_ARG_2_SI_CMP },
26915   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomltd",    IX86_BUILTIN_VPCOMLTD,    LT,           (int)MULTI_ARG_2_SI_CMP },
26916   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomled",    IX86_BUILTIN_VPCOMLED,    LE,           (int)MULTI_ARG_2_SI_CMP },
26917   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomgtd",    IX86_BUILTIN_VPCOMGTD,    GT,           (int)MULTI_ARG_2_SI_CMP },
26918   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv4si3,      "__builtin_ia32_vpcomged",    IX86_BUILTIN_VPCOMGED,    GE,           (int)MULTI_ARG_2_SI_CMP },
26919
26920   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomeqq",    IX86_BUILTIN_VPCOMEQQ,    EQ,           (int)MULTI_ARG_2_DI_CMP },
26921   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneq",    IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
26922   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomneqq",   IX86_BUILTIN_VPCOMNEQ,    NE,           (int)MULTI_ARG_2_DI_CMP },
26923   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomltq",    IX86_BUILTIN_VPCOMLTQ,    LT,           (int)MULTI_ARG_2_DI_CMP },
26924   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomleq",    IX86_BUILTIN_VPCOMLEQ,    LE,           (int)MULTI_ARG_2_DI_CMP },
26925   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgtq",    IX86_BUILTIN_VPCOMGTQ,    GT,           (int)MULTI_ARG_2_DI_CMP },
26926   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmpv2di3,      "__builtin_ia32_vpcomgeq",    IX86_BUILTIN_VPCOMGEQ,    GE,           (int)MULTI_ARG_2_DI_CMP },
26927
26928   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomequb",   IX86_BUILTIN_VPCOMEQUB,   EQ,           (int)MULTI_ARG_2_QI_CMP },
26929   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomneub",   IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
26930   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v16qi3,"__builtin_ia32_vpcomnequb",  IX86_BUILTIN_VPCOMNEUB,   NE,           (int)MULTI_ARG_2_QI_CMP },
26931   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomltub",   IX86_BUILTIN_VPCOMLTUB,   LTU,          (int)MULTI_ARG_2_QI_CMP },
26932   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomleub",   IX86_BUILTIN_VPCOMLEUB,   LEU,          (int)MULTI_ARG_2_QI_CMP },
26933   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgtub",   IX86_BUILTIN_VPCOMGTUB,   GTU,          (int)MULTI_ARG_2_QI_CMP },
26934   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv16qi3, "__builtin_ia32_vpcomgeub",   IX86_BUILTIN_VPCOMGEUB,   GEU,          (int)MULTI_ARG_2_QI_CMP },
26935
26936   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomequw",   IX86_BUILTIN_VPCOMEQUW,   EQ,           (int)MULTI_ARG_2_HI_CMP },
26937   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomneuw",   IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
26938   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v8hi3, "__builtin_ia32_vpcomnequw",  IX86_BUILTIN_VPCOMNEUW,   NE,           (int)MULTI_ARG_2_HI_CMP },
26939   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomltuw",   IX86_BUILTIN_VPCOMLTUW,   LTU,          (int)MULTI_ARG_2_HI_CMP },
26940   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomleuw",   IX86_BUILTIN_VPCOMLEUW,   LEU,          (int)MULTI_ARG_2_HI_CMP },
26941   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgtuw",   IX86_BUILTIN_VPCOMGTUW,   GTU,          (int)MULTI_ARG_2_HI_CMP },
26942   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv8hi3,  "__builtin_ia32_vpcomgeuw",   IX86_BUILTIN_VPCOMGEUW,   GEU,          (int)MULTI_ARG_2_HI_CMP },
26943
26944   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomequd",   IX86_BUILTIN_VPCOMEQUD,   EQ,           (int)MULTI_ARG_2_SI_CMP },
26945   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomneud",   IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
26946   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v4si3, "__builtin_ia32_vpcomnequd",  IX86_BUILTIN_VPCOMNEUD,   NE,           (int)MULTI_ARG_2_SI_CMP },
26947   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomltud",   IX86_BUILTIN_VPCOMLTUD,   LTU,          (int)MULTI_ARG_2_SI_CMP },
26948   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomleud",   IX86_BUILTIN_VPCOMLEUD,   LEU,          (int)MULTI_ARG_2_SI_CMP },
26949   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgtud",   IX86_BUILTIN_VPCOMGTUD,   GTU,          (int)MULTI_ARG_2_SI_CMP },
26950   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv4si3,  "__builtin_ia32_vpcomgeud",   IX86_BUILTIN_VPCOMGEUD,   GEU,          (int)MULTI_ARG_2_SI_CMP },
26951
26952   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomequq",   IX86_BUILTIN_VPCOMEQUQ,   EQ,           (int)MULTI_ARG_2_DI_CMP },
26953   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomneuq",   IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
26954   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_uns2v2di3, "__builtin_ia32_vpcomnequq",  IX86_BUILTIN_VPCOMNEUQ,   NE,           (int)MULTI_ARG_2_DI_CMP },
26955   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomltuq",   IX86_BUILTIN_VPCOMLTUQ,   LTU,          (int)MULTI_ARG_2_DI_CMP },
26956   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomleuq",   IX86_BUILTIN_VPCOMLEUQ,   LEU,          (int)MULTI_ARG_2_DI_CMP },
26957   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgtuq",   IX86_BUILTIN_VPCOMGTUQ,   GTU,          (int)MULTI_ARG_2_DI_CMP },
26958   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_maskcmp_unsv2di3,  "__builtin_ia32_vpcomgeuq",   IX86_BUILTIN_VPCOMGEUQ,   GEU,          (int)MULTI_ARG_2_DI_CMP },
26959
26960   { 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 },
26961   { 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 },
26962   { 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 },
26963   { 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 },
26964   { 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 },
26965   { 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 },
26966   { 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 },
26967   { 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 },
26968
26969   { 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 },
26970   { 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 },
26971   { 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 },
26972   { 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 },
26973   { 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 },
26974   { 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 },
26975   { 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 },
26976   { 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 },
26977
26978   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v2df3,     "__builtin_ia32_vpermil2pd",  IX86_BUILTIN_VPERMIL2PD, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I },
26979   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4sf3,     "__builtin_ia32_vpermil2ps",  IX86_BUILTIN_VPERMIL2PS, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I },
26980   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v4df3,     "__builtin_ia32_vpermil2pd256", IX86_BUILTIN_VPERMIL2PD256, UNKNOWN, (int)MULTI_ARG_4_DF2_DI_I1 },
26981   { OPTION_MASK_ISA_XOP, CODE_FOR_xop_vpermil2v8sf3,     "__builtin_ia32_vpermil2ps256", IX86_BUILTIN_VPERMIL2PS256, UNKNOWN, (int)MULTI_ARG_4_SF2_SI_I1 },
26982
26983 };
26984 \f
26985 /* TM vector builtins.  */
26986
26987 /* Reuse the existing x86-specific `struct builtin_description' cause
26988    we're lazy.  Add casts to make them fit.  */
26989 static const struct builtin_description bdesc_tm[] =
26990 {
26991   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_WM64", (enum ix86_builtins) BUILT_IN_TM_STORE_M64, UNKNOWN, VOID_FTYPE_PV2SI_V2SI },
26992   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_WaRM64", (enum ix86_builtins) BUILT_IN_TM_STORE_WAR_M64, UNKNOWN, VOID_FTYPE_PV2SI_V2SI },
26993   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_WaWM64", (enum ix86_builtins) BUILT_IN_TM_STORE_WAW_M64, UNKNOWN, VOID_FTYPE_PV2SI_V2SI },
26994   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_RM64", (enum ix86_builtins) BUILT_IN_TM_LOAD_M64, UNKNOWN, V2SI_FTYPE_PCV2SI },
26995   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_RaRM64", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAR_M64, UNKNOWN, V2SI_FTYPE_PCV2SI },
26996   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_RaWM64", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAW_M64, UNKNOWN, V2SI_FTYPE_PCV2SI },
26997   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_RfWM64", (enum ix86_builtins) BUILT_IN_TM_LOAD_RFW_M64, UNKNOWN, V2SI_FTYPE_PCV2SI },
26998
26999   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_WM128", (enum ix86_builtins) BUILT_IN_TM_STORE_M128, UNKNOWN, VOID_FTYPE_PV4SF_V4SF },
27000   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_WaRM128", (enum ix86_builtins) BUILT_IN_TM_STORE_WAR_M128, UNKNOWN, VOID_FTYPE_PV4SF_V4SF },
27001   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_WaWM128", (enum ix86_builtins) BUILT_IN_TM_STORE_WAW_M128, UNKNOWN, VOID_FTYPE_PV4SF_V4SF },
27002   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_RM128", (enum ix86_builtins) BUILT_IN_TM_LOAD_M128, UNKNOWN, V4SF_FTYPE_PCV4SF },
27003   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_RaRM128", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAR_M128, UNKNOWN, V4SF_FTYPE_PCV4SF },
27004   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_RaWM128", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAW_M128, UNKNOWN, V4SF_FTYPE_PCV4SF },
27005   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_RfWM128", (enum ix86_builtins) BUILT_IN_TM_LOAD_RFW_M128, UNKNOWN, V4SF_FTYPE_PCV4SF },
27006
27007   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_WM256", (enum ix86_builtins) BUILT_IN_TM_STORE_M256, UNKNOWN, VOID_FTYPE_PV8SF_V8SF },
27008   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_WaRM256", (enum ix86_builtins) BUILT_IN_TM_STORE_WAR_M256, UNKNOWN, VOID_FTYPE_PV8SF_V8SF },
27009   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_WaWM256", (enum ix86_builtins) BUILT_IN_TM_STORE_WAW_M256, UNKNOWN, VOID_FTYPE_PV8SF_V8SF },
27010   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_RM256", (enum ix86_builtins) BUILT_IN_TM_LOAD_M256, UNKNOWN, V8SF_FTYPE_PCV8SF },
27011   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_RaRM256", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAR_M256, UNKNOWN, V8SF_FTYPE_PCV8SF },
27012   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_RaWM256", (enum ix86_builtins) BUILT_IN_TM_LOAD_RAW_M256, UNKNOWN, V8SF_FTYPE_PCV8SF },
27013   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_RfWM256", (enum ix86_builtins) BUILT_IN_TM_LOAD_RFW_M256, UNKNOWN, V8SF_FTYPE_PCV8SF },
27014
27015   { OPTION_MASK_ISA_MMX, CODE_FOR_nothing, "__builtin__ITM_LM64", (enum ix86_builtins) BUILT_IN_TM_LOG_M64, UNKNOWN, VOID_FTYPE_PCVOID },
27016   { OPTION_MASK_ISA_SSE, CODE_FOR_nothing, "__builtin__ITM_LM128", (enum ix86_builtins) BUILT_IN_TM_LOG_M128, UNKNOWN, VOID_FTYPE_PCVOID },
27017   { OPTION_MASK_ISA_AVX, CODE_FOR_nothing, "__builtin__ITM_LM256", (enum ix86_builtins) BUILT_IN_TM_LOG_M256, UNKNOWN, VOID_FTYPE_PCVOID },
27018 };
27019
27020 /* TM callbacks.  */
27021
27022 /* Return the builtin decl needed to load a vector of TYPE.  */
27023
27024 static tree
27025 ix86_builtin_tm_load (tree type)
27026 {
27027   if (TREE_CODE (type) == VECTOR_TYPE)
27028     {
27029       switch (tree_low_cst (TYPE_SIZE (type), 1))
27030         {
27031         case 64:
27032           return builtin_decl_explicit (BUILT_IN_TM_LOAD_M64);
27033         case 128:
27034           return builtin_decl_explicit (BUILT_IN_TM_LOAD_M128);
27035         case 256:
27036           return builtin_decl_explicit (BUILT_IN_TM_LOAD_M256);
27037         }
27038     }
27039   return NULL_TREE;
27040 }
27041
27042 /* Return the builtin decl needed to store a vector of TYPE.  */
27043
27044 static tree
27045 ix86_builtin_tm_store (tree type)
27046 {
27047   if (TREE_CODE (type) == VECTOR_TYPE)
27048     {
27049       switch (tree_low_cst (TYPE_SIZE (type), 1))
27050         {
27051         case 64:
27052           return builtin_decl_explicit (BUILT_IN_TM_STORE_M64);
27053         case 128:
27054           return builtin_decl_explicit (BUILT_IN_TM_STORE_M128);
27055         case 256:
27056           return builtin_decl_explicit (BUILT_IN_TM_STORE_M256);
27057         }
27058     }
27059   return NULL_TREE;
27060 }
27061 \f
27062 /* Initialize the transactional memory vector load/store builtins.  */
27063
27064 static void
27065 ix86_init_tm_builtins (void)
27066 {
27067   enum ix86_builtin_func_type ftype;
27068   const struct builtin_description *d;
27069   size_t i;
27070   tree decl;
27071   tree attrs_load, attrs_type_load, attrs_store, attrs_type_store;
27072   tree attrs_log, attrs_type_log;
27073
27074   if (!flag_tm)
27075     return;
27076
27077   /* If there are no builtins defined, we must be compiling in a
27078      language without trans-mem support.  */
27079   if (!builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
27080     return;
27081
27082   /* Use whatever attributes a normal TM load has.  */
27083   decl = builtin_decl_explicit (BUILT_IN_TM_LOAD_1);
27084   attrs_load = DECL_ATTRIBUTES (decl);
27085   attrs_type_load = TYPE_ATTRIBUTES (TREE_TYPE (decl));
27086   /* Use whatever attributes a normal TM store has.  */
27087   decl = builtin_decl_explicit (BUILT_IN_TM_STORE_1);
27088   attrs_store = DECL_ATTRIBUTES (decl);
27089   attrs_type_store = TYPE_ATTRIBUTES (TREE_TYPE (decl));
27090   /* Use whatever attributes a normal TM log has.  */
27091   decl = builtin_decl_explicit (BUILT_IN_TM_LOG);
27092   attrs_log = DECL_ATTRIBUTES (decl);
27093   attrs_type_log = TYPE_ATTRIBUTES (TREE_TYPE (decl));
27094
27095   for (i = 0, d = bdesc_tm;
27096        i < ARRAY_SIZE (bdesc_tm);
27097        i++, d++)
27098     {
27099       if ((d->mask & ix86_isa_flags) != 0
27100           || (lang_hooks.builtin_function
27101               == lang_hooks.builtin_function_ext_scope))
27102         {
27103           tree type, attrs, attrs_type;
27104           enum built_in_function code = (enum built_in_function) d->code;
27105
27106           ftype = (enum ix86_builtin_func_type) d->flag;
27107           type = ix86_get_builtin_func_type (ftype);
27108
27109           if (BUILTIN_TM_LOAD_P (code))
27110             {
27111               attrs = attrs_load;
27112               attrs_type = attrs_type_load;
27113             }
27114           else if (BUILTIN_TM_STORE_P (code))
27115             {
27116               attrs = attrs_store;
27117               attrs_type = attrs_type_store;
27118             }
27119           else
27120             {
27121               attrs = attrs_log;
27122               attrs_type = attrs_type_log;
27123             }
27124           decl = add_builtin_function (d->name, type, code, BUILT_IN_NORMAL,
27125                                        /* The builtin without the prefix for
27126                                           calling it directly.  */
27127                                        d->name + strlen ("__builtin_"),
27128                                        attrs);
27129           /* add_builtin_function() will set the DECL_ATTRIBUTES, now
27130              set the TYPE_ATTRIBUTES.  */
27131           decl_attributes (&TREE_TYPE (decl), attrs_type, ATTR_FLAG_BUILT_IN);
27132
27133           set_builtin_decl (code, decl, false);
27134         }
27135     }
27136 }
27137
27138 /* Set up all the MMX/SSE builtins, even builtins for instructions that are not
27139    in the current target ISA to allow the user to compile particular modules
27140    with different target specific options that differ from the command line
27141    options.  */
27142 static void
27143 ix86_init_mmx_sse_builtins (void)
27144 {
27145   const struct builtin_description * d;
27146   enum ix86_builtin_func_type ftype;
27147   size_t i;
27148
27149   /* Add all special builtins with variable number of operands.  */
27150   for (i = 0, d = bdesc_special_args;
27151        i < ARRAY_SIZE (bdesc_special_args);
27152        i++, d++)
27153     {
27154       if (d->name == 0)
27155         continue;
27156
27157       ftype = (enum ix86_builtin_func_type) d->flag;
27158       def_builtin (d->mask, d->name, ftype, d->code);
27159     }
27160
27161   /* Add all builtins with variable number of operands.  */
27162   for (i = 0, d = bdesc_args;
27163        i < ARRAY_SIZE (bdesc_args);
27164        i++, d++)
27165     {
27166       if (d->name == 0)
27167         continue;
27168
27169       ftype = (enum ix86_builtin_func_type) d->flag;
27170       def_builtin_const (d->mask, d->name, ftype, d->code);
27171     }
27172
27173   /* pcmpestr[im] insns.  */
27174   for (i = 0, d = bdesc_pcmpestr;
27175        i < ARRAY_SIZE (bdesc_pcmpestr);
27176        i++, d++)
27177     {
27178       if (d->code == IX86_BUILTIN_PCMPESTRM128)
27179         ftype = V16QI_FTYPE_V16QI_INT_V16QI_INT_INT;
27180       else
27181         ftype = INT_FTYPE_V16QI_INT_V16QI_INT_INT;
27182       def_builtin_const (d->mask, d->name, ftype, d->code);
27183     }
27184
27185   /* pcmpistr[im] insns.  */
27186   for (i = 0, d = bdesc_pcmpistr;
27187        i < ARRAY_SIZE (bdesc_pcmpistr);
27188        i++, d++)
27189     {
27190       if (d->code == IX86_BUILTIN_PCMPISTRM128)
27191         ftype = V16QI_FTYPE_V16QI_V16QI_INT;
27192       else
27193         ftype = INT_FTYPE_V16QI_V16QI_INT;
27194       def_builtin_const (d->mask, d->name, ftype, d->code);
27195     }
27196
27197   /* comi/ucomi insns.  */
27198   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
27199     {
27200       if (d->mask == OPTION_MASK_ISA_SSE2)
27201         ftype = INT_FTYPE_V2DF_V2DF;
27202       else
27203         ftype = INT_FTYPE_V4SF_V4SF;
27204       def_builtin_const (d->mask, d->name, ftype, d->code);
27205     }
27206
27207   /* SSE */
27208   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_ldmxcsr",
27209                VOID_FTYPE_UNSIGNED, IX86_BUILTIN_LDMXCSR);
27210   def_builtin (OPTION_MASK_ISA_SSE, "__builtin_ia32_stmxcsr",
27211                UNSIGNED_FTYPE_VOID, IX86_BUILTIN_STMXCSR);
27212
27213   /* SSE or 3DNow!A */
27214   def_builtin (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
27215                "__builtin_ia32_maskmovq", VOID_FTYPE_V8QI_V8QI_PCHAR,
27216                IX86_BUILTIN_MASKMOVQ);
27217
27218   /* SSE2 */
27219   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_maskmovdqu",
27220                VOID_FTYPE_V16QI_V16QI_PCHAR, IX86_BUILTIN_MASKMOVDQU);
27221
27222   def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_clflush",
27223                VOID_FTYPE_PCVOID, IX86_BUILTIN_CLFLUSH);
27224   x86_mfence = def_builtin (OPTION_MASK_ISA_SSE2, "__builtin_ia32_mfence",
27225                             VOID_FTYPE_VOID, IX86_BUILTIN_MFENCE);
27226
27227   /* SSE3.  */
27228   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_monitor",
27229                VOID_FTYPE_PCVOID_UNSIGNED_UNSIGNED, IX86_BUILTIN_MONITOR);
27230   def_builtin (OPTION_MASK_ISA_SSE3, "__builtin_ia32_mwait",
27231                VOID_FTYPE_UNSIGNED_UNSIGNED, IX86_BUILTIN_MWAIT);
27232
27233   /* AES */
27234   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenc128",
27235                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENC128);
27236   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesenclast128",
27237                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESENCLAST128);
27238   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdec128",
27239                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDEC128);
27240   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesdeclast128",
27241                      V2DI_FTYPE_V2DI_V2DI, IX86_BUILTIN_AESDECLAST128);
27242   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aesimc128",
27243                      V2DI_FTYPE_V2DI, IX86_BUILTIN_AESIMC128);
27244   def_builtin_const (OPTION_MASK_ISA_AES, "__builtin_ia32_aeskeygenassist128",
27245                      V2DI_FTYPE_V2DI_INT, IX86_BUILTIN_AESKEYGENASSIST128);
27246
27247   /* PCLMUL */
27248   def_builtin_const (OPTION_MASK_ISA_PCLMUL, "__builtin_ia32_pclmulqdq128",
27249                      V2DI_FTYPE_V2DI_V2DI_INT, IX86_BUILTIN_PCLMULQDQ128);
27250
27251   /* RDRND */
27252   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand16_step",
27253                INT_FTYPE_PUSHORT, IX86_BUILTIN_RDRAND16_STEP);
27254   def_builtin (OPTION_MASK_ISA_RDRND, "__builtin_ia32_rdrand32_step",
27255                INT_FTYPE_PUNSIGNED, IX86_BUILTIN_RDRAND32_STEP);
27256   def_builtin (OPTION_MASK_ISA_RDRND | OPTION_MASK_ISA_64BIT,
27257                "__builtin_ia32_rdrand64_step", INT_FTYPE_PULONGLONG,
27258                IX86_BUILTIN_RDRAND64_STEP);
27259
27260   /* AVX2 */
27261   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv2df",
27262                V2DF_FTYPE_V2DF_PCDOUBLE_V4SI_V2DF_INT,
27263                IX86_BUILTIN_GATHERSIV2DF);
27264
27265   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4df",
27266                V4DF_FTYPE_V4DF_PCDOUBLE_V4SI_V4DF_INT,
27267                IX86_BUILTIN_GATHERSIV4DF);
27268
27269   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv2df",
27270                V2DF_FTYPE_V2DF_PCDOUBLE_V2DI_V2DF_INT,
27271                IX86_BUILTIN_GATHERDIV2DF);
27272
27273   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4df",
27274                V4DF_FTYPE_V4DF_PCDOUBLE_V4DI_V4DF_INT,
27275                IX86_BUILTIN_GATHERDIV4DF);
27276
27277   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4sf",
27278                V4SF_FTYPE_V4SF_PCFLOAT_V4SI_V4SF_INT,
27279                IX86_BUILTIN_GATHERSIV4SF);
27280
27281   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv8sf",
27282                V8SF_FTYPE_V8SF_PCFLOAT_V8SI_V8SF_INT,
27283                IX86_BUILTIN_GATHERSIV8SF);
27284
27285   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4sf",
27286                V4SF_FTYPE_V4SF_PCFLOAT_V2DI_V4SF_INT,
27287                IX86_BUILTIN_GATHERDIV4SF);
27288
27289   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4sf256",
27290                V4SF_FTYPE_V4SF_PCFLOAT_V4DI_V4SF_INT,
27291                IX86_BUILTIN_GATHERDIV8SF);
27292
27293   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv2di",
27294                V2DI_FTYPE_V2DI_PCINT64_V4SI_V2DI_INT,
27295                IX86_BUILTIN_GATHERSIV2DI);
27296
27297   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4di",
27298                V4DI_FTYPE_V4DI_PCINT64_V4SI_V4DI_INT,
27299                IX86_BUILTIN_GATHERSIV4DI);
27300
27301   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv2di",
27302                V2DI_FTYPE_V2DI_PCINT64_V2DI_V2DI_INT,
27303                IX86_BUILTIN_GATHERDIV2DI);
27304
27305   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4di",
27306                V4DI_FTYPE_V4DI_PCINT64_V4DI_V4DI_INT,
27307                IX86_BUILTIN_GATHERDIV4DI);
27308
27309   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv4si",
27310                V4SI_FTYPE_V4SI_PCINT_V4SI_V4SI_INT,
27311                IX86_BUILTIN_GATHERSIV4SI);
27312
27313   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gathersiv8si",
27314                V8SI_FTYPE_V8SI_PCINT_V8SI_V8SI_INT,
27315                IX86_BUILTIN_GATHERSIV8SI);
27316
27317   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4si",
27318                V4SI_FTYPE_V4SI_PCINT_V2DI_V4SI_INT,
27319                IX86_BUILTIN_GATHERDIV4SI);
27320
27321   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatherdiv4si256",
27322                V4SI_FTYPE_V4SI_PCINT_V4DI_V4SI_INT,
27323                IX86_BUILTIN_GATHERDIV8SI);
27324
27325   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatheraltsiv4df ",
27326                V4DF_FTYPE_V4DF_PCDOUBLE_V8SI_V4DF_INT,
27327                IX86_BUILTIN_GATHERALTSIV4DF);
27328
27329   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatheraltdiv4sf256 ",
27330                V8SF_FTYPE_V8SF_PCFLOAT_V4DI_V8SF_INT,
27331                IX86_BUILTIN_GATHERALTDIV8SF);
27332
27333   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatheraltsiv4di ",
27334                V4DI_FTYPE_V4DI_PCINT64_V8SI_V4DI_INT,
27335                IX86_BUILTIN_GATHERALTSIV4DI);
27336
27337   def_builtin (OPTION_MASK_ISA_AVX2, "__builtin_ia32_gatheraltdiv4si256 ",
27338                V8SI_FTYPE_V8SI_PCINT_V4DI_V8SI_INT,
27339                IX86_BUILTIN_GATHERALTDIV8SI);
27340
27341   /* MMX access to the vec_init patterns.  */
27342   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v2si",
27343                      V2SI_FTYPE_INT_INT, IX86_BUILTIN_VEC_INIT_V2SI);
27344
27345   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v4hi",
27346                      V4HI_FTYPE_HI_HI_HI_HI,
27347                      IX86_BUILTIN_VEC_INIT_V4HI);
27348
27349   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_init_v8qi",
27350                      V8QI_FTYPE_QI_QI_QI_QI_QI_QI_QI_QI,
27351                      IX86_BUILTIN_VEC_INIT_V8QI);
27352
27353   /* Access to the vec_extract patterns.  */
27354   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2df",
27355                      DOUBLE_FTYPE_V2DF_INT, IX86_BUILTIN_VEC_EXT_V2DF);
27356   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v2di",
27357                      DI_FTYPE_V2DI_INT, IX86_BUILTIN_VEC_EXT_V2DI);
27358   def_builtin_const (OPTION_MASK_ISA_SSE, "__builtin_ia32_vec_ext_v4sf",
27359                      FLOAT_FTYPE_V4SF_INT, IX86_BUILTIN_VEC_EXT_V4SF);
27360   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v4si",
27361                      SI_FTYPE_V4SI_INT, IX86_BUILTIN_VEC_EXT_V4SI);
27362   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v8hi",
27363                      HI_FTYPE_V8HI_INT, IX86_BUILTIN_VEC_EXT_V8HI);
27364
27365   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
27366                      "__builtin_ia32_vec_ext_v4hi",
27367                      HI_FTYPE_V4HI_INT, IX86_BUILTIN_VEC_EXT_V4HI);
27368
27369   def_builtin_const (OPTION_MASK_ISA_MMX, "__builtin_ia32_vec_ext_v2si",
27370                      SI_FTYPE_V2SI_INT, IX86_BUILTIN_VEC_EXT_V2SI);
27371
27372   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_ext_v16qi",
27373                      QI_FTYPE_V16QI_INT, IX86_BUILTIN_VEC_EXT_V16QI);
27374
27375   /* Access to the vec_set patterns.  */
27376   def_builtin_const (OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_64BIT,
27377                      "__builtin_ia32_vec_set_v2di",
27378                      V2DI_FTYPE_V2DI_DI_INT, IX86_BUILTIN_VEC_SET_V2DI);
27379
27380   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4sf",
27381                      V4SF_FTYPE_V4SF_FLOAT_INT, IX86_BUILTIN_VEC_SET_V4SF);
27382
27383   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v4si",
27384                      V4SI_FTYPE_V4SI_SI_INT, IX86_BUILTIN_VEC_SET_V4SI);
27385
27386   def_builtin_const (OPTION_MASK_ISA_SSE2, "__builtin_ia32_vec_set_v8hi",
27387                      V8HI_FTYPE_V8HI_HI_INT, IX86_BUILTIN_VEC_SET_V8HI);
27388
27389   def_builtin_const (OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_3DNOW_A,
27390                      "__builtin_ia32_vec_set_v4hi",
27391                      V4HI_FTYPE_V4HI_HI_INT, IX86_BUILTIN_VEC_SET_V4HI);
27392
27393   def_builtin_const (OPTION_MASK_ISA_SSE4_1, "__builtin_ia32_vec_set_v16qi",
27394                      V16QI_FTYPE_V16QI_QI_INT, IX86_BUILTIN_VEC_SET_V16QI);
27395
27396   /* Add FMA4 multi-arg argument instructions */
27397   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
27398     {
27399       if (d->name == 0)
27400         continue;
27401
27402       ftype = (enum ix86_builtin_func_type) d->flag;
27403       def_builtin_const (d->mask, d->name, ftype, d->code);
27404     }
27405 }
27406
27407 /* Internal method for ix86_init_builtins.  */
27408
27409 static void
27410 ix86_init_builtins_va_builtins_abi (void)
27411 {
27412   tree ms_va_ref, sysv_va_ref;
27413   tree fnvoid_va_end_ms, fnvoid_va_end_sysv;
27414   tree fnvoid_va_start_ms, fnvoid_va_start_sysv;
27415   tree fnvoid_va_copy_ms, fnvoid_va_copy_sysv;
27416   tree fnattr_ms = NULL_TREE, fnattr_sysv = NULL_TREE;
27417
27418   if (!TARGET_64BIT)
27419     return;
27420   fnattr_ms = build_tree_list (get_identifier ("ms_abi"), NULL_TREE);
27421   fnattr_sysv = build_tree_list (get_identifier ("sysv_abi"), NULL_TREE);
27422   ms_va_ref = build_reference_type (ms_va_list_type_node);
27423   sysv_va_ref =
27424     build_pointer_type (TREE_TYPE (sysv_va_list_type_node));
27425
27426   fnvoid_va_end_ms =
27427     build_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
27428   fnvoid_va_start_ms =
27429     build_varargs_function_type_list (void_type_node, ms_va_ref, NULL_TREE);
27430   fnvoid_va_end_sysv =
27431     build_function_type_list (void_type_node, sysv_va_ref, NULL_TREE);
27432   fnvoid_va_start_sysv =
27433     build_varargs_function_type_list (void_type_node, sysv_va_ref,
27434                                        NULL_TREE);
27435   fnvoid_va_copy_ms =
27436     build_function_type_list (void_type_node, ms_va_ref, ms_va_list_type_node,
27437                               NULL_TREE);
27438   fnvoid_va_copy_sysv =
27439     build_function_type_list (void_type_node, sysv_va_ref,
27440                               sysv_va_ref, NULL_TREE);
27441
27442   add_builtin_function ("__builtin_ms_va_start", fnvoid_va_start_ms,
27443                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_ms);
27444   add_builtin_function ("__builtin_ms_va_end", fnvoid_va_end_ms,
27445                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_ms);
27446   add_builtin_function ("__builtin_ms_va_copy", fnvoid_va_copy_ms,
27447                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_ms);
27448   add_builtin_function ("__builtin_sysv_va_start", fnvoid_va_start_sysv,
27449                         BUILT_IN_VA_START, BUILT_IN_NORMAL, NULL, fnattr_sysv);
27450   add_builtin_function ("__builtin_sysv_va_end", fnvoid_va_end_sysv,
27451                         BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL, fnattr_sysv);
27452   add_builtin_function ("__builtin_sysv_va_copy", fnvoid_va_copy_sysv,
27453                         BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL, fnattr_sysv);
27454 }
27455
27456 static void
27457 ix86_init_builtin_types (void)
27458 {
27459   tree float128_type_node, float80_type_node;
27460
27461   /* The __float80 type.  */
27462   float80_type_node = long_double_type_node;
27463   if (TYPE_MODE (float80_type_node) != XFmode)
27464     {
27465       /* The __float80 type.  */
27466       float80_type_node = make_node (REAL_TYPE);
27467
27468       TYPE_PRECISION (float80_type_node) = 80;
27469       layout_type (float80_type_node);
27470     }
27471   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
27472
27473   /* The __float128 type.  */
27474   float128_type_node = make_node (REAL_TYPE);
27475   TYPE_PRECISION (float128_type_node) = 128;
27476   layout_type (float128_type_node);
27477   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
27478
27479   /* This macro is built by i386-builtin-types.awk.  */
27480   DEFINE_BUILTIN_PRIMITIVE_TYPES;
27481 }
27482
27483 static void
27484 ix86_init_builtins (void)
27485 {
27486   tree t;
27487
27488   ix86_init_builtin_types ();
27489
27490   /* TFmode support builtins.  */
27491   def_builtin_const (0, "__builtin_infq",
27492                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_INFQ);
27493   def_builtin_const (0, "__builtin_huge_valq",
27494                      FLOAT128_FTYPE_VOID, IX86_BUILTIN_HUGE_VALQ);
27495
27496   /* We will expand them to normal call if SSE2 isn't available since
27497      they are used by libgcc. */
27498   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128);
27499   t = add_builtin_function ("__builtin_fabsq", t, IX86_BUILTIN_FABSQ,
27500                             BUILT_IN_MD, "__fabstf2", NULL_TREE);
27501   TREE_READONLY (t) = 1;
27502   ix86_builtins[(int) IX86_BUILTIN_FABSQ] = t;
27503
27504   t = ix86_get_builtin_func_type (FLOAT128_FTYPE_FLOAT128_FLOAT128);
27505   t = add_builtin_function ("__builtin_copysignq", t, IX86_BUILTIN_COPYSIGNQ,
27506                             BUILT_IN_MD, "__copysigntf3", NULL_TREE);
27507   TREE_READONLY (t) = 1;
27508   ix86_builtins[(int) IX86_BUILTIN_COPYSIGNQ] = t;
27509
27510   ix86_init_tm_builtins ();
27511   ix86_init_mmx_sse_builtins ();
27512
27513   if (TARGET_LP64)
27514     ix86_init_builtins_va_builtins_abi ();
27515
27516 #ifdef SUBTARGET_INIT_BUILTINS
27517   SUBTARGET_INIT_BUILTINS;
27518 #endif
27519 }
27520
27521 /* Return the ix86 builtin for CODE.  */
27522
27523 static tree
27524 ix86_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
27525 {
27526   if (code >= IX86_BUILTIN_MAX)
27527     return error_mark_node;
27528
27529   return ix86_builtins[code];
27530 }
27531
27532 /* Errors in the source file can cause expand_expr to return const0_rtx
27533    where we expect a vector.  To avoid crashing, use one of the vector
27534    clear instructions.  */
27535 static rtx
27536 safe_vector_operand (rtx x, enum machine_mode mode)
27537 {
27538   if (x == const0_rtx)
27539     x = CONST0_RTX (mode);
27540   return x;
27541 }
27542
27543 /* Subroutine of ix86_expand_builtin to take care of binop insns.  */
27544
27545 static rtx
27546 ix86_expand_binop_builtin (enum insn_code icode, tree exp, rtx target)
27547 {
27548   rtx pat;
27549   tree arg0 = CALL_EXPR_ARG (exp, 0);
27550   tree arg1 = CALL_EXPR_ARG (exp, 1);
27551   rtx op0 = expand_normal (arg0);
27552   rtx op1 = expand_normal (arg1);
27553   enum machine_mode tmode = insn_data[icode].operand[0].mode;
27554   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
27555   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
27556
27557   if (VECTOR_MODE_P (mode0))
27558     op0 = safe_vector_operand (op0, mode0);
27559   if (VECTOR_MODE_P (mode1))
27560     op1 = safe_vector_operand (op1, mode1);
27561
27562   if (optimize || !target
27563       || GET_MODE (target) != tmode
27564       || !insn_data[icode].operand[0].predicate (target, tmode))
27565     target = gen_reg_rtx (tmode);
27566
27567   if (GET_MODE (op1) == SImode && mode1 == TImode)
27568     {
27569       rtx x = gen_reg_rtx (V4SImode);
27570       emit_insn (gen_sse2_loadd (x, op1));
27571       op1 = gen_lowpart (TImode, x);
27572     }
27573
27574   if (!insn_data[icode].operand[1].predicate (op0, mode0))
27575     op0 = copy_to_mode_reg (mode0, op0);
27576   if (!insn_data[icode].operand[2].predicate (op1, mode1))
27577     op1 = copy_to_mode_reg (mode1, op1);
27578
27579   pat = GEN_FCN (icode) (target, op0, op1);
27580   if (! pat)
27581     return 0;
27582
27583   emit_insn (pat);
27584
27585   return target;
27586 }
27587
27588 /* Subroutine of ix86_expand_builtin to take care of 2-4 argument insns.  */
27589
27590 static rtx
27591 ix86_expand_multi_arg_builtin (enum insn_code icode, tree exp, rtx target,
27592                                enum ix86_builtin_func_type m_type,
27593                                enum rtx_code sub_code)
27594 {
27595   rtx pat;
27596   int i;
27597   int nargs;
27598   bool comparison_p = false;
27599   bool tf_p = false;
27600   bool last_arg_constant = false;
27601   int num_memory = 0;
27602   struct {
27603     rtx op;
27604     enum machine_mode mode;
27605   } args[4];
27606
27607   enum machine_mode tmode = insn_data[icode].operand[0].mode;
27608
27609   switch (m_type)
27610     {
27611     case MULTI_ARG_4_DF2_DI_I:
27612     case MULTI_ARG_4_DF2_DI_I1:
27613     case MULTI_ARG_4_SF2_SI_I:
27614     case MULTI_ARG_4_SF2_SI_I1:
27615       nargs = 4;
27616       last_arg_constant = true;
27617       break;
27618
27619     case MULTI_ARG_3_SF:
27620     case MULTI_ARG_3_DF:
27621     case MULTI_ARG_3_SF2:
27622     case MULTI_ARG_3_DF2:
27623     case MULTI_ARG_3_DI:
27624     case MULTI_ARG_3_SI:
27625     case MULTI_ARG_3_SI_DI:
27626     case MULTI_ARG_3_HI:
27627     case MULTI_ARG_3_HI_SI:
27628     case MULTI_ARG_3_QI:
27629     case MULTI_ARG_3_DI2:
27630     case MULTI_ARG_3_SI2:
27631     case MULTI_ARG_3_HI2:
27632     case MULTI_ARG_3_QI2:
27633       nargs = 3;
27634       break;
27635
27636     case MULTI_ARG_2_SF:
27637     case MULTI_ARG_2_DF:
27638     case MULTI_ARG_2_DI:
27639     case MULTI_ARG_2_SI:
27640     case MULTI_ARG_2_HI:
27641     case MULTI_ARG_2_QI:
27642       nargs = 2;
27643       break;
27644
27645     case MULTI_ARG_2_DI_IMM:
27646     case MULTI_ARG_2_SI_IMM:
27647     case MULTI_ARG_2_HI_IMM:
27648     case MULTI_ARG_2_QI_IMM:
27649       nargs = 2;
27650       last_arg_constant = true;
27651       break;
27652
27653     case MULTI_ARG_1_SF:
27654     case MULTI_ARG_1_DF:
27655     case MULTI_ARG_1_SF2:
27656     case MULTI_ARG_1_DF2:
27657     case MULTI_ARG_1_DI:
27658     case MULTI_ARG_1_SI:
27659     case MULTI_ARG_1_HI:
27660     case MULTI_ARG_1_QI:
27661     case MULTI_ARG_1_SI_DI:
27662     case MULTI_ARG_1_HI_DI:
27663     case MULTI_ARG_1_HI_SI:
27664     case MULTI_ARG_1_QI_DI:
27665     case MULTI_ARG_1_QI_SI:
27666     case MULTI_ARG_1_QI_HI:
27667       nargs = 1;
27668       break;
27669
27670     case MULTI_ARG_2_DI_CMP:
27671     case MULTI_ARG_2_SI_CMP:
27672     case MULTI_ARG_2_HI_CMP:
27673     case MULTI_ARG_2_QI_CMP:
27674       nargs = 2;
27675       comparison_p = true;
27676       break;
27677
27678     case MULTI_ARG_2_SF_TF:
27679     case MULTI_ARG_2_DF_TF:
27680     case MULTI_ARG_2_DI_TF:
27681     case MULTI_ARG_2_SI_TF:
27682     case MULTI_ARG_2_HI_TF:
27683     case MULTI_ARG_2_QI_TF:
27684       nargs = 2;
27685       tf_p = true;
27686       break;
27687
27688     default:
27689       gcc_unreachable ();
27690     }
27691
27692   if (optimize || !target
27693       || GET_MODE (target) != tmode
27694       || !insn_data[icode].operand[0].predicate (target, tmode))
27695     target = gen_reg_rtx (tmode);
27696
27697   gcc_assert (nargs <= 4);
27698
27699   for (i = 0; i < nargs; i++)
27700     {
27701       tree arg = CALL_EXPR_ARG (exp, i);
27702       rtx op = expand_normal (arg);
27703       int adjust = (comparison_p) ? 1 : 0;
27704       enum machine_mode mode = insn_data[icode].operand[i+adjust+1].mode;
27705
27706       if (last_arg_constant && i == nargs - 1)
27707         {
27708           if (!insn_data[icode].operand[i + 1].predicate (op, mode))
27709             {
27710               enum insn_code new_icode = icode;
27711               switch (icode)
27712                 {
27713                 case CODE_FOR_xop_vpermil2v2df3:
27714                 case CODE_FOR_xop_vpermil2v4sf3:
27715                 case CODE_FOR_xop_vpermil2v4df3:
27716                 case CODE_FOR_xop_vpermil2v8sf3:
27717                   error ("the last argument must be a 2-bit immediate");
27718                   return gen_reg_rtx (tmode);
27719                 case CODE_FOR_xop_rotlv2di3:
27720                   new_icode = CODE_FOR_rotlv2di3;
27721                   goto xop_rotl;
27722                 case CODE_FOR_xop_rotlv4si3:
27723                   new_icode = CODE_FOR_rotlv4si3;
27724                   goto xop_rotl;
27725                 case CODE_FOR_xop_rotlv8hi3:
27726                   new_icode = CODE_FOR_rotlv8hi3;
27727                   goto xop_rotl;
27728                 case CODE_FOR_xop_rotlv16qi3:
27729                   new_icode = CODE_FOR_rotlv16qi3;
27730                 xop_rotl:
27731                   if (CONST_INT_P (op))
27732                     {
27733                       int mask = GET_MODE_BITSIZE (GET_MODE_INNER (tmode)) - 1;
27734                       op = GEN_INT (INTVAL (op) & mask);
27735                       gcc_checking_assert
27736                         (insn_data[icode].operand[i + 1].predicate (op, mode));
27737                     }
27738                   else
27739                     {
27740                       gcc_checking_assert
27741                         (nargs == 2
27742                          && insn_data[new_icode].operand[0].mode == tmode
27743                          && insn_data[new_icode].operand[1].mode == tmode
27744                          && insn_data[new_icode].operand[2].mode == mode
27745                          && insn_data[new_icode].operand[0].predicate
27746                             == insn_data[icode].operand[0].predicate
27747                          && insn_data[new_icode].operand[1].predicate
27748                             == insn_data[icode].operand[1].predicate);
27749                       icode = new_icode;
27750                       goto non_constant;
27751                     }
27752                   break;
27753                 default:
27754                   gcc_unreachable ();
27755                 }
27756             }
27757         }
27758       else
27759         {
27760         non_constant:
27761           if (VECTOR_MODE_P (mode))
27762             op = safe_vector_operand (op, mode);
27763
27764           /* If we aren't optimizing, only allow one memory operand to be
27765              generated.  */
27766           if (memory_operand (op, mode))
27767             num_memory++;
27768
27769           gcc_assert (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode);
27770
27771           if (optimize
27772               || !insn_data[icode].operand[i+adjust+1].predicate (op, mode)
27773               || num_memory > 1)
27774             op = force_reg (mode, op);
27775         }
27776
27777       args[i].op = op;
27778       args[i].mode = mode;
27779     }
27780
27781   switch (nargs)
27782     {
27783     case 1:
27784       pat = GEN_FCN (icode) (target, args[0].op);
27785       break;
27786
27787     case 2:
27788       if (tf_p)
27789         pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
27790                                GEN_INT ((int)sub_code));
27791       else if (! comparison_p)
27792         pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
27793       else
27794         {
27795           rtx cmp_op = gen_rtx_fmt_ee (sub_code, GET_MODE (target),
27796                                        args[0].op,
27797                                        args[1].op);
27798
27799           pat = GEN_FCN (icode) (target, cmp_op, args[0].op, args[1].op);
27800         }
27801       break;
27802
27803     case 3:
27804       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
27805       break;
27806
27807     case 4:
27808       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op, args[3].op);
27809       break;
27810
27811     default:
27812       gcc_unreachable ();
27813     }
27814
27815   if (! pat)
27816     return 0;
27817
27818   emit_insn (pat);
27819   return target;
27820 }
27821
27822 /* Subroutine of ix86_expand_args_builtin to take care of scalar unop
27823    insns with vec_merge.  */
27824
27825 static rtx
27826 ix86_expand_unop_vec_merge_builtin (enum insn_code icode, tree exp,
27827                                     rtx target)
27828 {
27829   rtx pat;
27830   tree arg0 = CALL_EXPR_ARG (exp, 0);
27831   rtx op1, op0 = expand_normal (arg0);
27832   enum machine_mode tmode = insn_data[icode].operand[0].mode;
27833   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
27834
27835   if (optimize || !target
27836       || GET_MODE (target) != tmode
27837       || !insn_data[icode].operand[0].predicate (target, tmode))
27838     target = gen_reg_rtx (tmode);
27839
27840   if (VECTOR_MODE_P (mode0))
27841     op0 = safe_vector_operand (op0, mode0);
27842
27843   if ((optimize && !register_operand (op0, mode0))
27844       || !insn_data[icode].operand[1].predicate (op0, mode0))
27845     op0 = copy_to_mode_reg (mode0, op0);
27846
27847   op1 = op0;
27848   if (!insn_data[icode].operand[2].predicate (op1, mode0))
27849     op1 = copy_to_mode_reg (mode0, op1);
27850
27851   pat = GEN_FCN (icode) (target, op0, op1);
27852   if (! pat)
27853     return 0;
27854   emit_insn (pat);
27855   return target;
27856 }
27857
27858 /* Subroutine of ix86_expand_builtin to take care of comparison insns.  */
27859
27860 static rtx
27861 ix86_expand_sse_compare (const struct builtin_description *d,
27862                          tree exp, rtx target, bool swap)
27863 {
27864   rtx pat;
27865   tree arg0 = CALL_EXPR_ARG (exp, 0);
27866   tree arg1 = CALL_EXPR_ARG (exp, 1);
27867   rtx op0 = expand_normal (arg0);
27868   rtx op1 = expand_normal (arg1);
27869   rtx op2;
27870   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
27871   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
27872   enum machine_mode mode1 = insn_data[d->icode].operand[2].mode;
27873   enum rtx_code comparison = d->comparison;
27874
27875   if (VECTOR_MODE_P (mode0))
27876     op0 = safe_vector_operand (op0, mode0);
27877   if (VECTOR_MODE_P (mode1))
27878     op1 = safe_vector_operand (op1, mode1);
27879
27880   /* Swap operands if we have a comparison that isn't available in
27881      hardware.  */
27882   if (swap)
27883     {
27884       rtx tmp = gen_reg_rtx (mode1);
27885       emit_move_insn (tmp, op1);
27886       op1 = op0;
27887       op0 = tmp;
27888     }
27889
27890   if (optimize || !target
27891       || GET_MODE (target) != tmode
27892       || !insn_data[d->icode].operand[0].predicate (target, tmode))
27893     target = gen_reg_rtx (tmode);
27894
27895   if ((optimize && !register_operand (op0, mode0))
27896       || !insn_data[d->icode].operand[1].predicate (op0, mode0))
27897     op0 = copy_to_mode_reg (mode0, op0);
27898   if ((optimize && !register_operand (op1, mode1))
27899       || !insn_data[d->icode].operand[2].predicate (op1, mode1))
27900     op1 = copy_to_mode_reg (mode1, op1);
27901
27902   op2 = gen_rtx_fmt_ee (comparison, mode0, op0, op1);
27903   pat = GEN_FCN (d->icode) (target, op0, op1, op2);
27904   if (! pat)
27905     return 0;
27906   emit_insn (pat);
27907   return target;
27908 }
27909
27910 /* Subroutine of ix86_expand_builtin to take care of comi insns.  */
27911
27912 static rtx
27913 ix86_expand_sse_comi (const struct builtin_description *d, tree exp,
27914                       rtx target)
27915 {
27916   rtx pat;
27917   tree arg0 = CALL_EXPR_ARG (exp, 0);
27918   tree arg1 = CALL_EXPR_ARG (exp, 1);
27919   rtx op0 = expand_normal (arg0);
27920   rtx op1 = expand_normal (arg1);
27921   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
27922   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
27923   enum rtx_code comparison = d->comparison;
27924
27925   if (VECTOR_MODE_P (mode0))
27926     op0 = safe_vector_operand (op0, mode0);
27927   if (VECTOR_MODE_P (mode1))
27928     op1 = safe_vector_operand (op1, mode1);
27929
27930   /* Swap operands if we have a comparison that isn't available in
27931      hardware.  */
27932   if (d->flag & BUILTIN_DESC_SWAP_OPERANDS)
27933     {
27934       rtx tmp = op1;
27935       op1 = op0;
27936       op0 = tmp;
27937     }
27938
27939   target = gen_reg_rtx (SImode);
27940   emit_move_insn (target, const0_rtx);
27941   target = gen_rtx_SUBREG (QImode, target, 0);
27942
27943   if ((optimize && !register_operand (op0, mode0))
27944       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
27945     op0 = copy_to_mode_reg (mode0, op0);
27946   if ((optimize && !register_operand (op1, mode1))
27947       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
27948     op1 = copy_to_mode_reg (mode1, op1);
27949
27950   pat = GEN_FCN (d->icode) (op0, op1);
27951   if (! pat)
27952     return 0;
27953   emit_insn (pat);
27954   emit_insn (gen_rtx_SET (VOIDmode,
27955                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
27956                           gen_rtx_fmt_ee (comparison, QImode,
27957                                           SET_DEST (pat),
27958                                           const0_rtx)));
27959
27960   return SUBREG_REG (target);
27961 }
27962
27963 /* Subroutines of ix86_expand_args_builtin to take care of round insns.  */
27964
27965 static rtx
27966 ix86_expand_sse_round (const struct builtin_description *d, tree exp,
27967                        rtx target)
27968 {
27969   rtx pat;
27970   tree arg0 = CALL_EXPR_ARG (exp, 0);
27971   rtx op1, op0 = expand_normal (arg0);
27972   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
27973   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
27974
27975   if (optimize || target == 0
27976       || GET_MODE (target) != tmode
27977       || !insn_data[d->icode].operand[0].predicate (target, tmode))
27978     target = gen_reg_rtx (tmode);
27979
27980   if (VECTOR_MODE_P (mode0))
27981     op0 = safe_vector_operand (op0, mode0);
27982
27983   if ((optimize && !register_operand (op0, mode0))
27984       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
27985     op0 = copy_to_mode_reg (mode0, op0);
27986
27987   op1 = GEN_INT (d->comparison);
27988
27989   pat = GEN_FCN (d->icode) (target, op0, op1);
27990   if (! pat)
27991     return 0;
27992   emit_insn (pat);
27993   return target;
27994 }
27995
27996 static rtx
27997 ix86_expand_sse_round_vec_pack_sfix (const struct builtin_description *d,
27998                                      tree exp, rtx target)
27999 {
28000   rtx pat;
28001   tree arg0 = CALL_EXPR_ARG (exp, 0);
28002   tree arg1 = CALL_EXPR_ARG (exp, 1);
28003   rtx op0 = expand_normal (arg0);
28004   rtx op1 = expand_normal (arg1);
28005   rtx op2;
28006   enum machine_mode tmode = insn_data[d->icode].operand[0].mode;
28007   enum machine_mode mode0 = insn_data[d->icode].operand[1].mode;
28008   enum machine_mode mode1 = insn_data[d->icode].operand[2].mode;
28009
28010   if (optimize || target == 0
28011       || GET_MODE (target) != tmode
28012       || !insn_data[d->icode].operand[0].predicate (target, tmode))
28013     target = gen_reg_rtx (tmode);
28014
28015   op0 = safe_vector_operand (op0, mode0);
28016   op1 = safe_vector_operand (op1, mode1);
28017
28018   if ((optimize && !register_operand (op0, mode0))
28019       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
28020     op0 = copy_to_mode_reg (mode0, op0);
28021   if ((optimize && !register_operand (op1, mode1))
28022       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
28023     op1 = copy_to_mode_reg (mode1, op1);
28024
28025   op2 = GEN_INT (d->comparison);
28026
28027   pat = GEN_FCN (d->icode) (target, op0, op1, op2);
28028   if (! pat)
28029     return 0;
28030   emit_insn (pat);
28031   return target;
28032 }
28033
28034 /* Subroutine of ix86_expand_builtin to take care of ptest insns.  */
28035
28036 static rtx
28037 ix86_expand_sse_ptest (const struct builtin_description *d, tree exp,
28038                        rtx target)
28039 {
28040   rtx pat;
28041   tree arg0 = CALL_EXPR_ARG (exp, 0);
28042   tree arg1 = CALL_EXPR_ARG (exp, 1);
28043   rtx op0 = expand_normal (arg0);
28044   rtx op1 = expand_normal (arg1);
28045   enum machine_mode mode0 = insn_data[d->icode].operand[0].mode;
28046   enum machine_mode mode1 = insn_data[d->icode].operand[1].mode;
28047   enum rtx_code comparison = d->comparison;
28048
28049   if (VECTOR_MODE_P (mode0))
28050     op0 = safe_vector_operand (op0, mode0);
28051   if (VECTOR_MODE_P (mode1))
28052     op1 = safe_vector_operand (op1, mode1);
28053
28054   target = gen_reg_rtx (SImode);
28055   emit_move_insn (target, const0_rtx);
28056   target = gen_rtx_SUBREG (QImode, target, 0);
28057
28058   if ((optimize && !register_operand (op0, mode0))
28059       || !insn_data[d->icode].operand[0].predicate (op0, mode0))
28060     op0 = copy_to_mode_reg (mode0, op0);
28061   if ((optimize && !register_operand (op1, mode1))
28062       || !insn_data[d->icode].operand[1].predicate (op1, mode1))
28063     op1 = copy_to_mode_reg (mode1, op1);
28064
28065   pat = GEN_FCN (d->icode) (op0, op1);
28066   if (! pat)
28067     return 0;
28068   emit_insn (pat);
28069   emit_insn (gen_rtx_SET (VOIDmode,
28070                           gen_rtx_STRICT_LOW_PART (VOIDmode, target),
28071                           gen_rtx_fmt_ee (comparison, QImode,
28072                                           SET_DEST (pat),
28073                                           const0_rtx)));
28074
28075   return SUBREG_REG (target);
28076 }
28077
28078 /* Subroutine of ix86_expand_builtin to take care of pcmpestr[im] insns.  */
28079
28080 static rtx
28081 ix86_expand_sse_pcmpestr (const struct builtin_description *d,
28082                           tree exp, rtx target)
28083 {
28084   rtx pat;
28085   tree arg0 = CALL_EXPR_ARG (exp, 0);
28086   tree arg1 = CALL_EXPR_ARG (exp, 1);
28087   tree arg2 = CALL_EXPR_ARG (exp, 2);
28088   tree arg3 = CALL_EXPR_ARG (exp, 3);
28089   tree arg4 = CALL_EXPR_ARG (exp, 4);
28090   rtx scratch0, scratch1;
28091   rtx op0 = expand_normal (arg0);
28092   rtx op1 = expand_normal (arg1);
28093   rtx op2 = expand_normal (arg2);
28094   rtx op3 = expand_normal (arg3);
28095   rtx op4 = expand_normal (arg4);
28096   enum machine_mode tmode0, tmode1, modev2, modei3, modev4, modei5, modeimm;
28097
28098   tmode0 = insn_data[d->icode].operand[0].mode;
28099   tmode1 = insn_data[d->icode].operand[1].mode;
28100   modev2 = insn_data[d->icode].operand[2].mode;
28101   modei3 = insn_data[d->icode].operand[3].mode;
28102   modev4 = insn_data[d->icode].operand[4].mode;
28103   modei5 = insn_data[d->icode].operand[5].mode;
28104   modeimm = insn_data[d->icode].operand[6].mode;
28105
28106   if (VECTOR_MODE_P (modev2))
28107     op0 = safe_vector_operand (op0, modev2);
28108   if (VECTOR_MODE_P (modev4))
28109     op2 = safe_vector_operand (op2, modev4);
28110
28111   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
28112     op0 = copy_to_mode_reg (modev2, op0);
28113   if (!insn_data[d->icode].operand[3].predicate (op1, modei3))
28114     op1 = copy_to_mode_reg (modei3, op1);
28115   if ((optimize && !register_operand (op2, modev4))
28116       || !insn_data[d->icode].operand[4].predicate (op2, modev4))
28117     op2 = copy_to_mode_reg (modev4, op2);
28118   if (!insn_data[d->icode].operand[5].predicate (op3, modei5))
28119     op3 = copy_to_mode_reg (modei5, op3);
28120
28121   if (!insn_data[d->icode].operand[6].predicate (op4, modeimm))
28122     {
28123       error ("the fifth argument must be an 8-bit immediate");
28124       return const0_rtx;
28125     }
28126
28127   if (d->code == IX86_BUILTIN_PCMPESTRI128)
28128     {
28129       if (optimize || !target
28130           || GET_MODE (target) != tmode0
28131           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
28132         target = gen_reg_rtx (tmode0);
28133
28134       scratch1 = gen_reg_rtx (tmode1);
28135
28136       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2, op3, op4);
28137     }
28138   else if (d->code == IX86_BUILTIN_PCMPESTRM128)
28139     {
28140       if (optimize || !target
28141           || GET_MODE (target) != tmode1
28142           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
28143         target = gen_reg_rtx (tmode1);
28144
28145       scratch0 = gen_reg_rtx (tmode0);
28146
28147       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2, op3, op4);
28148     }
28149   else
28150     {
28151       gcc_assert (d->flag);
28152
28153       scratch0 = gen_reg_rtx (tmode0);
28154       scratch1 = gen_reg_rtx (tmode1);
28155
28156       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2, op3, op4);
28157     }
28158
28159   if (! pat)
28160     return 0;
28161
28162   emit_insn (pat);
28163
28164   if (d->flag)
28165     {
28166       target = gen_reg_rtx (SImode);
28167       emit_move_insn (target, const0_rtx);
28168       target = gen_rtx_SUBREG (QImode, target, 0);
28169
28170       emit_insn
28171         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
28172                       gen_rtx_fmt_ee (EQ, QImode,
28173                                       gen_rtx_REG ((enum machine_mode) d->flag,
28174                                                    FLAGS_REG),
28175                                       const0_rtx)));
28176       return SUBREG_REG (target);
28177     }
28178   else
28179     return target;
28180 }
28181
28182
28183 /* Subroutine of ix86_expand_builtin to take care of pcmpistr[im] insns.  */
28184
28185 static rtx
28186 ix86_expand_sse_pcmpistr (const struct builtin_description *d,
28187                           tree exp, rtx target)
28188 {
28189   rtx pat;
28190   tree arg0 = CALL_EXPR_ARG (exp, 0);
28191   tree arg1 = CALL_EXPR_ARG (exp, 1);
28192   tree arg2 = CALL_EXPR_ARG (exp, 2);
28193   rtx scratch0, scratch1;
28194   rtx op0 = expand_normal (arg0);
28195   rtx op1 = expand_normal (arg1);
28196   rtx op2 = expand_normal (arg2);
28197   enum machine_mode tmode0, tmode1, modev2, modev3, modeimm;
28198
28199   tmode0 = insn_data[d->icode].operand[0].mode;
28200   tmode1 = insn_data[d->icode].operand[1].mode;
28201   modev2 = insn_data[d->icode].operand[2].mode;
28202   modev3 = insn_data[d->icode].operand[3].mode;
28203   modeimm = insn_data[d->icode].operand[4].mode;
28204
28205   if (VECTOR_MODE_P (modev2))
28206     op0 = safe_vector_operand (op0, modev2);
28207   if (VECTOR_MODE_P (modev3))
28208     op1 = safe_vector_operand (op1, modev3);
28209
28210   if (!insn_data[d->icode].operand[2].predicate (op0, modev2))
28211     op0 = copy_to_mode_reg (modev2, op0);
28212   if ((optimize && !register_operand (op1, modev3))
28213       || !insn_data[d->icode].operand[3].predicate (op1, modev3))
28214     op1 = copy_to_mode_reg (modev3, op1);
28215
28216   if (!insn_data[d->icode].operand[4].predicate (op2, modeimm))
28217     {
28218       error ("the third argument must be an 8-bit immediate");
28219       return const0_rtx;
28220     }
28221
28222   if (d->code == IX86_BUILTIN_PCMPISTRI128)
28223     {
28224       if (optimize || !target
28225           || GET_MODE (target) != tmode0
28226           || !insn_data[d->icode].operand[0].predicate (target, tmode0))
28227         target = gen_reg_rtx (tmode0);
28228
28229       scratch1 = gen_reg_rtx (tmode1);
28230
28231       pat = GEN_FCN (d->icode) (target, scratch1, op0, op1, op2);
28232     }
28233   else if (d->code == IX86_BUILTIN_PCMPISTRM128)
28234     {
28235       if (optimize || !target
28236           || GET_MODE (target) != tmode1
28237           || !insn_data[d->icode].operand[1].predicate (target, tmode1))
28238         target = gen_reg_rtx (tmode1);
28239
28240       scratch0 = gen_reg_rtx (tmode0);
28241
28242       pat = GEN_FCN (d->icode) (scratch0, target, op0, op1, op2);
28243     }
28244   else
28245     {
28246       gcc_assert (d->flag);
28247
28248       scratch0 = gen_reg_rtx (tmode0);
28249       scratch1 = gen_reg_rtx (tmode1);
28250
28251       pat = GEN_FCN (d->icode) (scratch0, scratch1, op0, op1, op2);
28252     }
28253
28254   if (! pat)
28255     return 0;
28256
28257   emit_insn (pat);
28258
28259   if (d->flag)
28260     {
28261       target = gen_reg_rtx (SImode);
28262       emit_move_insn (target, const0_rtx);
28263       target = gen_rtx_SUBREG (QImode, target, 0);
28264
28265       emit_insn
28266         (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
28267                       gen_rtx_fmt_ee (EQ, QImode,
28268                                       gen_rtx_REG ((enum machine_mode) d->flag,
28269                                                    FLAGS_REG),
28270                                       const0_rtx)));
28271       return SUBREG_REG (target);
28272     }
28273   else
28274     return target;
28275 }
28276
28277 /* Subroutine of ix86_expand_builtin to take care of insns with
28278    variable number of operands.  */
28279
28280 static rtx
28281 ix86_expand_args_builtin (const struct builtin_description *d,
28282                           tree exp, rtx target)
28283 {
28284   rtx pat, real_target;
28285   unsigned int i, nargs;
28286   unsigned int nargs_constant = 0;
28287   int num_memory = 0;
28288   struct
28289     {
28290       rtx op;
28291       enum machine_mode mode;
28292     } args[4];
28293   bool last_arg_count = false;
28294   enum insn_code icode = d->icode;
28295   const struct insn_data_d *insn_p = &insn_data[icode];
28296   enum machine_mode tmode = insn_p->operand[0].mode;
28297   enum machine_mode rmode = VOIDmode;
28298   bool swap = false;
28299   enum rtx_code comparison = d->comparison;
28300
28301   switch ((enum ix86_builtin_func_type) d->flag)
28302     {
28303     case V2DF_FTYPE_V2DF_ROUND:
28304     case V4DF_FTYPE_V4DF_ROUND:
28305     case V4SF_FTYPE_V4SF_ROUND:
28306     case V8SF_FTYPE_V8SF_ROUND:
28307     case V4SI_FTYPE_V4SF_ROUND:
28308     case V8SI_FTYPE_V8SF_ROUND:
28309       return ix86_expand_sse_round (d, exp, target);
28310     case V4SI_FTYPE_V2DF_V2DF_ROUND:
28311     case V8SI_FTYPE_V4DF_V4DF_ROUND:
28312       return ix86_expand_sse_round_vec_pack_sfix (d, exp, target);
28313     case INT_FTYPE_V8SF_V8SF_PTEST:
28314     case INT_FTYPE_V4DI_V4DI_PTEST:
28315     case INT_FTYPE_V4DF_V4DF_PTEST:
28316     case INT_FTYPE_V4SF_V4SF_PTEST:
28317     case INT_FTYPE_V2DI_V2DI_PTEST:
28318     case INT_FTYPE_V2DF_V2DF_PTEST:
28319       return ix86_expand_sse_ptest (d, exp, target);
28320     case FLOAT128_FTYPE_FLOAT128:
28321     case FLOAT_FTYPE_FLOAT:
28322     case INT_FTYPE_INT:
28323     case UINT64_FTYPE_INT:
28324     case UINT16_FTYPE_UINT16:
28325     case INT64_FTYPE_INT64:
28326     case INT64_FTYPE_V4SF:
28327     case INT64_FTYPE_V2DF:
28328     case INT_FTYPE_V16QI:
28329     case INT_FTYPE_V8QI:
28330     case INT_FTYPE_V8SF:
28331     case INT_FTYPE_V4DF:
28332     case INT_FTYPE_V4SF:
28333     case INT_FTYPE_V2DF:
28334     case INT_FTYPE_V32QI:
28335     case V16QI_FTYPE_V16QI:
28336     case V8SI_FTYPE_V8SF:
28337     case V8SI_FTYPE_V4SI:
28338     case V8HI_FTYPE_V8HI:
28339     case V8HI_FTYPE_V16QI:
28340     case V8QI_FTYPE_V8QI:
28341     case V8SF_FTYPE_V8SF:
28342     case V8SF_FTYPE_V8SI:
28343     case V8SF_FTYPE_V4SF:
28344     case V8SF_FTYPE_V8HI:
28345     case V4SI_FTYPE_V4SI:
28346     case V4SI_FTYPE_V16QI:
28347     case V4SI_FTYPE_V4SF:
28348     case V4SI_FTYPE_V8SI:
28349     case V4SI_FTYPE_V8HI:
28350     case V4SI_FTYPE_V4DF:
28351     case V4SI_FTYPE_V2DF:
28352     case V4HI_FTYPE_V4HI:
28353     case V4DF_FTYPE_V4DF:
28354     case V4DF_FTYPE_V4SI:
28355     case V4DF_FTYPE_V4SF:
28356     case V4DF_FTYPE_V2DF:
28357     case V4SF_FTYPE_V4SF:
28358     case V4SF_FTYPE_V4SI:
28359     case V4SF_FTYPE_V8SF:
28360     case V4SF_FTYPE_V4DF:
28361     case V4SF_FTYPE_V8HI:
28362     case V4SF_FTYPE_V2DF:
28363     case V2DI_FTYPE_V2DI:
28364     case V2DI_FTYPE_V16QI:
28365     case V2DI_FTYPE_V8HI:
28366     case V2DI_FTYPE_V4SI:
28367     case V2DF_FTYPE_V2DF:
28368     case V2DF_FTYPE_V4SI:
28369     case V2DF_FTYPE_V4DF:
28370     case V2DF_FTYPE_V4SF:
28371     case V2DF_FTYPE_V2SI:
28372     case V2SI_FTYPE_V2SI:
28373     case V2SI_FTYPE_V4SF:
28374     case V2SI_FTYPE_V2SF:
28375     case V2SI_FTYPE_V2DF:
28376     case V2SF_FTYPE_V2SF:
28377     case V2SF_FTYPE_V2SI:
28378     case V32QI_FTYPE_V32QI:
28379     case V32QI_FTYPE_V16QI:
28380     case V16HI_FTYPE_V16HI:
28381     case V16HI_FTYPE_V8HI:
28382     case V8SI_FTYPE_V8SI:
28383     case V16HI_FTYPE_V16QI:
28384     case V8SI_FTYPE_V16QI:
28385     case V4DI_FTYPE_V16QI:
28386     case V8SI_FTYPE_V8HI:
28387     case V4DI_FTYPE_V8HI:
28388     case V4DI_FTYPE_V4SI:
28389     case V4DI_FTYPE_V2DI:
28390       nargs = 1;
28391       break;
28392     case V4SF_FTYPE_V4SF_VEC_MERGE:
28393     case V2DF_FTYPE_V2DF_VEC_MERGE:
28394       return ix86_expand_unop_vec_merge_builtin (icode, exp, target);
28395     case FLOAT128_FTYPE_FLOAT128_FLOAT128:
28396     case V16QI_FTYPE_V16QI_V16QI:
28397     case V16QI_FTYPE_V8HI_V8HI:
28398     case V8QI_FTYPE_V8QI_V8QI:
28399     case V8QI_FTYPE_V4HI_V4HI:
28400     case V8HI_FTYPE_V8HI_V8HI:
28401     case V8HI_FTYPE_V16QI_V16QI:
28402     case V8HI_FTYPE_V4SI_V4SI:
28403     case V8SF_FTYPE_V8SF_V8SF:
28404     case V8SF_FTYPE_V8SF_V8SI:
28405     case V4SI_FTYPE_V4SI_V4SI:
28406     case V4SI_FTYPE_V8HI_V8HI:
28407     case V4SI_FTYPE_V4SF_V4SF:
28408     case V4SI_FTYPE_V2DF_V2DF:
28409     case V4HI_FTYPE_V4HI_V4HI:
28410     case V4HI_FTYPE_V8QI_V8QI:
28411     case V4HI_FTYPE_V2SI_V2SI:
28412     case V4DF_FTYPE_V4DF_V4DF:
28413     case V4DF_FTYPE_V4DF_V4DI:
28414     case V4SF_FTYPE_V4SF_V4SF:
28415     case V4SF_FTYPE_V4SF_V4SI:
28416     case V4SF_FTYPE_V4SF_V2SI:
28417     case V4SF_FTYPE_V4SF_V2DF:
28418     case V4SF_FTYPE_V4SF_DI:
28419     case V4SF_FTYPE_V4SF_SI:
28420     case V2DI_FTYPE_V2DI_V2DI:
28421     case V2DI_FTYPE_V16QI_V16QI:
28422     case V2DI_FTYPE_V4SI_V4SI:
28423     case V2DI_FTYPE_V2DI_V16QI:
28424     case V2DI_FTYPE_V2DF_V2DF:
28425     case V2SI_FTYPE_V2SI_V2SI:
28426     case V2SI_FTYPE_V4HI_V4HI:
28427     case V2SI_FTYPE_V2SF_V2SF:
28428     case V2DF_FTYPE_V2DF_V2DF:
28429     case V2DF_FTYPE_V2DF_V4SF:
28430     case V2DF_FTYPE_V2DF_V2DI:
28431     case V2DF_FTYPE_V2DF_DI:
28432     case V2DF_FTYPE_V2DF_SI:
28433     case V2SF_FTYPE_V2SF_V2SF:
28434     case V1DI_FTYPE_V1DI_V1DI:
28435     case V1DI_FTYPE_V8QI_V8QI:
28436     case V1DI_FTYPE_V2SI_V2SI:
28437     case V32QI_FTYPE_V16HI_V16HI:
28438     case V16HI_FTYPE_V8SI_V8SI:
28439     case V32QI_FTYPE_V32QI_V32QI:
28440     case V16HI_FTYPE_V32QI_V32QI:
28441     case V16HI_FTYPE_V16HI_V16HI:
28442     case V8SI_FTYPE_V4DF_V4DF:
28443     case V8SI_FTYPE_V8SI_V8SI:
28444     case V8SI_FTYPE_V16HI_V16HI:
28445     case V4DI_FTYPE_V4DI_V4DI:
28446     case V4DI_FTYPE_V8SI_V8SI:
28447       if (comparison == UNKNOWN)
28448         return ix86_expand_binop_builtin (icode, exp, target);
28449       nargs = 2;
28450       break;
28451     case V4SF_FTYPE_V4SF_V4SF_SWAP:
28452     case V2DF_FTYPE_V2DF_V2DF_SWAP:
28453       gcc_assert (comparison != UNKNOWN);
28454       nargs = 2;
28455       swap = true;
28456       break;
28457     case V16HI_FTYPE_V16HI_V8HI_COUNT:
28458     case V16HI_FTYPE_V16HI_SI_COUNT:
28459     case V8SI_FTYPE_V8SI_V4SI_COUNT:
28460     case V8SI_FTYPE_V8SI_SI_COUNT:
28461     case V4DI_FTYPE_V4DI_V2DI_COUNT:
28462     case V4DI_FTYPE_V4DI_INT_COUNT:
28463     case V8HI_FTYPE_V8HI_V8HI_COUNT:
28464     case V8HI_FTYPE_V8HI_SI_COUNT:
28465     case V4SI_FTYPE_V4SI_V4SI_COUNT:
28466     case V4SI_FTYPE_V4SI_SI_COUNT:
28467     case V4HI_FTYPE_V4HI_V4HI_COUNT:
28468     case V4HI_FTYPE_V4HI_SI_COUNT:
28469     case V2DI_FTYPE_V2DI_V2DI_COUNT:
28470     case V2DI_FTYPE_V2DI_SI_COUNT:
28471     case V2SI_FTYPE_V2SI_V2SI_COUNT:
28472     case V2SI_FTYPE_V2SI_SI_COUNT:
28473     case V1DI_FTYPE_V1DI_V1DI_COUNT:
28474     case V1DI_FTYPE_V1DI_SI_COUNT:
28475       nargs = 2;
28476       last_arg_count = true;
28477       break;
28478     case UINT64_FTYPE_UINT64_UINT64:
28479     case UINT_FTYPE_UINT_UINT:
28480     case UINT_FTYPE_UINT_USHORT:
28481     case UINT_FTYPE_UINT_UCHAR:
28482     case UINT16_FTYPE_UINT16_INT:
28483     case UINT8_FTYPE_UINT8_INT:
28484       nargs = 2;
28485       break;
28486     case V2DI_FTYPE_V2DI_INT_CONVERT:
28487       nargs = 2;
28488       rmode = V1TImode;
28489       nargs_constant = 1;
28490       break;
28491     case V4DI_FTYPE_V4DI_INT_CONVERT:
28492       nargs = 2;
28493       rmode = V2TImode;
28494       nargs_constant = 1;
28495       break;
28496     case V8HI_FTYPE_V8HI_INT:
28497     case V8HI_FTYPE_V8SF_INT:
28498     case V8HI_FTYPE_V4SF_INT:
28499     case V8SF_FTYPE_V8SF_INT:
28500     case V4SI_FTYPE_V4SI_INT:
28501     case V4SI_FTYPE_V8SI_INT:
28502     case V4HI_FTYPE_V4HI_INT:
28503     case V4DF_FTYPE_V4DF_INT:
28504     case V4SF_FTYPE_V4SF_INT:
28505     case V4SF_FTYPE_V8SF_INT:
28506     case V2DI_FTYPE_V2DI_INT:
28507     case V2DF_FTYPE_V2DF_INT:
28508     case V2DF_FTYPE_V4DF_INT:
28509     case V16HI_FTYPE_V16HI_INT:
28510     case V8SI_FTYPE_V8SI_INT:
28511     case V4DI_FTYPE_V4DI_INT:
28512     case V2DI_FTYPE_V4DI_INT:
28513       nargs = 2;
28514       nargs_constant = 1;
28515       break;
28516     case V16QI_FTYPE_V16QI_V16QI_V16QI:
28517     case V8SF_FTYPE_V8SF_V8SF_V8SF:
28518     case V4DF_FTYPE_V4DF_V4DF_V4DF:
28519     case V4SF_FTYPE_V4SF_V4SF_V4SF:
28520     case V2DF_FTYPE_V2DF_V2DF_V2DF:
28521     case V32QI_FTYPE_V32QI_V32QI_V32QI:
28522       nargs = 3;
28523       break;
28524     case V32QI_FTYPE_V32QI_V32QI_INT:
28525     case V16HI_FTYPE_V16HI_V16HI_INT:
28526     case V16QI_FTYPE_V16QI_V16QI_INT:
28527     case V4DI_FTYPE_V4DI_V4DI_INT:
28528     case V8HI_FTYPE_V8HI_V8HI_INT:
28529     case V8SI_FTYPE_V8SI_V8SI_INT:
28530     case V8SI_FTYPE_V8SI_V4SI_INT:
28531     case V8SF_FTYPE_V8SF_V8SF_INT:
28532     case V8SF_FTYPE_V8SF_V4SF_INT:
28533     case V4SI_FTYPE_V4SI_V4SI_INT:
28534     case V4DF_FTYPE_V4DF_V4DF_INT:
28535     case V4DF_FTYPE_V4DF_V2DF_INT:
28536     case V4SF_FTYPE_V4SF_V4SF_INT:
28537     case V2DI_FTYPE_V2DI_V2DI_INT:
28538     case V4DI_FTYPE_V4DI_V2DI_INT:
28539     case V2DF_FTYPE_V2DF_V2DF_INT:
28540       nargs = 3;
28541       nargs_constant = 1;
28542       break;
28543     case V4DI_FTYPE_V4DI_V4DI_INT_CONVERT:
28544       nargs = 3;
28545       rmode = V4DImode;
28546       nargs_constant = 1;
28547       break;
28548     case V2DI_FTYPE_V2DI_V2DI_INT_CONVERT:
28549       nargs = 3;
28550       rmode = V2DImode;
28551       nargs_constant = 1;
28552       break;
28553     case V1DI_FTYPE_V1DI_V1DI_INT_CONVERT:
28554       nargs = 3;
28555       rmode = DImode;
28556       nargs_constant = 1;
28557       break;
28558     case V2DI_FTYPE_V2DI_UINT_UINT:
28559       nargs = 3;
28560       nargs_constant = 2;
28561       break;
28562     case V2DF_FTYPE_V2DF_V2DF_V2DI_INT:
28563     case V4DF_FTYPE_V4DF_V4DF_V4DI_INT:
28564     case V4SF_FTYPE_V4SF_V4SF_V4SI_INT:
28565     case V8SF_FTYPE_V8SF_V8SF_V8SI_INT:
28566       nargs = 4;
28567       nargs_constant = 1;
28568       break;
28569     case V2DI_FTYPE_V2DI_V2DI_UINT_UINT:
28570       nargs = 4;
28571       nargs_constant = 2;
28572       break;
28573     default:
28574       gcc_unreachable ();
28575     }
28576
28577   gcc_assert (nargs <= ARRAY_SIZE (args));
28578
28579   if (comparison != UNKNOWN)
28580     {
28581       gcc_assert (nargs == 2);
28582       return ix86_expand_sse_compare (d, exp, target, swap);
28583     }
28584
28585   if (rmode == VOIDmode || rmode == tmode)
28586     {
28587       if (optimize
28588           || target == 0
28589           || GET_MODE (target) != tmode
28590           || !insn_p->operand[0].predicate (target, tmode))
28591         target = gen_reg_rtx (tmode);
28592       real_target = target;
28593     }
28594   else
28595     {
28596       target = gen_reg_rtx (rmode);
28597       real_target = simplify_gen_subreg (tmode, target, rmode, 0);
28598     }
28599
28600   for (i = 0; i < nargs; i++)
28601     {
28602       tree arg = CALL_EXPR_ARG (exp, i);
28603       rtx op = expand_normal (arg);
28604       enum machine_mode mode = insn_p->operand[i + 1].mode;
28605       bool match = insn_p->operand[i + 1].predicate (op, mode);
28606
28607       if (last_arg_count && (i + 1) == nargs)
28608         {
28609           /* SIMD shift insns take either an 8-bit immediate or
28610              register as count.  But builtin functions take int as
28611              count.  If count doesn't match, we put it in register.  */
28612           if (!match)
28613             {
28614               op = simplify_gen_subreg (SImode, op, GET_MODE (op), 0);
28615               if (!insn_p->operand[i + 1].predicate (op, mode))
28616                 op = copy_to_reg (op);
28617             }
28618         }
28619       else if ((nargs - i) <= nargs_constant)
28620         {
28621           if (!match)
28622             switch (icode)
28623               {
28624               case CODE_FOR_avx2_inserti128:
28625               case CODE_FOR_avx2_extracti128:
28626                 error ("the last argument must be an 1-bit immediate");
28627                 return const0_rtx;
28628
28629               case CODE_FOR_sse4_1_roundsd:
28630               case CODE_FOR_sse4_1_roundss:
28631
28632               case CODE_FOR_sse4_1_roundpd:
28633               case CODE_FOR_sse4_1_roundps:
28634               case CODE_FOR_avx_roundpd256:
28635               case CODE_FOR_avx_roundps256:
28636
28637               case CODE_FOR_sse4_1_roundpd_vec_pack_sfix:
28638               case CODE_FOR_sse4_1_roundps_sfix:
28639               case CODE_FOR_avx_roundpd_vec_pack_sfix256:
28640               case CODE_FOR_avx_roundps_sfix256:
28641
28642               case CODE_FOR_sse4_1_blendps:
28643               case CODE_FOR_avx_blendpd256:
28644               case CODE_FOR_avx_vpermilv4df:
28645                 error ("the last argument must be a 4-bit immediate");
28646                 return const0_rtx;
28647
28648               case CODE_FOR_sse4_1_blendpd:
28649               case CODE_FOR_avx_vpermilv2df:
28650               case CODE_FOR_xop_vpermil2v2df3:
28651               case CODE_FOR_xop_vpermil2v4sf3:
28652               case CODE_FOR_xop_vpermil2v4df3:
28653               case CODE_FOR_xop_vpermil2v8sf3:
28654                 error ("the last argument must be a 2-bit immediate");
28655                 return const0_rtx;
28656
28657               case CODE_FOR_avx_vextractf128v4df:
28658               case CODE_FOR_avx_vextractf128v8sf:
28659               case CODE_FOR_avx_vextractf128v8si:
28660               case CODE_FOR_avx_vinsertf128v4df:
28661               case CODE_FOR_avx_vinsertf128v8sf:
28662               case CODE_FOR_avx_vinsertf128v8si:
28663                 error ("the last argument must be a 1-bit immediate");
28664                 return const0_rtx;
28665
28666               case CODE_FOR_avx_vmcmpv2df3:
28667               case CODE_FOR_avx_vmcmpv4sf3:
28668               case CODE_FOR_avx_cmpv2df3:
28669               case CODE_FOR_avx_cmpv4sf3:
28670               case CODE_FOR_avx_cmpv4df3:
28671               case CODE_FOR_avx_cmpv8sf3:
28672                 error ("the last argument must be a 5-bit immediate");
28673                 return const0_rtx;
28674
28675              default:
28676                 switch (nargs_constant)
28677                   {
28678                   case 2:
28679                     if ((nargs - i) == nargs_constant)
28680                       {
28681                         error ("the next to last argument must be an 8-bit immediate");
28682                         break;
28683                       }
28684                   case 1:
28685                     error ("the last argument must be an 8-bit immediate");
28686                     break;
28687                   default:
28688                     gcc_unreachable ();
28689                   }
28690                 return const0_rtx;
28691               }
28692         }
28693       else
28694         {
28695           if (VECTOR_MODE_P (mode))
28696             op = safe_vector_operand (op, mode);
28697
28698           /* If we aren't optimizing, only allow one memory operand to
28699              be generated.  */
28700           if (memory_operand (op, mode))
28701             num_memory++;
28702
28703           if (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
28704             {
28705               if (optimize || !match || num_memory > 1)
28706                 op = copy_to_mode_reg (mode, op);
28707             }
28708           else
28709             {
28710               op = copy_to_reg (op);
28711               op = simplify_gen_subreg (mode, op, GET_MODE (op), 0);
28712             }
28713         }
28714
28715       args[i].op = op;
28716       args[i].mode = mode;
28717     }
28718
28719   switch (nargs)
28720     {
28721     case 1:
28722       pat = GEN_FCN (icode) (real_target, args[0].op);
28723       break;
28724     case 2:
28725       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op);
28726       break;
28727     case 3:
28728       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
28729                              args[2].op);
28730       break;
28731     case 4:
28732       pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
28733                              args[2].op, args[3].op);
28734       break;
28735     default:
28736       gcc_unreachable ();
28737     }
28738
28739   if (! pat)
28740     return 0;
28741
28742   emit_insn (pat);
28743   return target;
28744 }
28745
28746 /* Subroutine of ix86_expand_builtin to take care of special insns
28747    with variable number of operands.  */
28748
28749 static rtx
28750 ix86_expand_special_args_builtin (const struct builtin_description *d,
28751                                     tree exp, rtx target)
28752 {
28753   tree arg;
28754   rtx pat, op;
28755   unsigned int i, nargs, arg_adjust, memory;
28756   struct
28757     {
28758       rtx op;
28759       enum machine_mode mode;
28760     } args[3];
28761   enum insn_code icode = d->icode;
28762   bool last_arg_constant = false;
28763   const struct insn_data_d *insn_p = &insn_data[icode];
28764   enum machine_mode tmode = insn_p->operand[0].mode;
28765   enum { load, store } klass;
28766
28767   switch ((enum ix86_builtin_func_type) d->flag)
28768     {
28769     case VOID_FTYPE_VOID:
28770       if (icode == CODE_FOR_avx_vzeroupper)
28771         target = GEN_INT (vzeroupper_intrinsic);
28772       emit_insn (GEN_FCN (icode) (target));
28773       return 0;
28774     case VOID_FTYPE_UINT64:
28775     case VOID_FTYPE_UNSIGNED:
28776       nargs = 0;
28777       klass = store;
28778       memory = 0;
28779       break;
28780     case UINT64_FTYPE_VOID:
28781     case UNSIGNED_FTYPE_VOID:
28782       nargs = 0;
28783       klass = load;
28784       memory = 0;
28785       break;
28786     case UINT64_FTYPE_PUNSIGNED:
28787     case V2DI_FTYPE_PV2DI:
28788     case V4DI_FTYPE_PV4DI:
28789     case V32QI_FTYPE_PCCHAR:
28790     case V16QI_FTYPE_PCCHAR:
28791     case V8SF_FTYPE_PCV4SF:
28792     case V8SF_FTYPE_PCFLOAT:
28793     case V4SF_FTYPE_PCFLOAT:
28794     case V4DF_FTYPE_PCV2DF:
28795     case V4DF_FTYPE_PCDOUBLE:
28796     case V2DF_FTYPE_PCDOUBLE:
28797     case VOID_FTYPE_PVOID:
28798       nargs = 1;
28799       klass = load;
28800       memory = 0;
28801       break;
28802     case VOID_FTYPE_PV2SF_V4SF:
28803     case VOID_FTYPE_PV4DI_V4DI:
28804     case VOID_FTYPE_PV2DI_V2DI:
28805     case VOID_FTYPE_PCHAR_V32QI:
28806     case VOID_FTYPE_PCHAR_V16QI:
28807     case VOID_FTYPE_PFLOAT_V8SF:
28808     case VOID_FTYPE_PFLOAT_V4SF:
28809     case VOID_FTYPE_PDOUBLE_V4DF:
28810     case VOID_FTYPE_PDOUBLE_V2DF:
28811     case VOID_FTYPE_PLONGLONG_LONGLONG:
28812     case VOID_FTYPE_PULONGLONG_ULONGLONG:
28813     case VOID_FTYPE_PINT_INT:
28814       nargs = 1;
28815       klass = store;
28816       /* Reserve memory operand for target.  */
28817       memory = ARRAY_SIZE (args);
28818       break;
28819     case V4SF_FTYPE_V4SF_PCV2SF:
28820     case V2DF_FTYPE_V2DF_PCDOUBLE:
28821       nargs = 2;
28822       klass = load;
28823       memory = 1;
28824       break;
28825     case V8SF_FTYPE_PCV8SF_V8SI:
28826     case V4DF_FTYPE_PCV4DF_V4DI:
28827     case V4SF_FTYPE_PCV4SF_V4SI:
28828     case V2DF_FTYPE_PCV2DF_V2DI:
28829     case V8SI_FTYPE_PCV8SI_V8SI:
28830     case V4DI_FTYPE_PCV4DI_V4DI:
28831     case V4SI_FTYPE_PCV4SI_V4SI:
28832     case V2DI_FTYPE_PCV2DI_V2DI:
28833       nargs = 2;
28834       klass = load;
28835       memory = 0;
28836       break;
28837     case VOID_FTYPE_PV8SF_V8SI_V8SF:
28838     case VOID_FTYPE_PV4DF_V4DI_V4DF:
28839     case VOID_FTYPE_PV4SF_V4SI_V4SF:
28840     case VOID_FTYPE_PV2DF_V2DI_V2DF:
28841     case VOID_FTYPE_PV8SI_V8SI_V8SI:
28842     case VOID_FTYPE_PV4DI_V4DI_V4DI:
28843     case VOID_FTYPE_PV4SI_V4SI_V4SI:
28844     case VOID_FTYPE_PV2DI_V2DI_V2DI:
28845       nargs = 2;
28846       klass = store;
28847       /* Reserve memory operand for target.  */
28848       memory = ARRAY_SIZE (args);
28849       break;
28850     case VOID_FTYPE_UINT_UINT_UINT:
28851     case VOID_FTYPE_UINT64_UINT_UINT:
28852     case UCHAR_FTYPE_UINT_UINT_UINT:
28853     case UCHAR_FTYPE_UINT64_UINT_UINT:
28854       nargs = 3;
28855       klass = load;
28856       memory = ARRAY_SIZE (args);
28857       last_arg_constant = true;
28858       break;
28859     default:
28860       gcc_unreachable ();
28861     }
28862
28863   gcc_assert (nargs <= ARRAY_SIZE (args));
28864
28865   if (klass == store)
28866     {
28867       arg = CALL_EXPR_ARG (exp, 0);
28868       op = expand_normal (arg);
28869       gcc_assert (target == 0);
28870       if (memory)
28871         {
28872           if (GET_MODE (op) != Pmode)
28873             op = convert_to_mode (Pmode, op, 1);
28874           target = gen_rtx_MEM (tmode, force_reg (Pmode, op));
28875         }
28876       else
28877         target = force_reg (tmode, op);
28878       arg_adjust = 1;
28879     }
28880   else
28881     {
28882       arg_adjust = 0;
28883       if (optimize
28884           || target == 0
28885           || GET_MODE (target) != tmode
28886           || !insn_p->operand[0].predicate (target, tmode))
28887         target = gen_reg_rtx (tmode);
28888     }
28889
28890   for (i = 0; i < nargs; i++)
28891     {
28892       enum machine_mode mode = insn_p->operand[i + 1].mode;
28893       bool match;
28894
28895       arg = CALL_EXPR_ARG (exp, i + arg_adjust);
28896       op = expand_normal (arg);
28897       match = insn_p->operand[i + 1].predicate (op, mode);
28898
28899       if (last_arg_constant && (i + 1) == nargs)
28900         {
28901           if (!match)
28902             {
28903               if (icode == CODE_FOR_lwp_lwpvalsi3
28904                   || icode == CODE_FOR_lwp_lwpinssi3
28905                   || icode == CODE_FOR_lwp_lwpvaldi3
28906                   || icode == CODE_FOR_lwp_lwpinsdi3)
28907                 error ("the last argument must be a 32-bit immediate");
28908               else
28909                 error ("the last argument must be an 8-bit immediate");
28910               return const0_rtx;
28911             }
28912         }
28913       else
28914         {
28915           if (i == memory)
28916             {
28917               /* This must be the memory operand.  */
28918               if (GET_MODE (op) != Pmode)
28919                 op = convert_to_mode (Pmode, op, 1);
28920               op = gen_rtx_MEM (mode, force_reg (Pmode, op));
28921               gcc_assert (GET_MODE (op) == mode
28922                           || GET_MODE (op) == VOIDmode);
28923             }
28924           else
28925             {
28926               /* This must be register.  */
28927               if (VECTOR_MODE_P (mode))
28928                 op = safe_vector_operand (op, mode);
28929
28930               gcc_assert (GET_MODE (op) == mode
28931                           || GET_MODE (op) == VOIDmode);
28932               op = copy_to_mode_reg (mode, op);
28933             }
28934         }
28935
28936       args[i].op = op;
28937       args[i].mode = mode;
28938     }
28939
28940   switch (nargs)
28941     {
28942     case 0:
28943       pat = GEN_FCN (icode) (target);
28944       break;
28945     case 1:
28946       pat = GEN_FCN (icode) (target, args[0].op);
28947       break;
28948     case 2:
28949       pat = GEN_FCN (icode) (target, args[0].op, args[1].op);
28950       break;
28951     case 3:
28952       pat = GEN_FCN (icode) (target, args[0].op, args[1].op, args[2].op);
28953       break;
28954     default:
28955       gcc_unreachable ();
28956     }
28957
28958   if (! pat)
28959     return 0;
28960   emit_insn (pat);
28961   return klass == store ? 0 : target;
28962 }
28963
28964 /* Return the integer constant in ARG.  Constrain it to be in the range
28965    of the subparts of VEC_TYPE; issue an error if not.  */
28966
28967 static int
28968 get_element_number (tree vec_type, tree arg)
28969 {
28970   unsigned HOST_WIDE_INT elt, max = TYPE_VECTOR_SUBPARTS (vec_type) - 1;
28971
28972   if (!host_integerp (arg, 1)
28973       || (elt = tree_low_cst (arg, 1), elt > max))
28974     {
28975       error ("selector must be an integer constant in the range 0..%wi", max);
28976       return 0;
28977     }
28978
28979   return elt;
28980 }
28981
28982 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
28983    ix86_expand_vector_init.  We DO have language-level syntax for this, in
28984    the form of  (type){ init-list }.  Except that since we can't place emms
28985    instructions from inside the compiler, we can't allow the use of MMX
28986    registers unless the user explicitly asks for it.  So we do *not* define
28987    vec_set/vec_extract/vec_init patterns for MMX modes in mmx.md.  Instead
28988    we have builtins invoked by mmintrin.h that gives us license to emit
28989    these sorts of instructions.  */
28990
28991 static rtx
28992 ix86_expand_vec_init_builtin (tree type, tree exp, rtx target)
28993 {
28994   enum machine_mode tmode = TYPE_MODE (type);
28995   enum machine_mode inner_mode = GET_MODE_INNER (tmode);
28996   int i, n_elt = GET_MODE_NUNITS (tmode);
28997   rtvec v = rtvec_alloc (n_elt);
28998
28999   gcc_assert (VECTOR_MODE_P (tmode));
29000   gcc_assert (call_expr_nargs (exp) == n_elt);
29001
29002   for (i = 0; i < n_elt; ++i)
29003     {
29004       rtx x = expand_normal (CALL_EXPR_ARG (exp, i));
29005       RTVEC_ELT (v, i) = gen_lowpart (inner_mode, x);
29006     }
29007
29008   if (!target || !register_operand (target, tmode))
29009     target = gen_reg_rtx (tmode);
29010
29011   ix86_expand_vector_init (true, target, gen_rtx_PARALLEL (tmode, v));
29012   return target;
29013 }
29014
29015 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
29016    ix86_expand_vector_extract.  They would be redundant (for non-MMX) if we
29017    had a language-level syntax for referencing vector elements.  */
29018
29019 static rtx
29020 ix86_expand_vec_ext_builtin (tree exp, rtx target)
29021 {
29022   enum machine_mode tmode, mode0;
29023   tree arg0, arg1;
29024   int elt;
29025   rtx op0;
29026
29027   arg0 = CALL_EXPR_ARG (exp, 0);
29028   arg1 = CALL_EXPR_ARG (exp, 1);
29029
29030   op0 = expand_normal (arg0);
29031   elt = get_element_number (TREE_TYPE (arg0), arg1);
29032
29033   tmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
29034   mode0 = TYPE_MODE (TREE_TYPE (arg0));
29035   gcc_assert (VECTOR_MODE_P (mode0));
29036
29037   op0 = force_reg (mode0, op0);
29038
29039   if (optimize || !target || !register_operand (target, tmode))
29040     target = gen_reg_rtx (tmode);
29041
29042   ix86_expand_vector_extract (true, target, op0, elt);
29043
29044   return target;
29045 }
29046
29047 /* A subroutine of ix86_expand_builtin.  These builtins are a wrapper around
29048    ix86_expand_vector_set.  They would be redundant (for non-MMX) if we had
29049    a language-level syntax for referencing vector elements.  */
29050
29051 static rtx
29052 ix86_expand_vec_set_builtin (tree exp)
29053 {
29054   enum machine_mode tmode, mode1;
29055   tree arg0, arg1, arg2;
29056   int elt;
29057   rtx op0, op1, target;
29058
29059   arg0 = CALL_EXPR_ARG (exp, 0);
29060   arg1 = CALL_EXPR_ARG (exp, 1);
29061   arg2 = CALL_EXPR_ARG (exp, 2);
29062
29063   tmode = TYPE_MODE (TREE_TYPE (arg0));
29064   mode1 = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
29065   gcc_assert (VECTOR_MODE_P (tmode));
29066
29067   op0 = expand_expr (arg0, NULL_RTX, tmode, EXPAND_NORMAL);
29068   op1 = expand_expr (arg1, NULL_RTX, mode1, EXPAND_NORMAL);
29069   elt = get_element_number (TREE_TYPE (arg0), arg2);
29070
29071   if (GET_MODE (op1) != mode1 && GET_MODE (op1) != VOIDmode)
29072     op1 = convert_modes (mode1, GET_MODE (op1), op1, true);
29073
29074   op0 = force_reg (tmode, op0);
29075   op1 = force_reg (mode1, op1);
29076
29077   /* OP0 is the source of these builtin functions and shouldn't be
29078      modified.  Create a copy, use it and return it as target.  */
29079   target = gen_reg_rtx (tmode);
29080   emit_move_insn (target, op0);
29081   ix86_expand_vector_set (true, target, op1, elt);
29082
29083   return target;
29084 }
29085
29086 /* Expand an expression EXP that calls a built-in function,
29087    with result going to TARGET if that's convenient
29088    (and in mode MODE if that's convenient).
29089    SUBTARGET may be used as the target for computing one of EXP's operands.
29090    IGNORE is nonzero if the value is to be ignored.  */
29091
29092 static rtx
29093 ix86_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
29094                      enum machine_mode mode ATTRIBUTE_UNUSED,
29095                      int ignore ATTRIBUTE_UNUSED)
29096 {
29097   const struct builtin_description *d;
29098   size_t i;
29099   enum insn_code icode;
29100   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
29101   tree arg0, arg1, arg2, arg3, arg4;
29102   rtx op0, op1, op2, op3, op4, pat;
29103   enum machine_mode mode0, mode1, mode2, mode3, mode4;
29104   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
29105
29106   /* Determine whether the builtin function is available under the current ISA.
29107      Originally the builtin was not created if it wasn't applicable to the
29108      current ISA based on the command line switches.  With function specific
29109      options, we need to check in the context of the function making the call
29110      whether it is supported.  */
29111   if (ix86_builtins_isa[fcode].isa
29112       && !(ix86_builtins_isa[fcode].isa & ix86_isa_flags))
29113     {
29114       char *opts = ix86_target_string (ix86_builtins_isa[fcode].isa, 0, NULL,
29115                                        NULL, (enum fpmath_unit) 0, false);
29116
29117       if (!opts)
29118         error ("%qE needs unknown isa option", fndecl);
29119       else
29120         {
29121           gcc_assert (opts != NULL);
29122           error ("%qE needs isa option %s", fndecl, opts);
29123           free (opts);
29124         }
29125       return const0_rtx;
29126     }
29127
29128   switch (fcode)
29129     {
29130     case IX86_BUILTIN_MASKMOVQ:
29131     case IX86_BUILTIN_MASKMOVDQU:
29132       icode = (fcode == IX86_BUILTIN_MASKMOVQ
29133                ? CODE_FOR_mmx_maskmovq
29134                : CODE_FOR_sse2_maskmovdqu);
29135       /* Note the arg order is different from the operand order.  */
29136       arg1 = CALL_EXPR_ARG (exp, 0);
29137       arg2 = CALL_EXPR_ARG (exp, 1);
29138       arg0 = CALL_EXPR_ARG (exp, 2);
29139       op0 = expand_normal (arg0);
29140       op1 = expand_normal (arg1);
29141       op2 = expand_normal (arg2);
29142       mode0 = insn_data[icode].operand[0].mode;
29143       mode1 = insn_data[icode].operand[1].mode;
29144       mode2 = insn_data[icode].operand[2].mode;
29145
29146       if (GET_MODE (op0) != Pmode)
29147         op0 = convert_to_mode (Pmode, op0, 1);
29148       op0 = gen_rtx_MEM (mode1, force_reg (Pmode, op0));
29149
29150       if (!insn_data[icode].operand[0].predicate (op0, mode0))
29151         op0 = copy_to_mode_reg (mode0, op0);
29152       if (!insn_data[icode].operand[1].predicate (op1, mode1))
29153         op1 = copy_to_mode_reg (mode1, op1);
29154       if (!insn_data[icode].operand[2].predicate (op2, mode2))
29155         op2 = copy_to_mode_reg (mode2, op2);
29156       pat = GEN_FCN (icode) (op0, op1, op2);
29157       if (! pat)
29158         return 0;
29159       emit_insn (pat);
29160       return 0;
29161
29162     case IX86_BUILTIN_LDMXCSR:
29163       op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
29164       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
29165       emit_move_insn (target, op0);
29166       emit_insn (gen_sse_ldmxcsr (target));
29167       return 0;
29168
29169     case IX86_BUILTIN_STMXCSR:
29170       target = assign_386_stack_local (SImode, SLOT_VIRTUAL);
29171       emit_insn (gen_sse_stmxcsr (target));
29172       return copy_to_mode_reg (SImode, target);
29173
29174     case IX86_BUILTIN_CLFLUSH:
29175         arg0 = CALL_EXPR_ARG (exp, 0);
29176         op0 = expand_normal (arg0);
29177         icode = CODE_FOR_sse2_clflush;
29178         if (!insn_data[icode].operand[0].predicate (op0, Pmode))
29179           {
29180             if (GET_MODE (op0) != Pmode)
29181               op0 = convert_to_mode (Pmode, op0, 1);
29182             op0 = force_reg (Pmode, op0);
29183           }
29184
29185         emit_insn (gen_sse2_clflush (op0));
29186         return 0;
29187
29188     case IX86_BUILTIN_MONITOR:
29189       arg0 = CALL_EXPR_ARG (exp, 0);
29190       arg1 = CALL_EXPR_ARG (exp, 1);
29191       arg2 = CALL_EXPR_ARG (exp, 2);
29192       op0 = expand_normal (arg0);
29193       op1 = expand_normal (arg1);
29194       op2 = expand_normal (arg2);
29195       if (!REG_P (op0))
29196         {
29197           if (GET_MODE (op0) != Pmode)
29198             op0 = convert_to_mode (Pmode, op0, 1);
29199           op0 = force_reg (Pmode, op0);
29200         }
29201       if (!REG_P (op1))
29202         op1 = copy_to_mode_reg (SImode, op1);
29203       if (!REG_P (op2))
29204         op2 = copy_to_mode_reg (SImode, op2);
29205       emit_insn (ix86_gen_monitor (op0, op1, op2));
29206       return 0;
29207
29208     case IX86_BUILTIN_MWAIT:
29209       arg0 = CALL_EXPR_ARG (exp, 0);
29210       arg1 = CALL_EXPR_ARG (exp, 1);
29211       op0 = expand_normal (arg0);
29212       op1 = expand_normal (arg1);
29213       if (!REG_P (op0))
29214         op0 = copy_to_mode_reg (SImode, op0);
29215       if (!REG_P (op1))
29216         op1 = copy_to_mode_reg (SImode, op1);
29217       emit_insn (gen_sse3_mwait (op0, op1));
29218       return 0;
29219
29220     case IX86_BUILTIN_VEC_INIT_V2SI:
29221     case IX86_BUILTIN_VEC_INIT_V4HI:
29222     case IX86_BUILTIN_VEC_INIT_V8QI:
29223       return ix86_expand_vec_init_builtin (TREE_TYPE (exp), exp, target);
29224
29225     case IX86_BUILTIN_VEC_EXT_V2DF:
29226     case IX86_BUILTIN_VEC_EXT_V2DI:
29227     case IX86_BUILTIN_VEC_EXT_V4SF:
29228     case IX86_BUILTIN_VEC_EXT_V4SI:
29229     case IX86_BUILTIN_VEC_EXT_V8HI:
29230     case IX86_BUILTIN_VEC_EXT_V2SI:
29231     case IX86_BUILTIN_VEC_EXT_V4HI:
29232     case IX86_BUILTIN_VEC_EXT_V16QI:
29233       return ix86_expand_vec_ext_builtin (exp, target);
29234
29235     case IX86_BUILTIN_VEC_SET_V2DI:
29236     case IX86_BUILTIN_VEC_SET_V4SF:
29237     case IX86_BUILTIN_VEC_SET_V4SI:
29238     case IX86_BUILTIN_VEC_SET_V8HI:
29239     case IX86_BUILTIN_VEC_SET_V4HI:
29240     case IX86_BUILTIN_VEC_SET_V16QI:
29241       return ix86_expand_vec_set_builtin (exp);
29242
29243     case IX86_BUILTIN_INFQ:
29244     case IX86_BUILTIN_HUGE_VALQ:
29245       {
29246         REAL_VALUE_TYPE inf;
29247         rtx tmp;
29248
29249         real_inf (&inf);
29250         tmp = CONST_DOUBLE_FROM_REAL_VALUE (inf, mode);
29251
29252         tmp = validize_mem (force_const_mem (mode, tmp));
29253
29254         if (target == 0)
29255           target = gen_reg_rtx (mode);
29256
29257         emit_move_insn (target, tmp);
29258         return target;
29259       }
29260
29261     case IX86_BUILTIN_LLWPCB:
29262       arg0 = CALL_EXPR_ARG (exp, 0);
29263       op0 = expand_normal (arg0);
29264       icode = CODE_FOR_lwp_llwpcb;
29265       if (!insn_data[icode].operand[0].predicate (op0, Pmode))
29266         {
29267           if (GET_MODE (op0) != Pmode)
29268             op0 = convert_to_mode (Pmode, op0, 1);
29269           op0 = force_reg (Pmode, op0);
29270         }
29271       emit_insn (gen_lwp_llwpcb (op0));
29272       return 0;
29273
29274     case IX86_BUILTIN_SLWPCB:
29275       icode = CODE_FOR_lwp_slwpcb;
29276       if (!target
29277           || !insn_data[icode].operand[0].predicate (target, Pmode))
29278         target = gen_reg_rtx (Pmode);
29279       emit_insn (gen_lwp_slwpcb (target));
29280       return target;
29281
29282     case IX86_BUILTIN_BEXTRI32:
29283     case IX86_BUILTIN_BEXTRI64:
29284       arg0 = CALL_EXPR_ARG (exp, 0);
29285       arg1 = CALL_EXPR_ARG (exp, 1);
29286       op0 = expand_normal (arg0);
29287       op1 = expand_normal (arg1);
29288       icode = (fcode == IX86_BUILTIN_BEXTRI32
29289           ? CODE_FOR_tbm_bextri_si
29290           : CODE_FOR_tbm_bextri_di);
29291       if (!CONST_INT_P (op1))
29292         {
29293           error ("last argument must be an immediate");
29294           return const0_rtx;
29295         }
29296       else
29297         {
29298           unsigned char length = (INTVAL (op1) >> 8) & 0xFF;
29299           unsigned char lsb_index = INTVAL (op1) & 0xFF;
29300           op1 = GEN_INT (length);
29301           op2 = GEN_INT (lsb_index);
29302           pat = GEN_FCN (icode) (target, op0, op1, op2);
29303           if (pat)
29304             emit_insn (pat);
29305           return target;
29306         }
29307
29308     case IX86_BUILTIN_RDRAND16_STEP:
29309       icode = CODE_FOR_rdrandhi_1;
29310       mode0 = HImode;
29311       goto rdrand_step;
29312
29313     case IX86_BUILTIN_RDRAND32_STEP:
29314       icode = CODE_FOR_rdrandsi_1;
29315       mode0 = SImode;
29316       goto rdrand_step;
29317
29318     case IX86_BUILTIN_RDRAND64_STEP:
29319       icode = CODE_FOR_rdranddi_1;
29320       mode0 = DImode;
29321
29322 rdrand_step:
29323       op0 = gen_reg_rtx (mode0);
29324       emit_insn (GEN_FCN (icode) (op0));
29325
29326       arg0 = CALL_EXPR_ARG (exp, 0);
29327       op1 = expand_normal (arg0);
29328       if (!address_operand (op1, VOIDmode))
29329         {
29330           op1 = convert_memory_address (Pmode, op1);
29331           op1 = copy_addr_to_reg (op1);
29332         }
29333       emit_move_insn (gen_rtx_MEM (mode0, op1), op0);
29334
29335       op1 = gen_reg_rtx (SImode);
29336       emit_move_insn (op1, CONST1_RTX (SImode));
29337
29338       /* Emit SImode conditional move.  */
29339       if (mode0 == HImode)
29340         {
29341           op2 = gen_reg_rtx (SImode);
29342           emit_insn (gen_zero_extendhisi2 (op2, op0));
29343         }
29344       else if (mode0 == SImode)
29345         op2 = op0;
29346       else
29347         op2 = gen_rtx_SUBREG (SImode, op0, 0);
29348
29349       if (target == 0)
29350         target = gen_reg_rtx (SImode);
29351
29352       pat = gen_rtx_GEU (VOIDmode, gen_rtx_REG (CCCmode, FLAGS_REG),
29353                          const0_rtx);
29354       emit_insn (gen_rtx_SET (VOIDmode, target,
29355                               gen_rtx_IF_THEN_ELSE (SImode, pat, op2, op1)));
29356       return target;
29357
29358     case IX86_BUILTIN_GATHERSIV2DF:
29359       icode = CODE_FOR_avx2_gathersiv2df;
29360       goto gather_gen;
29361     case IX86_BUILTIN_GATHERSIV4DF:
29362       icode = CODE_FOR_avx2_gathersiv4df;
29363       goto gather_gen;
29364     case IX86_BUILTIN_GATHERDIV2DF:
29365       icode = CODE_FOR_avx2_gatherdiv2df;
29366       goto gather_gen;
29367     case IX86_BUILTIN_GATHERDIV4DF:
29368       icode = CODE_FOR_avx2_gatherdiv4df;
29369       goto gather_gen;
29370     case IX86_BUILTIN_GATHERSIV4SF:
29371       icode = CODE_FOR_avx2_gathersiv4sf;
29372       goto gather_gen;
29373     case IX86_BUILTIN_GATHERSIV8SF:
29374       icode = CODE_FOR_avx2_gathersiv8sf;
29375       goto gather_gen;
29376     case IX86_BUILTIN_GATHERDIV4SF:
29377       icode = CODE_FOR_avx2_gatherdiv4sf;
29378       goto gather_gen;
29379     case IX86_BUILTIN_GATHERDIV8SF:
29380       icode = CODE_FOR_avx2_gatherdiv8sf;
29381       goto gather_gen;
29382     case IX86_BUILTIN_GATHERSIV2DI:
29383       icode = CODE_FOR_avx2_gathersiv2di;
29384       goto gather_gen;
29385     case IX86_BUILTIN_GATHERSIV4DI:
29386       icode = CODE_FOR_avx2_gathersiv4di;
29387       goto gather_gen;
29388     case IX86_BUILTIN_GATHERDIV2DI:
29389       icode = CODE_FOR_avx2_gatherdiv2di;
29390       goto gather_gen;
29391     case IX86_BUILTIN_GATHERDIV4DI:
29392       icode = CODE_FOR_avx2_gatherdiv4di;
29393       goto gather_gen;
29394     case IX86_BUILTIN_GATHERSIV4SI:
29395       icode = CODE_FOR_avx2_gathersiv4si;
29396       goto gather_gen;
29397     case IX86_BUILTIN_GATHERSIV8SI:
29398       icode = CODE_FOR_avx2_gathersiv8si;
29399       goto gather_gen;
29400     case IX86_BUILTIN_GATHERDIV4SI:
29401       icode = CODE_FOR_avx2_gatherdiv4si;
29402       goto gather_gen;
29403     case IX86_BUILTIN_GATHERDIV8SI:
29404       icode = CODE_FOR_avx2_gatherdiv8si;
29405       goto gather_gen;
29406     case IX86_BUILTIN_GATHERALTSIV4DF:
29407       icode = CODE_FOR_avx2_gathersiv4df;
29408       goto gather_gen;
29409     case IX86_BUILTIN_GATHERALTDIV8SF:
29410       icode = CODE_FOR_avx2_gatherdiv8sf;
29411       goto gather_gen;
29412     case IX86_BUILTIN_GATHERALTSIV4DI:
29413       icode = CODE_FOR_avx2_gathersiv4di;
29414       goto gather_gen;
29415     case IX86_BUILTIN_GATHERALTDIV8SI:
29416       icode = CODE_FOR_avx2_gatherdiv8si;
29417       goto gather_gen;
29418
29419     gather_gen:
29420       arg0 = CALL_EXPR_ARG (exp, 0);
29421       arg1 = CALL_EXPR_ARG (exp, 1);
29422       arg2 = CALL_EXPR_ARG (exp, 2);
29423       arg3 = CALL_EXPR_ARG (exp, 3);
29424       arg4 = CALL_EXPR_ARG (exp, 4);
29425       op0 = expand_normal (arg0);
29426       op1 = expand_normal (arg1);
29427       op2 = expand_normal (arg2);
29428       op3 = expand_normal (arg3);
29429       op4 = expand_normal (arg4);
29430       /* Note the arg order is different from the operand order.  */
29431       mode0 = insn_data[icode].operand[1].mode;
29432       mode2 = insn_data[icode].operand[3].mode;
29433       mode3 = insn_data[icode].operand[4].mode;
29434       mode4 = insn_data[icode].operand[5].mode;
29435
29436       if (target == NULL_RTX
29437           || GET_MODE (target) != insn_data[icode].operand[0].mode)
29438         subtarget = gen_reg_rtx (insn_data[icode].operand[0].mode);
29439       else
29440         subtarget = target;
29441
29442       if (fcode == IX86_BUILTIN_GATHERALTSIV4DF
29443           || fcode == IX86_BUILTIN_GATHERALTSIV4DI)
29444         {
29445           rtx half = gen_reg_rtx (V4SImode);
29446           if (!nonimmediate_operand (op2, V8SImode))
29447             op2 = copy_to_mode_reg (V8SImode, op2);
29448           emit_insn (gen_vec_extract_lo_v8si (half, op2));
29449           op2 = half;
29450         }
29451       else if (fcode == IX86_BUILTIN_GATHERALTDIV8SF
29452                || fcode == IX86_BUILTIN_GATHERALTDIV8SI)
29453         {
29454           rtx (*gen) (rtx, rtx);
29455           rtx half = gen_reg_rtx (mode0);
29456           if (mode0 == V4SFmode)
29457             gen = gen_vec_extract_lo_v8sf;
29458           else
29459             gen = gen_vec_extract_lo_v8si;
29460           if (!nonimmediate_operand (op0, GET_MODE (op0)))
29461             op0 = copy_to_mode_reg (GET_MODE (op0), op0);
29462           emit_insn (gen (half, op0));
29463           op0 = half;
29464           if (!nonimmediate_operand (op3, GET_MODE (op3)))
29465             op3 = copy_to_mode_reg (GET_MODE (op3), op3);
29466           emit_insn (gen (half, op3));
29467           op3 = half;
29468         }
29469
29470       /* Force memory operand only with base register here.  But we
29471          don't want to do it on memory operand for other builtin
29472          functions.  */
29473       if (GET_MODE (op1) != Pmode)
29474         op1 = convert_to_mode (Pmode, op1, 1);
29475       op1 = force_reg (Pmode, op1);
29476
29477       if (!insn_data[icode].operand[1].predicate (op0, mode0))
29478         op0 = copy_to_mode_reg (mode0, op0);
29479       if (!insn_data[icode].operand[2].predicate (op1, Pmode))
29480         op1 = copy_to_mode_reg (Pmode, op1);
29481       if (!insn_data[icode].operand[3].predicate (op2, mode2))
29482         op2 = copy_to_mode_reg (mode2, op2);
29483       if (!insn_data[icode].operand[4].predicate (op3, mode3))
29484         op3 = copy_to_mode_reg (mode3, op3);
29485       if (!insn_data[icode].operand[5].predicate (op4, mode4))
29486         {
29487           error ("last argument must be scale 1, 2, 4, 8");
29488           return const0_rtx;
29489         }
29490
29491       /* Optimize.  If mask is known to have all high bits set,
29492          replace op0 with pc_rtx to signal that the instruction
29493          overwrites the whole destination and doesn't use its
29494          previous contents.  */
29495       if (optimize)
29496         {
29497           if (TREE_CODE (arg3) == VECTOR_CST)
29498             {
29499               tree elt;
29500               unsigned int negative = 0;
29501               for (elt = TREE_VECTOR_CST_ELTS (arg3);
29502                    elt; elt = TREE_CHAIN (elt))
29503                 {
29504                   tree cst = TREE_VALUE (elt);
29505                   if (TREE_CODE (cst) == INTEGER_CST
29506                       && tree_int_cst_sign_bit (cst))
29507                     negative++;
29508                   else if (TREE_CODE (cst) == REAL_CST
29509                            && REAL_VALUE_NEGATIVE (TREE_REAL_CST (cst)))
29510                     negative++;
29511                 }
29512               if (negative == TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg3)))
29513                 op0 = pc_rtx;
29514             }
29515           else if (TREE_CODE (arg3) == SSA_NAME)
29516             {
29517               /* Recognize also when mask is like:
29518                  __v2df src = _mm_setzero_pd ();
29519                  __v2df mask = _mm_cmpeq_pd (src, src);
29520                  or
29521                  __v8sf src = _mm256_setzero_ps ();
29522                  __v8sf mask = _mm256_cmp_ps (src, src, _CMP_EQ_OQ);
29523                  as that is a cheaper way to load all ones into
29524                  a register than having to load a constant from
29525                  memory.  */
29526               gimple def_stmt = SSA_NAME_DEF_STMT (arg3);
29527               if (is_gimple_call (def_stmt))
29528                 {
29529                   tree fndecl = gimple_call_fndecl (def_stmt);
29530                   if (fndecl
29531                       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
29532                     switch ((unsigned int) DECL_FUNCTION_CODE (fndecl))
29533                       {
29534                       case IX86_BUILTIN_CMPPD:
29535                       case IX86_BUILTIN_CMPPS:
29536                       case IX86_BUILTIN_CMPPD256:
29537                       case IX86_BUILTIN_CMPPS256:
29538                         if (!integer_zerop (gimple_call_arg (def_stmt, 2)))
29539                           break;
29540                         /* FALLTHRU */
29541                       case IX86_BUILTIN_CMPEQPD:
29542                       case IX86_BUILTIN_CMPEQPS:
29543                         if (initializer_zerop (gimple_call_arg (def_stmt, 0))
29544                             && initializer_zerop (gimple_call_arg (def_stmt,
29545                                                                    1)))
29546                           op0 = pc_rtx;
29547                         break;
29548                       default:
29549                         break;
29550                       }
29551                 }
29552             }
29553         }
29554
29555       pat = GEN_FCN (icode) (subtarget, op0, op1, op2, op3, op4);
29556       if (! pat)
29557         return const0_rtx;
29558       emit_insn (pat);
29559
29560       if (fcode == IX86_BUILTIN_GATHERDIV8SF
29561           || fcode == IX86_BUILTIN_GATHERDIV8SI)
29562         {
29563           enum machine_mode tmode = GET_MODE (subtarget) == V8SFmode
29564                                     ? V4SFmode : V4SImode;
29565           if (target == NULL_RTX)
29566             target = gen_reg_rtx (tmode);
29567           if (tmode == V4SFmode)
29568             emit_insn (gen_vec_extract_lo_v8sf (target, subtarget));
29569           else
29570             emit_insn (gen_vec_extract_lo_v8si (target, subtarget));
29571         }
29572       else
29573         target = subtarget;
29574
29575       return target;
29576
29577     default:
29578       break;
29579     }
29580
29581   for (i = 0, d = bdesc_special_args;
29582        i < ARRAY_SIZE (bdesc_special_args);
29583        i++, d++)
29584     if (d->code == fcode)
29585       return ix86_expand_special_args_builtin (d, exp, target);
29586
29587   for (i = 0, d = bdesc_args;
29588        i < ARRAY_SIZE (bdesc_args);
29589        i++, d++)
29590     if (d->code == fcode)
29591       switch (fcode)
29592         {
29593         case IX86_BUILTIN_FABSQ:
29594         case IX86_BUILTIN_COPYSIGNQ:
29595           if (!TARGET_SSE2)
29596             /* Emit a normal call if SSE2 isn't available.  */
29597             return expand_call (exp, target, ignore);
29598         default:
29599           return ix86_expand_args_builtin (d, exp, target);
29600         }
29601
29602   for (i = 0, d = bdesc_comi; i < ARRAY_SIZE (bdesc_comi); i++, d++)
29603     if (d->code == fcode)
29604       return ix86_expand_sse_comi (d, exp, target);
29605
29606   for (i = 0, d = bdesc_pcmpestr;
29607        i < ARRAY_SIZE (bdesc_pcmpestr);
29608        i++, d++)
29609     if (d->code == fcode)
29610       return ix86_expand_sse_pcmpestr (d, exp, target);
29611
29612   for (i = 0, d = bdesc_pcmpistr;
29613        i < ARRAY_SIZE (bdesc_pcmpistr);
29614        i++, d++)
29615     if (d->code == fcode)
29616       return ix86_expand_sse_pcmpistr (d, exp, target);
29617
29618   for (i = 0, d = bdesc_multi_arg; i < ARRAY_SIZE (bdesc_multi_arg); i++, d++)
29619     if (d->code == fcode)
29620       return ix86_expand_multi_arg_builtin (d->icode, exp, target,
29621                                             (enum ix86_builtin_func_type)
29622                                             d->flag, d->comparison);
29623
29624   gcc_unreachable ();
29625 }
29626
29627 /* Returns a function decl for a vectorized version of the builtin function
29628    with builtin function code FN and the result vector type TYPE, or NULL_TREE
29629    if it is not available.  */
29630
29631 static tree
29632 ix86_builtin_vectorized_function (tree fndecl, tree type_out,
29633                                   tree type_in)
29634 {
29635   enum machine_mode in_mode, out_mode;
29636   int in_n, out_n;
29637   enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
29638
29639   if (TREE_CODE (type_out) != VECTOR_TYPE
29640       || TREE_CODE (type_in) != VECTOR_TYPE
29641       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
29642     return NULL_TREE;
29643
29644   out_mode = TYPE_MODE (TREE_TYPE (type_out));
29645   out_n = TYPE_VECTOR_SUBPARTS (type_out);
29646   in_mode = TYPE_MODE (TREE_TYPE (type_in));
29647   in_n = TYPE_VECTOR_SUBPARTS (type_in);
29648
29649   switch (fn)
29650     {
29651     case BUILT_IN_SQRT:
29652       if (out_mode == DFmode && in_mode == DFmode)
29653         {
29654           if (out_n == 2 && in_n == 2)
29655             return ix86_builtins[IX86_BUILTIN_SQRTPD];
29656           else if (out_n == 4 && in_n == 4)
29657             return ix86_builtins[IX86_BUILTIN_SQRTPD256];
29658         }
29659       break;
29660
29661     case BUILT_IN_SQRTF:
29662       if (out_mode == SFmode && in_mode == SFmode)
29663         {
29664           if (out_n == 4 && in_n == 4)
29665             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR];
29666           else if (out_n == 8 && in_n == 8)
29667             return ix86_builtins[IX86_BUILTIN_SQRTPS_NR256];
29668         }
29669       break;
29670
29671     case BUILT_IN_IFLOOR:
29672     case BUILT_IN_LFLOOR:
29673     case BUILT_IN_LLFLOOR:
29674       /* The round insn does not trap on denormals.  */
29675       if (flag_trapping_math || !TARGET_ROUND)
29676         break;
29677
29678       if (out_mode == SImode && in_mode == DFmode)
29679         {
29680           if (out_n == 4 && in_n == 2)
29681             return ix86_builtins[IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX];
29682           else if (out_n == 8 && in_n == 4)
29683             return ix86_builtins[IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX256];
29684         }
29685       break;
29686
29687     case BUILT_IN_IFLOORF:
29688     case BUILT_IN_LFLOORF:
29689     case BUILT_IN_LLFLOORF:
29690       /* The round insn does not trap on denormals.  */
29691       if (flag_trapping_math || !TARGET_ROUND)
29692         break;
29693
29694       if (out_mode == SImode && in_mode == SFmode)
29695         {
29696           if (out_n == 4 && in_n == 4)
29697             return ix86_builtins[IX86_BUILTIN_FLOORPS_SFIX];
29698           else if (out_n == 8 && in_n == 8)
29699             return ix86_builtins[IX86_BUILTIN_FLOORPS_SFIX256];
29700         }
29701       break;
29702
29703     case BUILT_IN_ICEIL:
29704     case BUILT_IN_LCEIL:
29705     case BUILT_IN_LLCEIL:
29706       /* The round insn does not trap on denormals.  */
29707       if (flag_trapping_math || !TARGET_ROUND)
29708         break;
29709
29710       if (out_mode == SImode && in_mode == DFmode)
29711         {
29712           if (out_n == 4 && in_n == 2)
29713             return ix86_builtins[IX86_BUILTIN_CEILPD_VEC_PACK_SFIX];
29714           else if (out_n == 8 && in_n == 4)
29715             return ix86_builtins[IX86_BUILTIN_CEILPD_VEC_PACK_SFIX256];
29716         }
29717       break;
29718
29719     case BUILT_IN_ICEILF:
29720     case BUILT_IN_LCEILF:
29721     case BUILT_IN_LLCEILF:
29722       /* The round insn does not trap on denormals.  */
29723       if (flag_trapping_math || !TARGET_ROUND)
29724         break;
29725
29726       if (out_mode == SImode && in_mode == SFmode)
29727         {
29728           if (out_n == 4 && in_n == 4)
29729             return ix86_builtins[IX86_BUILTIN_CEILPS_SFIX];
29730           else if (out_n == 8 && in_n == 8)
29731             return ix86_builtins[IX86_BUILTIN_CEILPS_SFIX256];
29732         }
29733       break;
29734
29735     case BUILT_IN_IRINT:
29736     case BUILT_IN_LRINT:
29737     case BUILT_IN_LLRINT:
29738       if (out_mode == SImode && in_mode == DFmode)
29739         {
29740           if (out_n == 4 && in_n == 2)
29741             return ix86_builtins[IX86_BUILTIN_VEC_PACK_SFIX];
29742           else if (out_n == 8 && in_n == 4)
29743             return ix86_builtins[IX86_BUILTIN_VEC_PACK_SFIX256];
29744         }
29745       break;
29746
29747     case BUILT_IN_IRINTF:
29748     case BUILT_IN_LRINTF:
29749     case BUILT_IN_LLRINTF:
29750       if (out_mode == SImode && in_mode == SFmode)
29751         {
29752           if (out_n == 4 && in_n == 4)
29753             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ];
29754           else if (out_n == 8 && in_n == 8)
29755             return ix86_builtins[IX86_BUILTIN_CVTPS2DQ256];
29756         }
29757       break;
29758
29759     case BUILT_IN_IROUND:
29760     case BUILT_IN_LROUND:
29761     case BUILT_IN_LLROUND:
29762       /* The round insn does not trap on denormals.  */
29763       if (flag_trapping_math || !TARGET_ROUND)
29764         break;
29765
29766       if (out_mode == SImode && in_mode == DFmode)
29767         {
29768           if (out_n == 4 && in_n == 2)
29769             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX];
29770           else if (out_n == 8 && in_n == 4)
29771             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX256];
29772         }
29773       break;
29774
29775     case BUILT_IN_IROUNDF:
29776     case BUILT_IN_LROUNDF:
29777     case BUILT_IN_LLROUNDF:
29778       /* The round insn does not trap on denormals.  */
29779       if (flag_trapping_math || !TARGET_ROUND)
29780         break;
29781
29782       if (out_mode == SImode && in_mode == SFmode)
29783         {
29784           if (out_n == 4 && in_n == 4)
29785             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ_SFIX];
29786           else if (out_n == 8 && in_n == 8)
29787             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ_SFIX256];
29788         }
29789       break;
29790
29791     case BUILT_IN_COPYSIGN:
29792       if (out_mode == DFmode && in_mode == DFmode)
29793         {
29794           if (out_n == 2 && in_n == 2)
29795             return ix86_builtins[IX86_BUILTIN_CPYSGNPD];
29796           else if (out_n == 4 && in_n == 4)
29797             return ix86_builtins[IX86_BUILTIN_CPYSGNPD256];
29798         }
29799       break;
29800
29801     case BUILT_IN_COPYSIGNF:
29802       if (out_mode == SFmode && in_mode == SFmode)
29803         {
29804           if (out_n == 4 && in_n == 4)
29805             return ix86_builtins[IX86_BUILTIN_CPYSGNPS];
29806           else if (out_n == 8 && in_n == 8)
29807             return ix86_builtins[IX86_BUILTIN_CPYSGNPS256];
29808         }
29809       break;
29810
29811     case BUILT_IN_FLOOR:
29812       /* The round insn does not trap on denormals.  */
29813       if (flag_trapping_math || !TARGET_ROUND)
29814         break;
29815
29816       if (out_mode == DFmode && in_mode == DFmode)
29817         {
29818           if (out_n == 2 && in_n == 2)
29819             return ix86_builtins[IX86_BUILTIN_FLOORPD];
29820           else if (out_n == 4 && in_n == 4)
29821             return ix86_builtins[IX86_BUILTIN_FLOORPD256];
29822         }
29823       break;
29824
29825     case BUILT_IN_FLOORF:
29826       /* The round insn does not trap on denormals.  */
29827       if (flag_trapping_math || !TARGET_ROUND)
29828         break;
29829
29830       if (out_mode == SFmode && in_mode == SFmode)
29831         {
29832           if (out_n == 4 && in_n == 4)
29833             return ix86_builtins[IX86_BUILTIN_FLOORPS];
29834           else if (out_n == 8 && in_n == 8)
29835             return ix86_builtins[IX86_BUILTIN_FLOORPS256];
29836         }
29837       break;
29838
29839     case BUILT_IN_CEIL:
29840       /* The round insn does not trap on denormals.  */
29841       if (flag_trapping_math || !TARGET_ROUND)
29842         break;
29843
29844       if (out_mode == DFmode && in_mode == DFmode)
29845         {
29846           if (out_n == 2 && in_n == 2)
29847             return ix86_builtins[IX86_BUILTIN_CEILPD];
29848           else if (out_n == 4 && in_n == 4)
29849             return ix86_builtins[IX86_BUILTIN_CEILPD256];
29850         }
29851       break;
29852
29853     case BUILT_IN_CEILF:
29854       /* The round insn does not trap on denormals.  */
29855       if (flag_trapping_math || !TARGET_ROUND)
29856         break;
29857
29858       if (out_mode == SFmode && in_mode == SFmode)
29859         {
29860           if (out_n == 4 && in_n == 4)
29861             return ix86_builtins[IX86_BUILTIN_CEILPS];
29862           else if (out_n == 8 && in_n == 8)
29863             return ix86_builtins[IX86_BUILTIN_CEILPS256];
29864         }
29865       break;
29866
29867     case BUILT_IN_TRUNC:
29868       /* The round insn does not trap on denormals.  */
29869       if (flag_trapping_math || !TARGET_ROUND)
29870         break;
29871
29872       if (out_mode == DFmode && in_mode == DFmode)
29873         {
29874           if (out_n == 2 && in_n == 2)
29875             return ix86_builtins[IX86_BUILTIN_TRUNCPD];
29876           else if (out_n == 4 && in_n == 4)
29877             return ix86_builtins[IX86_BUILTIN_TRUNCPD256];
29878         }
29879       break;
29880
29881     case BUILT_IN_TRUNCF:
29882       /* The round insn does not trap on denormals.  */
29883       if (flag_trapping_math || !TARGET_ROUND)
29884         break;
29885
29886       if (out_mode == SFmode && in_mode == SFmode)
29887         {
29888           if (out_n == 4 && in_n == 4)
29889             return ix86_builtins[IX86_BUILTIN_TRUNCPS];
29890           else if (out_n == 8 && in_n == 8)
29891             return ix86_builtins[IX86_BUILTIN_TRUNCPS256];
29892         }
29893       break;
29894
29895     case BUILT_IN_RINT:
29896       /* The round insn does not trap on denormals.  */
29897       if (flag_trapping_math || !TARGET_ROUND)
29898         break;
29899
29900       if (out_mode == DFmode && in_mode == DFmode)
29901         {
29902           if (out_n == 2 && in_n == 2)
29903             return ix86_builtins[IX86_BUILTIN_RINTPD];
29904           else if (out_n == 4 && in_n == 4)
29905             return ix86_builtins[IX86_BUILTIN_RINTPD256];
29906         }
29907       break;
29908
29909     case BUILT_IN_RINTF:
29910       /* The round insn does not trap on denormals.  */
29911       if (flag_trapping_math || !TARGET_ROUND)
29912         break;
29913
29914       if (out_mode == SFmode && in_mode == SFmode)
29915         {
29916           if (out_n == 4 && in_n == 4)
29917             return ix86_builtins[IX86_BUILTIN_RINTPS];
29918           else if (out_n == 8 && in_n == 8)
29919             return ix86_builtins[IX86_BUILTIN_RINTPS256];
29920         }
29921       break;
29922
29923     case BUILT_IN_ROUND:
29924       /* The round insn does not trap on denormals.  */
29925       if (flag_trapping_math || !TARGET_ROUND)
29926         break;
29927
29928       if (out_mode == DFmode && in_mode == DFmode)
29929         {
29930           if (out_n == 2 && in_n == 2)
29931             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ];
29932           else if (out_n == 4 && in_n == 4)
29933             return ix86_builtins[IX86_BUILTIN_ROUNDPD_AZ256];
29934         }
29935       break;
29936
29937     case BUILT_IN_ROUNDF:
29938       /* The round insn does not trap on denormals.  */
29939       if (flag_trapping_math || !TARGET_ROUND)
29940         break;
29941
29942       if (out_mode == SFmode && in_mode == SFmode)
29943         {
29944           if (out_n == 4 && in_n == 4)
29945             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ];
29946           else if (out_n == 8 && in_n == 8)
29947             return ix86_builtins[IX86_BUILTIN_ROUNDPS_AZ256];
29948         }
29949       break;
29950
29951     case BUILT_IN_FMA:
29952       if (out_mode == DFmode && in_mode == DFmode)
29953         {
29954           if (out_n == 2 && in_n == 2)
29955             return ix86_builtins[IX86_BUILTIN_VFMADDPD];
29956           if (out_n == 4 && in_n == 4)
29957             return ix86_builtins[IX86_BUILTIN_VFMADDPD256];
29958         }
29959       break;
29960
29961     case BUILT_IN_FMAF:
29962       if (out_mode == SFmode && in_mode == SFmode)
29963         {
29964           if (out_n == 4 && in_n == 4)
29965             return ix86_builtins[IX86_BUILTIN_VFMADDPS];
29966           if (out_n == 8 && in_n == 8)
29967             return ix86_builtins[IX86_BUILTIN_VFMADDPS256];
29968         }
29969       break;
29970
29971     default:
29972       break;
29973     }
29974
29975   /* Dispatch to a handler for a vectorization library.  */
29976   if (ix86_veclib_handler)
29977     return ix86_veclib_handler ((enum built_in_function) fn, type_out,
29978                                 type_in);
29979
29980   return NULL_TREE;
29981 }
29982
29983 /* Handler for an SVML-style interface to
29984    a library with vectorized intrinsics.  */
29985
29986 static tree
29987 ix86_veclibabi_svml (enum built_in_function fn, tree type_out, tree type_in)
29988 {
29989   char name[20];
29990   tree fntype, new_fndecl, args;
29991   unsigned arity;
29992   const char *bname;
29993   enum machine_mode el_mode, in_mode;
29994   int n, in_n;
29995
29996   /* The SVML is suitable for unsafe math only.  */
29997   if (!flag_unsafe_math_optimizations)
29998     return NULL_TREE;
29999
30000   el_mode = TYPE_MODE (TREE_TYPE (type_out));
30001   n = TYPE_VECTOR_SUBPARTS (type_out);
30002   in_mode = TYPE_MODE (TREE_TYPE (type_in));
30003   in_n = TYPE_VECTOR_SUBPARTS (type_in);
30004   if (el_mode != in_mode
30005       || n != in_n)
30006     return NULL_TREE;
30007
30008   switch (fn)
30009     {
30010     case BUILT_IN_EXP:
30011     case BUILT_IN_LOG:
30012     case BUILT_IN_LOG10:
30013     case BUILT_IN_POW:
30014     case BUILT_IN_TANH:
30015     case BUILT_IN_TAN:
30016     case BUILT_IN_ATAN:
30017     case BUILT_IN_ATAN2:
30018     case BUILT_IN_ATANH:
30019     case BUILT_IN_CBRT:
30020     case BUILT_IN_SINH:
30021     case BUILT_IN_SIN:
30022     case BUILT_IN_ASINH:
30023     case BUILT_IN_ASIN:
30024     case BUILT_IN_COSH:
30025     case BUILT_IN_COS:
30026     case BUILT_IN_ACOSH:
30027     case BUILT_IN_ACOS:
30028       if (el_mode != DFmode || n != 2)
30029         return NULL_TREE;
30030       break;
30031
30032     case BUILT_IN_EXPF:
30033     case BUILT_IN_LOGF:
30034     case BUILT_IN_LOG10F:
30035     case BUILT_IN_POWF:
30036     case BUILT_IN_TANHF:
30037     case BUILT_IN_TANF:
30038     case BUILT_IN_ATANF:
30039     case BUILT_IN_ATAN2F:
30040     case BUILT_IN_ATANHF:
30041     case BUILT_IN_CBRTF:
30042     case BUILT_IN_SINHF:
30043     case BUILT_IN_SINF:
30044     case BUILT_IN_ASINHF:
30045     case BUILT_IN_ASINF:
30046     case BUILT_IN_COSHF:
30047     case BUILT_IN_COSF:
30048     case BUILT_IN_ACOSHF:
30049     case BUILT_IN_ACOSF:
30050       if (el_mode != SFmode || n != 4)
30051         return NULL_TREE;
30052       break;
30053
30054     default:
30055       return NULL_TREE;
30056     }
30057
30058   bname = IDENTIFIER_POINTER (DECL_NAME (builtin_decl_implicit (fn)));
30059
30060   if (fn == BUILT_IN_LOGF)
30061     strcpy (name, "vmlsLn4");
30062   else if (fn == BUILT_IN_LOG)
30063     strcpy (name, "vmldLn2");
30064   else if (n == 4)
30065     {
30066       sprintf (name, "vmls%s", bname+10);
30067       name[strlen (name)-1] = '4';
30068     }
30069   else
30070     sprintf (name, "vmld%s2", bname+10);
30071
30072   /* Convert to uppercase. */
30073   name[4] &= ~0x20;
30074
30075   arity = 0;
30076   for (args = DECL_ARGUMENTS (builtin_decl_implicit (fn));
30077        args;
30078        args = TREE_CHAIN (args))
30079     arity++;
30080
30081   if (arity == 1)
30082     fntype = build_function_type_list (type_out, type_in, NULL);
30083   else
30084     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
30085
30086   /* Build a function declaration for the vectorized function.  */
30087   new_fndecl = build_decl (BUILTINS_LOCATION,
30088                            FUNCTION_DECL, get_identifier (name), fntype);
30089   TREE_PUBLIC (new_fndecl) = 1;
30090   DECL_EXTERNAL (new_fndecl) = 1;
30091   DECL_IS_NOVOPS (new_fndecl) = 1;
30092   TREE_READONLY (new_fndecl) = 1;
30093
30094   return new_fndecl;
30095 }
30096
30097 /* Handler for an ACML-style interface to
30098    a library with vectorized intrinsics.  */
30099
30100 static tree
30101 ix86_veclibabi_acml (enum built_in_function fn, tree type_out, tree type_in)
30102 {
30103   char name[20] = "__vr.._";
30104   tree fntype, new_fndecl, args;
30105   unsigned arity;
30106   const char *bname;
30107   enum machine_mode el_mode, in_mode;
30108   int n, in_n;
30109
30110   /* The ACML is 64bits only and suitable for unsafe math only as
30111      it does not correctly support parts of IEEE with the required
30112      precision such as denormals.  */
30113   if (!TARGET_64BIT
30114       || !flag_unsafe_math_optimizations)
30115     return NULL_TREE;
30116
30117   el_mode = TYPE_MODE (TREE_TYPE (type_out));
30118   n = TYPE_VECTOR_SUBPARTS (type_out);
30119   in_mode = TYPE_MODE (TREE_TYPE (type_in));
30120   in_n = TYPE_VECTOR_SUBPARTS (type_in);
30121   if (el_mode != in_mode
30122       || n != in_n)
30123     return NULL_TREE;
30124
30125   switch (fn)
30126     {
30127     case BUILT_IN_SIN:
30128     case BUILT_IN_COS:
30129     case BUILT_IN_EXP:
30130     case BUILT_IN_LOG:
30131     case BUILT_IN_LOG2:
30132     case BUILT_IN_LOG10:
30133       name[4] = 'd';
30134       name[5] = '2';
30135       if (el_mode != DFmode
30136           || n != 2)
30137         return NULL_TREE;
30138       break;
30139
30140     case BUILT_IN_SINF:
30141     case BUILT_IN_COSF:
30142     case BUILT_IN_EXPF:
30143     case BUILT_IN_POWF:
30144     case BUILT_IN_LOGF:
30145     case BUILT_IN_LOG2F:
30146     case BUILT_IN_LOG10F:
30147       name[4] = 's';
30148       name[5] = '4';
30149       if (el_mode != SFmode
30150           || n != 4)
30151         return NULL_TREE;
30152       break;
30153
30154     default:
30155       return NULL_TREE;
30156     }
30157
30158   bname = IDENTIFIER_POINTER (DECL_NAME (builtin_decl_implicit (fn)));
30159   sprintf (name + 7, "%s", bname+10);
30160
30161   arity = 0;
30162   for (args = DECL_ARGUMENTS (builtin_decl_implicit (fn));
30163        args;
30164        args = TREE_CHAIN (args))
30165     arity++;
30166
30167   if (arity == 1)
30168     fntype = build_function_type_list (type_out, type_in, NULL);
30169   else
30170     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
30171
30172   /* Build a function declaration for the vectorized function.  */
30173   new_fndecl = build_decl (BUILTINS_LOCATION,
30174                            FUNCTION_DECL, get_identifier (name), fntype);
30175   TREE_PUBLIC (new_fndecl) = 1;
30176   DECL_EXTERNAL (new_fndecl) = 1;
30177   DECL_IS_NOVOPS (new_fndecl) = 1;
30178   TREE_READONLY (new_fndecl) = 1;
30179
30180   return new_fndecl;
30181 }
30182
30183 /* Returns a decl of a function that implements gather load with
30184    memory type MEM_VECTYPE and index type INDEX_VECTYPE and SCALE.
30185    Return NULL_TREE if it is not available.  */
30186
30187 static tree
30188 ix86_vectorize_builtin_gather (const_tree mem_vectype,
30189                                const_tree index_type, int scale)
30190 {
30191   bool si;
30192   enum ix86_builtins code;
30193
30194   if (! TARGET_AVX2)
30195     return NULL_TREE;
30196
30197   if ((TREE_CODE (index_type) != INTEGER_TYPE
30198        && !POINTER_TYPE_P (index_type))
30199       || (TYPE_MODE (index_type) != SImode
30200           && TYPE_MODE (index_type) != DImode))
30201     return NULL_TREE;
30202
30203   if (TYPE_PRECISION (index_type) > POINTER_SIZE)
30204     return NULL_TREE;
30205
30206   /* v*gather* insn sign extends index to pointer mode.  */
30207   if (TYPE_PRECISION (index_type) < POINTER_SIZE
30208       && TYPE_UNSIGNED (index_type))
30209     return NULL_TREE;
30210
30211   if (scale <= 0
30212       || scale > 8
30213       || (scale & (scale - 1)) != 0)
30214     return NULL_TREE;
30215
30216   si = TYPE_MODE (index_type) == SImode;
30217   switch (TYPE_MODE (mem_vectype))
30218     {
30219     case V2DFmode:
30220       code = si ? IX86_BUILTIN_GATHERSIV2DF : IX86_BUILTIN_GATHERDIV2DF;
30221       break;
30222     case V4DFmode:
30223       code = si ? IX86_BUILTIN_GATHERALTSIV4DF : IX86_BUILTIN_GATHERDIV4DF;
30224       break;
30225     case V2DImode:
30226       code = si ? IX86_BUILTIN_GATHERSIV2DI : IX86_BUILTIN_GATHERDIV2DI;
30227       break;
30228     case V4DImode:
30229       code = si ? IX86_BUILTIN_GATHERALTSIV4DI : IX86_BUILTIN_GATHERDIV4DI;
30230       break;
30231     case V4SFmode:
30232       code = si ? IX86_BUILTIN_GATHERSIV4SF : IX86_BUILTIN_GATHERDIV4SF;
30233       break;
30234     case V8SFmode:
30235       code = si ? IX86_BUILTIN_GATHERSIV8SF : IX86_BUILTIN_GATHERALTDIV8SF;
30236       break;
30237     case V4SImode:
30238       code = si ? IX86_BUILTIN_GATHERSIV4SI : IX86_BUILTIN_GATHERDIV4SI;
30239       break;
30240     case V8SImode:
30241       code = si ? IX86_BUILTIN_GATHERSIV8SI : IX86_BUILTIN_GATHERALTDIV8SI;
30242       break;
30243     default:
30244       return NULL_TREE;
30245     }
30246
30247   return ix86_builtins[code];
30248 }
30249
30250 /* Returns a code for a target-specific builtin that implements
30251    reciprocal of the function, or NULL_TREE if not available.  */
30252
30253 static tree
30254 ix86_builtin_reciprocal (unsigned int fn, bool md_fn,
30255                          bool sqrt ATTRIBUTE_UNUSED)
30256 {
30257   if (! (TARGET_SSE_MATH && !optimize_insn_for_size_p ()
30258          && flag_finite_math_only && !flag_trapping_math
30259          && flag_unsafe_math_optimizations))
30260     return NULL_TREE;
30261
30262   if (md_fn)
30263     /* Machine dependent builtins.  */
30264     switch (fn)
30265       {
30266         /* Vectorized version of sqrt to rsqrt conversion.  */
30267       case IX86_BUILTIN_SQRTPS_NR:
30268         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR];
30269
30270       case IX86_BUILTIN_SQRTPS_NR256:
30271         return ix86_builtins[IX86_BUILTIN_RSQRTPS_NR256];
30272
30273       default:
30274         return NULL_TREE;
30275       }
30276   else
30277     /* Normal builtins.  */
30278     switch (fn)
30279       {
30280         /* Sqrt to rsqrt conversion.  */
30281       case BUILT_IN_SQRTF:
30282         return ix86_builtins[IX86_BUILTIN_RSQRTF];
30283
30284       default:
30285         return NULL_TREE;
30286       }
30287 }
30288 \f
30289 /* Helper for avx_vpermilps256_operand et al.  This is also used by
30290    the expansion functions to turn the parallel back into a mask.
30291    The return value is 0 for no match and the imm8+1 for a match.  */
30292
30293 int
30294 avx_vpermilp_parallel (rtx par, enum machine_mode mode)
30295 {
30296   unsigned i, nelt = GET_MODE_NUNITS (mode);
30297   unsigned mask = 0;
30298   unsigned char ipar[8];
30299
30300   if (XVECLEN (par, 0) != (int) nelt)
30301     return 0;
30302
30303   /* Validate that all of the elements are constants, and not totally
30304      out of range.  Copy the data into an integral array to make the
30305      subsequent checks easier.  */
30306   for (i = 0; i < nelt; ++i)
30307     {
30308       rtx er = XVECEXP (par, 0, i);
30309       unsigned HOST_WIDE_INT ei;
30310
30311       if (!CONST_INT_P (er))
30312         return 0;
30313       ei = INTVAL (er);
30314       if (ei >= nelt)
30315         return 0;
30316       ipar[i] = ei;
30317     }
30318
30319   switch (mode)
30320     {
30321     case V4DFmode:
30322       /* In the 256-bit DFmode case, we can only move elements within
30323          a 128-bit lane.  */
30324       for (i = 0; i < 2; ++i)
30325         {
30326           if (ipar[i] >= 2)
30327             return 0;
30328           mask |= ipar[i] << i;
30329         }
30330       for (i = 2; i < 4; ++i)
30331         {
30332           if (ipar[i] < 2)
30333             return 0;
30334           mask |= (ipar[i] - 2) << i;
30335         }
30336       break;
30337
30338     case V8SFmode:
30339       /* In the 256-bit SFmode case, we have full freedom of movement
30340          within the low 128-bit lane, but the high 128-bit lane must
30341          mirror the exact same pattern.  */
30342       for (i = 0; i < 4; ++i)
30343         if (ipar[i] + 4 != ipar[i + 4])
30344           return 0;
30345       nelt = 4;
30346       /* FALLTHRU */
30347
30348     case V2DFmode:
30349     case V4SFmode:
30350       /* In the 128-bit case, we've full freedom in the placement of
30351          the elements from the source operand.  */
30352       for (i = 0; i < nelt; ++i)
30353         mask |= ipar[i] << (i * (nelt / 2));
30354       break;
30355
30356     default:
30357       gcc_unreachable ();
30358     }
30359
30360   /* Make sure success has a non-zero value by adding one.  */
30361   return mask + 1;
30362 }
30363
30364 /* Helper for avx_vperm2f128_v4df_operand et al.  This is also used by
30365    the expansion functions to turn the parallel back into a mask.
30366    The return value is 0 for no match and the imm8+1 for a match.  */
30367
30368 int
30369 avx_vperm2f128_parallel (rtx par, enum machine_mode mode)
30370 {
30371   unsigned i, nelt = GET_MODE_NUNITS (mode), nelt2 = nelt / 2;
30372   unsigned mask = 0;
30373   unsigned char ipar[8];
30374
30375   if (XVECLEN (par, 0) != (int) nelt)
30376     return 0;
30377
30378   /* Validate that all of the elements are constants, and not totally
30379      out of range.  Copy the data into an integral array to make the
30380      subsequent checks easier.  */
30381   for (i = 0; i < nelt; ++i)
30382     {
30383       rtx er = XVECEXP (par, 0, i);
30384       unsigned HOST_WIDE_INT ei;
30385
30386       if (!CONST_INT_P (er))
30387         return 0;
30388       ei = INTVAL (er);
30389       if (ei >= 2 * nelt)
30390         return 0;
30391       ipar[i] = ei;
30392     }
30393
30394   /* Validate that the halves of the permute are halves.  */
30395   for (i = 0; i < nelt2 - 1; ++i)
30396     if (ipar[i] + 1 != ipar[i + 1])
30397       return 0;
30398   for (i = nelt2; i < nelt - 1; ++i)
30399     if (ipar[i] + 1 != ipar[i + 1])
30400       return 0;
30401
30402   /* Reconstruct the mask.  */
30403   for (i = 0; i < 2; ++i)
30404     {
30405       unsigned e = ipar[i * nelt2];
30406       if (e % nelt2)
30407         return 0;
30408       e /= nelt2;
30409       mask |= e << (i * 4);
30410     }
30411
30412   /* Make sure success has a non-zero value by adding one.  */
30413   return mask + 1;
30414 }
30415 \f
30416 /* Store OPERAND to the memory after reload is completed.  This means
30417    that we can't easily use assign_stack_local.  */
30418 rtx
30419 ix86_force_to_memory (enum machine_mode mode, rtx operand)
30420 {
30421   rtx result;
30422
30423   gcc_assert (reload_completed);
30424   if (ix86_using_red_zone ())
30425     {
30426       result = gen_rtx_MEM (mode,
30427                             gen_rtx_PLUS (Pmode,
30428                                           stack_pointer_rtx,
30429                                           GEN_INT (-RED_ZONE_SIZE)));
30430       emit_move_insn (result, operand);
30431     }
30432   else if (TARGET_64BIT)
30433     {
30434       switch (mode)
30435         {
30436         case HImode:
30437         case SImode:
30438           operand = gen_lowpart (DImode, operand);
30439           /* FALLTHRU */
30440         case DImode:
30441           emit_insn (
30442                       gen_rtx_SET (VOIDmode,
30443                                    gen_rtx_MEM (DImode,
30444                                                 gen_rtx_PRE_DEC (DImode,
30445                                                         stack_pointer_rtx)),
30446                                    operand));
30447           break;
30448         default:
30449           gcc_unreachable ();
30450         }
30451       result = gen_rtx_MEM (mode, stack_pointer_rtx);
30452     }
30453   else
30454     {
30455       switch (mode)
30456         {
30457         case DImode:
30458           {
30459             rtx operands[2];
30460             split_double_mode (mode, &operand, 1, operands, operands + 1);
30461             emit_insn (
30462                         gen_rtx_SET (VOIDmode,
30463                                      gen_rtx_MEM (SImode,
30464                                                   gen_rtx_PRE_DEC (Pmode,
30465                                                         stack_pointer_rtx)),
30466                                      operands[1]));
30467             emit_insn (
30468                         gen_rtx_SET (VOIDmode,
30469                                      gen_rtx_MEM (SImode,
30470                                                   gen_rtx_PRE_DEC (Pmode,
30471                                                         stack_pointer_rtx)),
30472                                      operands[0]));
30473           }
30474           break;
30475         case HImode:
30476           /* Store HImodes as SImodes.  */
30477           operand = gen_lowpart (SImode, operand);
30478           /* FALLTHRU */
30479         case SImode:
30480           emit_insn (
30481                       gen_rtx_SET (VOIDmode,
30482                                    gen_rtx_MEM (GET_MODE (operand),
30483                                                 gen_rtx_PRE_DEC (SImode,
30484                                                         stack_pointer_rtx)),
30485                                    operand));
30486           break;
30487         default:
30488           gcc_unreachable ();
30489         }
30490       result = gen_rtx_MEM (mode, stack_pointer_rtx);
30491     }
30492   return result;
30493 }
30494
30495 /* Free operand from the memory.  */
30496 void
30497 ix86_free_from_memory (enum machine_mode mode)
30498 {
30499   if (!ix86_using_red_zone ())
30500     {
30501       int size;
30502
30503       if (mode == DImode || TARGET_64BIT)
30504         size = 8;
30505       else
30506         size = 4;
30507       /* Use LEA to deallocate stack space.  In peephole2 it will be converted
30508          to pop or add instruction if registers are available.  */
30509       emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
30510                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
30511                                             GEN_INT (size))));
30512     }
30513 }
30514
30515 /* Implement TARGET_PREFERRED_RELOAD_CLASS.
30516
30517    Put float CONST_DOUBLE in the constant pool instead of fp regs.
30518    QImode must go into class Q_REGS.
30519    Narrow ALL_REGS to GENERAL_REGS.  This supports allowing movsf and
30520    movdf to do mem-to-mem moves through integer regs.  */
30521
30522 static reg_class_t
30523 ix86_preferred_reload_class (rtx x, reg_class_t regclass)
30524 {
30525   enum machine_mode mode = GET_MODE (x);
30526
30527   /* We're only allowed to return a subclass of CLASS.  Many of the
30528      following checks fail for NO_REGS, so eliminate that early.  */
30529   if (regclass == NO_REGS)
30530     return NO_REGS;
30531
30532   /* All classes can load zeros.  */
30533   if (x == CONST0_RTX (mode))
30534     return regclass;
30535
30536   /* Force constants into memory if we are loading a (nonzero) constant into
30537      an MMX or SSE register.  This is because there are no MMX/SSE instructions
30538      to load from a constant.  */
30539   if (CONSTANT_P (x)
30540       && (MAYBE_MMX_CLASS_P (regclass) || MAYBE_SSE_CLASS_P (regclass)))
30541     return NO_REGS;
30542
30543   /* Prefer SSE regs only, if we can use them for math.  */
30544   if (TARGET_SSE_MATH && !TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P (mode))
30545     return SSE_CLASS_P (regclass) ? regclass : NO_REGS;
30546
30547   /* Floating-point constants need more complex checks.  */
30548   if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode)
30549     {
30550       /* General regs can load everything.  */
30551       if (reg_class_subset_p (regclass, GENERAL_REGS))
30552         return regclass;
30553
30554       /* Floats can load 0 and 1 plus some others.  Note that we eliminated
30555          zero above.  We only want to wind up preferring 80387 registers if
30556          we plan on doing computation with them.  */
30557       if (TARGET_80387
30558           && standard_80387_constant_p (x) > 0)
30559         {
30560           /* Limit class to non-sse.  */
30561           if (regclass == FLOAT_SSE_REGS)
30562             return FLOAT_REGS;
30563           if (regclass == FP_TOP_SSE_REGS)
30564             return FP_TOP_REG;
30565           if (regclass == FP_SECOND_SSE_REGS)
30566             return FP_SECOND_REG;
30567           if (regclass == FLOAT_INT_REGS || regclass == FLOAT_REGS)
30568             return regclass;
30569         }
30570
30571       return NO_REGS;
30572     }
30573
30574   /* Generally when we see PLUS here, it's the function invariant
30575      (plus soft-fp const_int).  Which can only be computed into general
30576      regs.  */
30577   if (GET_CODE (x) == PLUS)
30578     return reg_class_subset_p (regclass, GENERAL_REGS) ? regclass : NO_REGS;
30579
30580   /* QImode constants are easy to load, but non-constant QImode data
30581      must go into Q_REGS.  */
30582   if (GET_MODE (x) == QImode && !CONSTANT_P (x))
30583     {
30584       if (reg_class_subset_p (regclass, Q_REGS))
30585         return regclass;
30586       if (reg_class_subset_p (Q_REGS, regclass))
30587         return Q_REGS;
30588       return NO_REGS;
30589     }
30590
30591   return regclass;
30592 }
30593
30594 /* Discourage putting floating-point values in SSE registers unless
30595    SSE math is being used, and likewise for the 387 registers.  */
30596 static reg_class_t
30597 ix86_preferred_output_reload_class (rtx x, reg_class_t regclass)
30598 {
30599   enum machine_mode mode = GET_MODE (x);
30600
30601   /* Restrict the output reload class to the register bank that we are doing
30602      math on.  If we would like not to return a subset of CLASS, reject this
30603      alternative: if reload cannot do this, it will still use its choice.  */
30604   mode = GET_MODE (x);
30605   if (TARGET_SSE_MATH && SSE_FLOAT_MODE_P (mode))
30606     return MAYBE_SSE_CLASS_P (regclass) ? SSE_REGS : NO_REGS;
30607
30608   if (X87_FLOAT_MODE_P (mode))
30609     {
30610       if (regclass == FP_TOP_SSE_REGS)
30611         return FP_TOP_REG;
30612       else if (regclass == FP_SECOND_SSE_REGS)
30613         return FP_SECOND_REG;
30614       else
30615         return FLOAT_CLASS_P (regclass) ? regclass : NO_REGS;
30616     }
30617
30618   return regclass;
30619 }
30620
30621 static reg_class_t
30622 ix86_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
30623                        enum machine_mode mode, secondary_reload_info *sri)
30624 {
30625   /* Double-word spills from general registers to non-offsettable memory
30626      references (zero-extended addresses) require special handling.  */
30627   if (TARGET_64BIT
30628       && MEM_P (x)
30629       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
30630       && rclass == GENERAL_REGS
30631       && !offsettable_memref_p (x))
30632     {
30633       sri->icode = (in_p
30634                     ? CODE_FOR_reload_noff_load
30635                     : CODE_FOR_reload_noff_store);
30636       /* Add the cost of moving address to a temporary.  */
30637       sri->extra_cost = 1;
30638
30639       return NO_REGS;
30640     }
30641
30642   /* QImode spills from non-QI registers require
30643      intermediate register on 32bit targets.  */
30644   if (!TARGET_64BIT
30645       && !in_p && mode == QImode
30646       && (rclass == GENERAL_REGS
30647           || rclass == LEGACY_REGS
30648           || rclass == INDEX_REGS))
30649     {
30650       int regno;
30651
30652       if (REG_P (x))
30653         regno = REGNO (x);
30654       else
30655         regno = -1;
30656
30657       if (regno >= FIRST_PSEUDO_REGISTER || GET_CODE (x) == SUBREG)
30658         regno = true_regnum (x);
30659
30660       /* Return Q_REGS if the operand is in memory.  */
30661       if (regno == -1)
30662         return Q_REGS;
30663     }
30664
30665   /* This condition handles corner case where an expression involving
30666      pointers gets vectorized.  We're trying to use the address of a
30667      stack slot as a vector initializer.
30668
30669      (set (reg:V2DI 74 [ vect_cst_.2 ])
30670           (vec_duplicate:V2DI (reg/f:DI 20 frame)))
30671
30672      Eventually frame gets turned into sp+offset like this:
30673
30674      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
30675           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
30676                                        (const_int 392 [0x188]))))
30677
30678      That later gets turned into:
30679
30680      (set (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
30681           (vec_duplicate:V2DI (plus:DI (reg/f:DI 7 sp)
30682             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))))
30683
30684      We'll have the following reload recorded:
30685
30686      Reload 0: reload_in (DI) =
30687            (plus:DI (reg/f:DI 7 sp)
30688             (mem/u/c/i:DI (symbol_ref/u:DI ("*.LC0") [flags 0x2]) [0 S8 A64]))
30689      reload_out (V2DI) = (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
30690      SSE_REGS, RELOAD_OTHER (opnum = 0), can't combine
30691      reload_in_reg: (plus:DI (reg/f:DI 7 sp) (const_int 392 [0x188]))
30692      reload_out_reg: (reg:V2DI 21 xmm0 [orig:74 vect_cst_.2 ] [74])
30693      reload_reg_rtx: (reg:V2DI 22 xmm1)
30694
30695      Which isn't going to work since SSE instructions can't handle scalar
30696      additions.  Returning GENERAL_REGS forces the addition into integer
30697      register and reload can handle subsequent reloads without problems.  */
30698
30699   if (in_p && GET_CODE (x) == PLUS
30700       && SSE_CLASS_P (rclass)
30701       && SCALAR_INT_MODE_P (mode))
30702     return GENERAL_REGS;
30703
30704   return NO_REGS;
30705 }
30706
30707 /* Implement TARGET_CLASS_LIKELY_SPILLED_P.  */
30708
30709 static bool
30710 ix86_class_likely_spilled_p (reg_class_t rclass)
30711 {
30712   switch (rclass)
30713     {
30714       case AREG:
30715       case DREG:
30716       case CREG:
30717       case BREG:
30718       case AD_REGS:
30719       case SIREG:
30720       case DIREG:
30721       case SSE_FIRST_REG:
30722       case FP_TOP_REG:
30723       case FP_SECOND_REG:
30724         return true;
30725
30726       default:
30727         break;
30728     }
30729
30730   return false;
30731 }
30732
30733 /* If we are copying between general and FP registers, we need a memory
30734    location. The same is true for SSE and MMX registers.
30735
30736    To optimize register_move_cost performance, allow inline variant.
30737
30738    The macro can't work reliably when one of the CLASSES is class containing
30739    registers from multiple units (SSE, MMX, integer).  We avoid this by never
30740    combining those units in single alternative in the machine description.
30741    Ensure that this constraint holds to avoid unexpected surprises.
30742
30743    When STRICT is false, we are being called from REGISTER_MOVE_COST, so do not
30744    enforce these sanity checks.  */
30745
30746 static inline bool
30747 inline_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
30748                                 enum machine_mode mode, int strict)
30749 {
30750   if (MAYBE_FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class1)
30751       || MAYBE_FLOAT_CLASS_P (class2) != FLOAT_CLASS_P (class2)
30752       || MAYBE_SSE_CLASS_P (class1) != SSE_CLASS_P (class1)
30753       || MAYBE_SSE_CLASS_P (class2) != SSE_CLASS_P (class2)
30754       || MAYBE_MMX_CLASS_P (class1) != MMX_CLASS_P (class1)
30755       || MAYBE_MMX_CLASS_P (class2) != MMX_CLASS_P (class2))
30756     {
30757       gcc_assert (!strict);
30758       return true;
30759     }
30760
30761   if (FLOAT_CLASS_P (class1) != FLOAT_CLASS_P (class2))
30762     return true;
30763
30764   /* ??? This is a lie.  We do have moves between mmx/general, and for
30765      mmx/sse2.  But by saying we need secondary memory we discourage the
30766      register allocator from using the mmx registers unless needed.  */
30767   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2))
30768     return true;
30769
30770   if (SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
30771     {
30772       /* SSE1 doesn't have any direct moves from other classes.  */
30773       if (!TARGET_SSE2)
30774         return true;
30775
30776       /* If the target says that inter-unit moves are more expensive
30777          than moving through memory, then don't generate them.  */
30778       if (!TARGET_INTER_UNIT_MOVES)
30779         return true;
30780
30781       /* Between SSE and general, we have moves no larger than word size.  */
30782       if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
30783         return true;
30784     }
30785
30786   return false;
30787 }
30788
30789 bool
30790 ix86_secondary_memory_needed (enum reg_class class1, enum reg_class class2,
30791                               enum machine_mode mode, int strict)
30792 {
30793   return inline_secondary_memory_needed (class1, class2, mode, strict);
30794 }
30795
30796 /* Implement the TARGET_CLASS_MAX_NREGS hook.
30797
30798    On the 80386, this is the size of MODE in words,
30799    except in the FP regs, where a single reg is always enough.  */
30800
30801 static unsigned char
30802 ix86_class_max_nregs (reg_class_t rclass, enum machine_mode mode)
30803 {
30804   if (MAYBE_INTEGER_CLASS_P (rclass))
30805     {
30806       if (mode == XFmode)
30807         return (TARGET_64BIT ? 2 : 3);
30808       else if (mode == XCmode)
30809         return (TARGET_64BIT ? 4 : 6);
30810       else
30811         return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
30812     }
30813   else
30814     {
30815       if (COMPLEX_MODE_P (mode))
30816         return 2;
30817       else
30818         return 1;
30819     }
30820 }
30821
30822 /* Return true if the registers in CLASS cannot represent the change from
30823    modes FROM to TO.  */
30824
30825 bool
30826 ix86_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
30827                                enum reg_class regclass)
30828 {
30829   if (from == to)
30830     return false;
30831
30832   /* x87 registers can't do subreg at all, as all values are reformatted
30833      to extended precision.  */
30834   if (MAYBE_FLOAT_CLASS_P (regclass))
30835     return true;
30836
30837   if (MAYBE_SSE_CLASS_P (regclass) || MAYBE_MMX_CLASS_P (regclass))
30838     {
30839       /* Vector registers do not support QI or HImode loads.  If we don't
30840          disallow a change to these modes, reload will assume it's ok to
30841          drop the subreg from (subreg:SI (reg:HI 100) 0).  This affects
30842          the vec_dupv4hi pattern.  */
30843       if (GET_MODE_SIZE (from) < 4)
30844         return true;
30845
30846       /* Vector registers do not support subreg with nonzero offsets, which
30847          are otherwise valid for integer registers.  Since we can't see
30848          whether we have a nonzero offset from here, prohibit all
30849          nonparadoxical subregs changing size.  */
30850       if (GET_MODE_SIZE (to) < GET_MODE_SIZE (from))
30851         return true;
30852     }
30853
30854   return false;
30855 }
30856
30857 /* Return the cost of moving data of mode M between a
30858    register and memory.  A value of 2 is the default; this cost is
30859    relative to those in `REGISTER_MOVE_COST'.
30860
30861    This function is used extensively by register_move_cost that is used to
30862    build tables at startup.  Make it inline in this case.
30863    When IN is 2, return maximum of in and out move cost.
30864
30865    If moving between registers and memory is more expensive than
30866    between two registers, you should define this macro to express the
30867    relative cost.
30868
30869    Model also increased moving costs of QImode registers in non
30870    Q_REGS classes.
30871  */
30872 static inline int
30873 inline_memory_move_cost (enum machine_mode mode, enum reg_class regclass,
30874                          int in)
30875 {
30876   int cost;
30877   if (FLOAT_CLASS_P (regclass))
30878     {
30879       int index;
30880       switch (mode)
30881         {
30882           case SFmode:
30883             index = 0;
30884             break;
30885           case DFmode:
30886             index = 1;
30887             break;
30888           case XFmode:
30889             index = 2;
30890             break;
30891           default:
30892             return 100;
30893         }
30894       if (in == 2)
30895         return MAX (ix86_cost->fp_load [index], ix86_cost->fp_store [index]);
30896       return in ? ix86_cost->fp_load [index] : ix86_cost->fp_store [index];
30897     }
30898   if (SSE_CLASS_P (regclass))
30899     {
30900       int index;
30901       switch (GET_MODE_SIZE (mode))
30902         {
30903           case 4:
30904             index = 0;
30905             break;
30906           case 8:
30907             index = 1;
30908             break;
30909           case 16:
30910             index = 2;
30911             break;
30912           default:
30913             return 100;
30914         }
30915       if (in == 2)
30916         return MAX (ix86_cost->sse_load [index], ix86_cost->sse_store [index]);
30917       return in ? ix86_cost->sse_load [index] : ix86_cost->sse_store [index];
30918     }
30919   if (MMX_CLASS_P (regclass))
30920     {
30921       int index;
30922       switch (GET_MODE_SIZE (mode))
30923         {
30924           case 4:
30925             index = 0;
30926             break;
30927           case 8:
30928             index = 1;
30929             break;
30930           default:
30931             return 100;
30932         }
30933       if (in)
30934         return MAX (ix86_cost->mmx_load [index], ix86_cost->mmx_store [index]);
30935       return in ? ix86_cost->mmx_load [index] : ix86_cost->mmx_store [index];
30936     }
30937   switch (GET_MODE_SIZE (mode))
30938     {
30939       case 1:
30940         if (Q_CLASS_P (regclass) || TARGET_64BIT)
30941           {
30942             if (!in)
30943               return ix86_cost->int_store[0];
30944             if (TARGET_PARTIAL_REG_DEPENDENCY
30945                 && optimize_function_for_speed_p (cfun))
30946               cost = ix86_cost->movzbl_load;
30947             else
30948               cost = ix86_cost->int_load[0];
30949             if (in == 2)
30950               return MAX (cost, ix86_cost->int_store[0]);
30951             return cost;
30952           }
30953         else
30954           {
30955            if (in == 2)
30956              return MAX (ix86_cost->movzbl_load, ix86_cost->int_store[0] + 4);
30957            if (in)
30958              return ix86_cost->movzbl_load;
30959            else
30960              return ix86_cost->int_store[0] + 4;
30961           }
30962         break;
30963       case 2:
30964         if (in == 2)
30965           return MAX (ix86_cost->int_load[1], ix86_cost->int_store[1]);
30966         return in ? ix86_cost->int_load[1] : ix86_cost->int_store[1];
30967       default:
30968         /* Compute number of 32bit moves needed.  TFmode is moved as XFmode.  */
30969         if (mode == TFmode)
30970           mode = XFmode;
30971         if (in == 2)
30972           cost = MAX (ix86_cost->int_load[2] , ix86_cost->int_store[2]);
30973         else if (in)
30974           cost = ix86_cost->int_load[2];
30975         else
30976           cost = ix86_cost->int_store[2];
30977         return (cost * (((int) GET_MODE_SIZE (mode)
30978                         + UNITS_PER_WORD - 1) / UNITS_PER_WORD));
30979     }
30980 }
30981
30982 static int
30983 ix86_memory_move_cost (enum machine_mode mode, reg_class_t regclass,
30984                        bool in)
30985 {
30986   return inline_memory_move_cost (mode, (enum reg_class) regclass, in ? 1 : 0);
30987 }
30988
30989
30990 /* Return the cost of moving data from a register in class CLASS1 to
30991    one in class CLASS2.
30992
30993    It is not required that the cost always equal 2 when FROM is the same as TO;
30994    on some machines it is expensive to move between registers if they are not
30995    general registers.  */
30996
30997 static int
30998 ix86_register_move_cost (enum machine_mode mode, reg_class_t class1_i,
30999                          reg_class_t class2_i)
31000 {
31001   enum reg_class class1 = (enum reg_class) class1_i;
31002   enum reg_class class2 = (enum reg_class) class2_i;
31003
31004   /* In case we require secondary memory, compute cost of the store followed
31005      by load.  In order to avoid bad register allocation choices, we need
31006      for this to be *at least* as high as the symmetric MEMORY_MOVE_COST.  */
31007
31008   if (inline_secondary_memory_needed (class1, class2, mode, 0))
31009     {
31010       int cost = 1;
31011
31012       cost += inline_memory_move_cost (mode, class1, 2);
31013       cost += inline_memory_move_cost (mode, class2, 2);
31014
31015       /* In case of copying from general_purpose_register we may emit multiple
31016          stores followed by single load causing memory size mismatch stall.
31017          Count this as arbitrarily high cost of 20.  */
31018       if (targetm.class_max_nregs (class1, mode)
31019           > targetm.class_max_nregs (class2, mode))
31020         cost += 20;
31021
31022       /* In the case of FP/MMX moves, the registers actually overlap, and we
31023          have to switch modes in order to treat them differently.  */
31024       if ((MMX_CLASS_P (class1) && MAYBE_FLOAT_CLASS_P (class2))
31025           || (MMX_CLASS_P (class2) && MAYBE_FLOAT_CLASS_P (class1)))
31026         cost += 20;
31027
31028       return cost;
31029     }
31030
31031   /* Moves between SSE/MMX and integer unit are expensive.  */
31032   if (MMX_CLASS_P (class1) != MMX_CLASS_P (class2)
31033       || SSE_CLASS_P (class1) != SSE_CLASS_P (class2))
31034
31035     /* ??? By keeping returned value relatively high, we limit the number
31036        of moves between integer and MMX/SSE registers for all targets.
31037        Additionally, high value prevents problem with x86_modes_tieable_p(),
31038        where integer modes in MMX/SSE registers are not tieable
31039        because of missing QImode and HImode moves to, from or between
31040        MMX/SSE registers.  */
31041     return MAX (8, ix86_cost->mmxsse_to_integer);
31042
31043   if (MAYBE_FLOAT_CLASS_P (class1))
31044     return ix86_cost->fp_move;
31045   if (MAYBE_SSE_CLASS_P (class1))
31046     return ix86_cost->sse_move;
31047   if (MAYBE_MMX_CLASS_P (class1))
31048     return ix86_cost->mmx_move;
31049   return 2;
31050 }
31051
31052 /* Return TRUE if hard register REGNO can hold a value of machine-mode
31053    MODE.  */
31054
31055 bool
31056 ix86_hard_regno_mode_ok (int regno, enum machine_mode mode)
31057 {
31058   /* Flags and only flags can only hold CCmode values.  */
31059   if (CC_REGNO_P (regno))
31060     return GET_MODE_CLASS (mode) == MODE_CC;
31061   if (GET_MODE_CLASS (mode) == MODE_CC
31062       || GET_MODE_CLASS (mode) == MODE_RANDOM
31063       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
31064     return false;
31065   if (FP_REGNO_P (regno))
31066     return VALID_FP_MODE_P (mode);
31067   if (SSE_REGNO_P (regno))
31068     {
31069       /* We implement the move patterns for all vector modes into and
31070          out of SSE registers, even when no operation instructions
31071          are available.  OImode move is available only when AVX is
31072          enabled.  */
31073       return ((TARGET_AVX && mode == OImode)
31074               || VALID_AVX256_REG_MODE (mode)
31075               || VALID_SSE_REG_MODE (mode)
31076               || VALID_SSE2_REG_MODE (mode)
31077               || VALID_MMX_REG_MODE (mode)
31078               || VALID_MMX_REG_MODE_3DNOW (mode));
31079     }
31080   if (MMX_REGNO_P (regno))
31081     {
31082       /* We implement the move patterns for 3DNOW modes even in MMX mode,
31083          so if the register is available at all, then we can move data of
31084          the given mode into or out of it.  */
31085       return (VALID_MMX_REG_MODE (mode)
31086               || VALID_MMX_REG_MODE_3DNOW (mode));
31087     }
31088
31089   if (mode == QImode)
31090     {
31091       /* Take care for QImode values - they can be in non-QI regs,
31092          but then they do cause partial register stalls.  */
31093       if (regno <= BX_REG || TARGET_64BIT)
31094         return true;
31095       if (!TARGET_PARTIAL_REG_STALL)
31096         return true;
31097       return !can_create_pseudo_p ();
31098     }
31099   /* We handle both integer and floats in the general purpose registers.  */
31100   else if (VALID_INT_MODE_P (mode))
31101     return true;
31102   else if (VALID_FP_MODE_P (mode))
31103     return true;
31104   else if (VALID_DFP_MODE_P (mode))
31105     return true;
31106   /* Lots of MMX code casts 8 byte vector modes to DImode.  If we then go
31107      on to use that value in smaller contexts, this can easily force a
31108      pseudo to be allocated to GENERAL_REGS.  Since this is no worse than
31109      supporting DImode, allow it.  */
31110   else if (VALID_MMX_REG_MODE_3DNOW (mode) || VALID_MMX_REG_MODE (mode))
31111     return true;
31112
31113   return false;
31114 }
31115
31116 /* A subroutine of ix86_modes_tieable_p.  Return true if MODE is a
31117    tieable integer mode.  */
31118
31119 static bool
31120 ix86_tieable_integer_mode_p (enum machine_mode mode)
31121 {
31122   switch (mode)
31123     {
31124     case HImode:
31125     case SImode:
31126       return true;
31127
31128     case QImode:
31129       return TARGET_64BIT || !TARGET_PARTIAL_REG_STALL;
31130
31131     case DImode:
31132       return TARGET_64BIT;
31133
31134     default:
31135       return false;
31136     }
31137 }
31138
31139 /* Return true if MODE1 is accessible in a register that can hold MODE2
31140    without copying.  That is, all register classes that can hold MODE2
31141    can also hold MODE1.  */
31142
31143 bool
31144 ix86_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
31145 {
31146   if (mode1 == mode2)
31147     return true;
31148
31149   if (ix86_tieable_integer_mode_p (mode1)
31150       && ix86_tieable_integer_mode_p (mode2))
31151     return true;
31152
31153   /* MODE2 being XFmode implies fp stack or general regs, which means we
31154      can tie any smaller floating point modes to it.  Note that we do not
31155      tie this with TFmode.  */
31156   if (mode2 == XFmode)
31157     return mode1 == SFmode || mode1 == DFmode;
31158
31159   /* MODE2 being DFmode implies fp stack, general or sse regs, which means
31160      that we can tie it with SFmode.  */
31161   if (mode2 == DFmode)
31162     return mode1 == SFmode;
31163
31164   /* If MODE2 is only appropriate for an SSE register, then tie with
31165      any other mode acceptable to SSE registers.  */
31166   if (GET_MODE_SIZE (mode2) == 16
31167       && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode2))
31168     return (GET_MODE_SIZE (mode1) == 16
31169             && ix86_hard_regno_mode_ok (FIRST_SSE_REG, mode1));
31170
31171   /* If MODE2 is appropriate for an MMX register, then tie
31172      with any other mode acceptable to MMX registers.  */
31173   if (GET_MODE_SIZE (mode2) == 8
31174       && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode2))
31175     return (GET_MODE_SIZE (mode1) == 8
31176             && ix86_hard_regno_mode_ok (FIRST_MMX_REG, mode1));
31177
31178   return false;
31179 }
31180
31181 /* Compute a (partial) cost for rtx X.  Return true if the complete
31182    cost has been computed, and false if subexpressions should be
31183    scanned.  In either case, *TOTAL contains the cost result.  */
31184
31185 static bool
31186 ix86_rtx_costs (rtx x, int code, int outer_code_i, int opno, int *total,
31187                 bool speed)
31188 {
31189   enum rtx_code outer_code = (enum rtx_code) outer_code_i;
31190   enum machine_mode mode = GET_MODE (x);
31191   const struct processor_costs *cost = speed ? ix86_cost : &ix86_size_cost;
31192
31193   switch (code)
31194     {
31195     case CONST_INT:
31196     case CONST:
31197     case LABEL_REF:
31198     case SYMBOL_REF:
31199       if (TARGET_64BIT && !x86_64_immediate_operand (x, VOIDmode))
31200         *total = 3;
31201       else if (TARGET_64BIT && !x86_64_zext_immediate_operand (x, VOIDmode))
31202         *total = 2;
31203       else if (flag_pic && SYMBOLIC_CONST (x)
31204                && (!TARGET_64BIT
31205                    || (!GET_CODE (x) != LABEL_REF
31206                        && (GET_CODE (x) != SYMBOL_REF
31207                            || !SYMBOL_REF_LOCAL_P (x)))))
31208         *total = 1;
31209       else
31210         *total = 0;
31211       return true;
31212
31213     case CONST_DOUBLE:
31214       if (mode == VOIDmode)
31215         *total = 0;
31216       else
31217         switch (standard_80387_constant_p (x))
31218           {
31219           case 1: /* 0.0 */
31220             *total = 1;
31221             break;
31222           default: /* Other constants */
31223             *total = 2;
31224             break;
31225           case 0:
31226           case -1:
31227             /* Start with (MEM (SYMBOL_REF)), since that's where
31228                it'll probably end up.  Add a penalty for size.  */
31229             *total = (COSTS_N_INSNS (1)
31230                       + (flag_pic != 0 && !TARGET_64BIT)
31231                       + (mode == SFmode ? 0 : mode == DFmode ? 1 : 2));
31232             break;
31233           }
31234       return true;
31235
31236     case ZERO_EXTEND:
31237       /* The zero extensions is often completely free on x86_64, so make
31238          it as cheap as possible.  */
31239       if (TARGET_64BIT && mode == DImode
31240           && GET_MODE (XEXP (x, 0)) == SImode)
31241         *total = 1;
31242       else if (TARGET_ZERO_EXTEND_WITH_AND)
31243         *total = cost->add;
31244       else
31245         *total = cost->movzx;
31246       return false;
31247
31248     case SIGN_EXTEND:
31249       *total = cost->movsx;
31250       return false;
31251
31252     case ASHIFT:
31253       if (CONST_INT_P (XEXP (x, 1))
31254           && (GET_MODE (XEXP (x, 0)) != DImode || TARGET_64BIT))
31255         {
31256           HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
31257           if (value == 1)
31258             {
31259               *total = cost->add;
31260               return false;
31261             }
31262           if ((value == 2 || value == 3)
31263               && cost->lea <= cost->shift_const)
31264             {
31265               *total = cost->lea;
31266               return false;
31267             }
31268         }
31269       /* FALLTHRU */
31270
31271     case ROTATE:
31272     case ASHIFTRT:
31273     case LSHIFTRT:
31274     case ROTATERT:
31275       if (!TARGET_64BIT && GET_MODE (XEXP (x, 0)) == DImode)
31276         {
31277           if (CONST_INT_P (XEXP (x, 1)))
31278             {
31279               if (INTVAL (XEXP (x, 1)) > 32)
31280                 *total = cost->shift_const + COSTS_N_INSNS (2);
31281               else
31282                 *total = cost->shift_const * 2;
31283             }
31284           else
31285             {
31286               if (GET_CODE (XEXP (x, 1)) == AND)
31287                 *total = cost->shift_var * 2;
31288               else
31289                 *total = cost->shift_var * 6 + COSTS_N_INSNS (2);
31290             }
31291         }
31292       else
31293         {
31294           if (CONST_INT_P (XEXP (x, 1)))
31295             *total = cost->shift_const;
31296           else
31297             *total = cost->shift_var;
31298         }
31299       return false;
31300
31301     case FMA:
31302       {
31303         rtx sub;
31304
31305         gcc_assert (FLOAT_MODE_P (mode));
31306         gcc_assert (TARGET_FMA || TARGET_FMA4);
31307
31308         /* ??? SSE scalar/vector cost should be used here.  */
31309         /* ??? Bald assumption that fma has the same cost as fmul.  */
31310         *total = cost->fmul;
31311         *total += rtx_cost (XEXP (x, 1), FMA, 1, speed);
31312
31313         /* Negate in op0 or op2 is free: FMS, FNMA, FNMS.  */
31314         sub = XEXP (x, 0);
31315         if (GET_CODE (sub) == NEG)
31316           sub = XEXP (sub, 0);
31317         *total += rtx_cost (sub, FMA, 0, speed);
31318
31319         sub = XEXP (x, 2);
31320         if (GET_CODE (sub) == NEG)
31321           sub = XEXP (sub, 0);
31322         *total += rtx_cost (sub, FMA, 2, speed);
31323         return true;
31324       }
31325
31326     case MULT:
31327       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31328         {
31329           /* ??? SSE scalar cost should be used here.  */
31330           *total = cost->fmul;
31331           return false;
31332         }
31333       else if (X87_FLOAT_MODE_P (mode))
31334         {
31335           *total = cost->fmul;
31336           return false;
31337         }
31338       else if (FLOAT_MODE_P (mode))
31339         {
31340           /* ??? SSE vector cost should be used here.  */
31341           *total = cost->fmul;
31342           return false;
31343         }
31344       else
31345         {
31346           rtx op0 = XEXP (x, 0);
31347           rtx op1 = XEXP (x, 1);
31348           int nbits;
31349           if (CONST_INT_P (XEXP (x, 1)))
31350             {
31351               unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
31352               for (nbits = 0; value != 0; value &= value - 1)
31353                 nbits++;
31354             }
31355           else
31356             /* This is arbitrary.  */
31357             nbits = 7;
31358
31359           /* Compute costs correctly for widening multiplication.  */
31360           if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
31361               && GET_MODE_SIZE (GET_MODE (XEXP (op0, 0))) * 2
31362                  == GET_MODE_SIZE (mode))
31363             {
31364               int is_mulwiden = 0;
31365               enum machine_mode inner_mode = GET_MODE (op0);
31366
31367               if (GET_CODE (op0) == GET_CODE (op1))
31368                 is_mulwiden = 1, op1 = XEXP (op1, 0);
31369               else if (CONST_INT_P (op1))
31370                 {
31371                   if (GET_CODE (op0) == SIGN_EXTEND)
31372                     is_mulwiden = trunc_int_for_mode (INTVAL (op1), inner_mode)
31373                                   == INTVAL (op1);
31374                   else
31375                     is_mulwiden = !(INTVAL (op1) & ~GET_MODE_MASK (inner_mode));
31376                 }
31377
31378               if (is_mulwiden)
31379                 op0 = XEXP (op0, 0), mode = GET_MODE (op0);
31380             }
31381
31382           *total = (cost->mult_init[MODE_INDEX (mode)]
31383                     + nbits * cost->mult_bit
31384                     + rtx_cost (op0, outer_code, opno, speed)
31385                     + rtx_cost (op1, outer_code, opno, speed));
31386
31387           return true;
31388         }
31389
31390     case DIV:
31391     case UDIV:
31392     case MOD:
31393     case UMOD:
31394       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31395         /* ??? SSE cost should be used here.  */
31396         *total = cost->fdiv;
31397       else if (X87_FLOAT_MODE_P (mode))
31398         *total = cost->fdiv;
31399       else if (FLOAT_MODE_P (mode))
31400         /* ??? SSE vector cost should be used here.  */
31401         *total = cost->fdiv;
31402       else
31403         *total = cost->divide[MODE_INDEX (mode)];
31404       return false;
31405
31406     case PLUS:
31407       if (GET_MODE_CLASS (mode) == MODE_INT
31408                && GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (Pmode))
31409         {
31410           if (GET_CODE (XEXP (x, 0)) == PLUS
31411               && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
31412               && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
31413               && CONSTANT_P (XEXP (x, 1)))
31414             {
31415               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1));
31416               if (val == 2 || val == 4 || val == 8)
31417                 {
31418                   *total = cost->lea;
31419                   *total += rtx_cost (XEXP (XEXP (x, 0), 1),
31420                                       outer_code, opno, speed);
31421                   *total += rtx_cost (XEXP (XEXP (XEXP (x, 0), 0), 0),
31422                                       outer_code, opno, speed);
31423                   *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
31424                   return true;
31425                 }
31426             }
31427           else if (GET_CODE (XEXP (x, 0)) == MULT
31428                    && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
31429             {
31430               HOST_WIDE_INT val = INTVAL (XEXP (XEXP (x, 0), 1));
31431               if (val == 2 || val == 4 || val == 8)
31432                 {
31433                   *total = cost->lea;
31434                   *total += rtx_cost (XEXP (XEXP (x, 0), 0),
31435                                       outer_code, opno, speed);
31436                   *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
31437                   return true;
31438                 }
31439             }
31440           else if (GET_CODE (XEXP (x, 0)) == PLUS)
31441             {
31442               *total = cost->lea;
31443               *total += rtx_cost (XEXP (XEXP (x, 0), 0),
31444                                   outer_code, opno, speed);
31445               *total += rtx_cost (XEXP (XEXP (x, 0), 1),
31446                                   outer_code, opno, speed);
31447               *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
31448               return true;
31449             }
31450         }
31451       /* FALLTHRU */
31452
31453     case MINUS:
31454       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31455         {
31456           /* ??? SSE cost should be used here.  */
31457           *total = cost->fadd;
31458           return false;
31459         }
31460       else if (X87_FLOAT_MODE_P (mode))
31461         {
31462           *total = cost->fadd;
31463           return false;
31464         }
31465       else if (FLOAT_MODE_P (mode))
31466         {
31467           /* ??? SSE vector cost should be used here.  */
31468           *total = cost->fadd;
31469           return false;
31470         }
31471       /* FALLTHRU */
31472
31473     case AND:
31474     case IOR:
31475     case XOR:
31476       if (!TARGET_64BIT && mode == DImode)
31477         {
31478           *total = (cost->add * 2
31479                     + (rtx_cost (XEXP (x, 0), outer_code, opno, speed)
31480                        << (GET_MODE (XEXP (x, 0)) != DImode))
31481                     + (rtx_cost (XEXP (x, 1), outer_code, opno, speed)
31482                        << (GET_MODE (XEXP (x, 1)) != DImode)));
31483           return true;
31484         }
31485       /* FALLTHRU */
31486
31487     case NEG:
31488       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31489         {
31490           /* ??? SSE cost should be used here.  */
31491           *total = cost->fchs;
31492           return false;
31493         }
31494       else if (X87_FLOAT_MODE_P (mode))
31495         {
31496           *total = cost->fchs;
31497           return false;
31498         }
31499       else if (FLOAT_MODE_P (mode))
31500         {
31501           /* ??? SSE vector cost should be used here.  */
31502           *total = cost->fchs;
31503           return false;
31504         }
31505       /* FALLTHRU */
31506
31507     case NOT:
31508       if (!TARGET_64BIT && mode == DImode)
31509         *total = cost->add * 2;
31510       else
31511         *total = cost->add;
31512       return false;
31513
31514     case COMPARE:
31515       if (GET_CODE (XEXP (x, 0)) == ZERO_EXTRACT
31516           && XEXP (XEXP (x, 0), 1) == const1_rtx
31517           && CONST_INT_P (XEXP (XEXP (x, 0), 2))
31518           && XEXP (x, 1) == const0_rtx)
31519         {
31520           /* This kind of construct is implemented using test[bwl].
31521              Treat it as if we had an AND.  */
31522           *total = (cost->add
31523                     + rtx_cost (XEXP (XEXP (x, 0), 0), outer_code, opno, speed)
31524                     + rtx_cost (const1_rtx, outer_code, opno, speed));
31525           return true;
31526         }
31527       return false;
31528
31529     case FLOAT_EXTEND:
31530       if (!(SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH))
31531         *total = 0;
31532       return false;
31533
31534     case ABS:
31535       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31536         /* ??? SSE cost should be used here.  */
31537         *total = cost->fabs;
31538       else if (X87_FLOAT_MODE_P (mode))
31539         *total = cost->fabs;
31540       else if (FLOAT_MODE_P (mode))
31541         /* ??? SSE vector cost should be used here.  */
31542         *total = cost->fabs;
31543       return false;
31544
31545     case SQRT:
31546       if (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)
31547         /* ??? SSE cost should be used here.  */
31548         *total = cost->fsqrt;
31549       else if (X87_FLOAT_MODE_P (mode))
31550         *total = cost->fsqrt;
31551       else if (FLOAT_MODE_P (mode))
31552         /* ??? SSE vector cost should be used here.  */
31553         *total = cost->fsqrt;
31554       return false;
31555
31556     case UNSPEC:
31557       if (XINT (x, 1) == UNSPEC_TP)
31558         *total = 0;
31559       return false;
31560
31561     case VEC_SELECT:
31562     case VEC_CONCAT:
31563     case VEC_MERGE:
31564     case VEC_DUPLICATE:
31565       /* ??? Assume all of these vector manipulation patterns are
31566          recognizable.  In which case they all pretty much have the
31567          same cost.  */
31568      *total = COSTS_N_INSNS (1);
31569      return true;
31570
31571     default:
31572       return false;
31573     }
31574 }
31575
31576 #if TARGET_MACHO
31577
31578 static int current_machopic_label_num;
31579
31580 /* Given a symbol name and its associated stub, write out the
31581    definition of the stub.  */
31582
31583 void
31584 machopic_output_stub (FILE *file, const char *symb, const char *stub)
31585 {
31586   unsigned int length;
31587   char *binder_name, *symbol_name, lazy_ptr_name[32];
31588   int label = ++current_machopic_label_num;
31589
31590   /* For 64-bit we shouldn't get here.  */
31591   gcc_assert (!TARGET_64BIT);
31592
31593   /* Lose our funky encoding stuff so it doesn't contaminate the stub.  */
31594   symb = targetm.strip_name_encoding (symb);
31595
31596   length = strlen (stub);
31597   binder_name = XALLOCAVEC (char, length + 32);
31598   GEN_BINDER_NAME_FOR_STUB (binder_name, stub, length);
31599
31600   length = strlen (symb);
31601   symbol_name = XALLOCAVEC (char, length + 32);
31602   GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
31603
31604   sprintf (lazy_ptr_name, "L%d$lz", label);
31605
31606   if (MACHOPIC_ATT_STUB)
31607     switch_to_section (darwin_sections[machopic_picsymbol_stub3_section]);
31608   else if (MACHOPIC_PURE)
31609     switch_to_section (darwin_sections[machopic_picsymbol_stub2_section]);
31610   else
31611     switch_to_section (darwin_sections[machopic_symbol_stub_section]);
31612
31613   fprintf (file, "%s:\n", stub);
31614   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
31615
31616   if (MACHOPIC_ATT_STUB)
31617     {
31618       fprintf (file, "\thlt ; hlt ; hlt ; hlt ; hlt\n");
31619     }
31620   else if (MACHOPIC_PURE)
31621     {
31622       /* PIC stub.  */
31623       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
31624       rtx tmp = gen_rtx_REG (SImode, 2 /* ECX */);
31625       output_set_got (tmp, NULL_RTX);   /* "CALL ___<cpu>.get_pc_thunk.cx".  */
31626       fprintf (file, "LPC$%d:\tmovl\t%s-LPC$%d(%%ecx),%%ecx\n",
31627                label, lazy_ptr_name, label);
31628       fprintf (file, "\tjmp\t*%%ecx\n");
31629     }
31630   else
31631     fprintf (file, "\tjmp\t*%s\n", lazy_ptr_name);
31632
31633   /* The AT&T-style ("self-modifying") stub is not lazily bound, thus
31634      it needs no stub-binding-helper.  */
31635   if (MACHOPIC_ATT_STUB)
31636     return;
31637
31638   fprintf (file, "%s:\n", binder_name);
31639
31640   if (MACHOPIC_PURE)
31641     {
31642       fprintf (file, "\tlea\t%s-%s(%%ecx),%%ecx\n", lazy_ptr_name, binder_name);
31643       fprintf (file, "\tpushl\t%%ecx\n");
31644     }
31645   else
31646     fprintf (file, "\tpushl\t$%s\n", lazy_ptr_name);
31647
31648   fputs ("\tjmp\tdyld_stub_binding_helper\n", file);
31649
31650   /* N.B. Keep the correspondence of these
31651      'symbol_ptr/symbol_ptr2/symbol_ptr3' sections consistent with the
31652      old-pic/new-pic/non-pic stubs; altering this will break
31653      compatibility with existing dylibs.  */
31654   if (MACHOPIC_PURE)
31655     {
31656       /* 25-byte PIC stub using "CALL get_pc_thunk".  */
31657       switch_to_section (darwin_sections[machopic_lazy_symbol_ptr2_section]);
31658     }
31659   else
31660     /* 16-byte -mdynamic-no-pic stub.  */
31661     switch_to_section(darwin_sections[machopic_lazy_symbol_ptr3_section]);
31662
31663   fprintf (file, "%s:\n", lazy_ptr_name);
31664   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
31665   fprintf (file, ASM_LONG "%s\n", binder_name);
31666 }
31667 #endif /* TARGET_MACHO */
31668
31669 /* Order the registers for register allocator.  */
31670
31671 void
31672 x86_order_regs_for_local_alloc (void)
31673 {
31674    int pos = 0;
31675    int i;
31676
31677    /* First allocate the local general purpose registers.  */
31678    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
31679      if (GENERAL_REGNO_P (i) && call_used_regs[i])
31680         reg_alloc_order [pos++] = i;
31681
31682    /* Global general purpose registers.  */
31683    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
31684      if (GENERAL_REGNO_P (i) && !call_used_regs[i])
31685         reg_alloc_order [pos++] = i;
31686
31687    /* x87 registers come first in case we are doing FP math
31688       using them.  */
31689    if (!TARGET_SSE_MATH)
31690      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
31691        reg_alloc_order [pos++] = i;
31692
31693    /* SSE registers.  */
31694    for (i = FIRST_SSE_REG; i <= LAST_SSE_REG; i++)
31695      reg_alloc_order [pos++] = i;
31696    for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++)
31697      reg_alloc_order [pos++] = i;
31698
31699    /* x87 registers.  */
31700    if (TARGET_SSE_MATH)
31701      for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
31702        reg_alloc_order [pos++] = i;
31703
31704    for (i = FIRST_MMX_REG; i <= LAST_MMX_REG; i++)
31705      reg_alloc_order [pos++] = i;
31706
31707    /* Initialize the rest of array as we do not allocate some registers
31708       at all.  */
31709    while (pos < FIRST_PSEUDO_REGISTER)
31710      reg_alloc_order [pos++] = 0;
31711 }
31712
31713 /* Handle a "callee_pop_aggregate_return" attribute; arguments as
31714    in struct attribute_spec handler.  */
31715 static tree
31716 ix86_handle_callee_pop_aggregate_return (tree *node, tree name,
31717                                               tree args,
31718                                               int flags ATTRIBUTE_UNUSED,
31719                                               bool *no_add_attrs)
31720 {
31721   if (TREE_CODE (*node) != FUNCTION_TYPE
31722       && TREE_CODE (*node) != METHOD_TYPE
31723       && TREE_CODE (*node) != FIELD_DECL
31724       && TREE_CODE (*node) != TYPE_DECL)
31725     {
31726       warning (OPT_Wattributes, "%qE attribute only applies to functions",
31727                name);
31728       *no_add_attrs = true;
31729       return NULL_TREE;
31730     }
31731   if (TARGET_64BIT)
31732     {
31733       warning (OPT_Wattributes, "%qE attribute only available for 32-bit",
31734                name);
31735       *no_add_attrs = true;
31736       return NULL_TREE;
31737     }
31738   if (is_attribute_p ("callee_pop_aggregate_return", name))
31739     {
31740       tree cst;
31741
31742       cst = TREE_VALUE (args);
31743       if (TREE_CODE (cst) != INTEGER_CST)
31744         {
31745           warning (OPT_Wattributes,
31746                    "%qE attribute requires an integer constant argument",
31747                    name);
31748           *no_add_attrs = true;
31749         }
31750       else if (compare_tree_int (cst, 0) != 0
31751                && compare_tree_int (cst, 1) != 0)
31752         {
31753           warning (OPT_Wattributes,
31754                    "argument to %qE attribute is neither zero, nor one",
31755                    name);
31756           *no_add_attrs = true;
31757         }
31758
31759       return NULL_TREE;
31760     }
31761
31762   return NULL_TREE;
31763 }
31764
31765 /* Handle a "ms_abi" or "sysv" attribute; arguments as in
31766    struct attribute_spec.handler.  */
31767 static tree
31768 ix86_handle_abi_attribute (tree *node, tree name,
31769                               tree args ATTRIBUTE_UNUSED,
31770                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
31771 {
31772   if (TREE_CODE (*node) != FUNCTION_TYPE
31773       && TREE_CODE (*node) != METHOD_TYPE
31774       && TREE_CODE (*node) != FIELD_DECL
31775       && TREE_CODE (*node) != TYPE_DECL)
31776     {
31777       warning (OPT_Wattributes, "%qE attribute only applies to functions",
31778                name);
31779       *no_add_attrs = true;
31780       return NULL_TREE;
31781     }
31782
31783   /* Can combine regparm with all attributes but fastcall.  */
31784   if (is_attribute_p ("ms_abi", name))
31785     {
31786       if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
31787         {
31788           error ("ms_abi and sysv_abi attributes are not compatible");
31789         }
31790
31791       return NULL_TREE;
31792     }
31793   else if (is_attribute_p ("sysv_abi", name))
31794     {
31795       if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
31796         {
31797           error ("ms_abi and sysv_abi attributes are not compatible");
31798         }
31799
31800       return NULL_TREE;
31801     }
31802
31803   return NULL_TREE;
31804 }
31805
31806 /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
31807    struct attribute_spec.handler.  */
31808 static tree
31809 ix86_handle_struct_attribute (tree *node, tree name,
31810                               tree args ATTRIBUTE_UNUSED,
31811                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
31812 {
31813   tree *type = NULL;
31814   if (DECL_P (*node))
31815     {
31816       if (TREE_CODE (*node) == TYPE_DECL)
31817         type = &TREE_TYPE (*node);
31818     }
31819   else
31820     type = node;
31821
31822   if (!(type && (TREE_CODE (*type) == RECORD_TYPE
31823                  || TREE_CODE (*type) == UNION_TYPE)))
31824     {
31825       warning (OPT_Wattributes, "%qE attribute ignored",
31826                name);
31827       *no_add_attrs = true;
31828     }
31829
31830   else if ((is_attribute_p ("ms_struct", name)
31831             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
31832            || ((is_attribute_p ("gcc_struct", name)
31833                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
31834     {
31835       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
31836                name);
31837       *no_add_attrs = true;
31838     }
31839
31840   return NULL_TREE;
31841 }
31842
31843 static tree
31844 ix86_handle_fndecl_attribute (tree *node, tree name,
31845                               tree args ATTRIBUTE_UNUSED,
31846                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
31847 {
31848   if (TREE_CODE (*node) != FUNCTION_DECL)
31849     {
31850       warning (OPT_Wattributes, "%qE attribute only applies to functions",
31851                name);
31852       *no_add_attrs = true;
31853     }
31854   return NULL_TREE;
31855 }
31856
31857 static bool
31858 ix86_ms_bitfield_layout_p (const_tree record_type)
31859 {
31860   return ((TARGET_MS_BITFIELD_LAYOUT
31861            && !lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (record_type)))
31862           || lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (record_type)));
31863 }
31864
31865 /* Returns an expression indicating where the this parameter is
31866    located on entry to the FUNCTION.  */
31867
31868 static rtx
31869 x86_this_parameter (tree function)
31870 {
31871   tree type = TREE_TYPE (function);
31872   bool aggr = aggregate_value_p (TREE_TYPE (type), type) != 0;
31873   int nregs;
31874
31875   if (TARGET_64BIT)
31876     {
31877       const int *parm_regs;
31878
31879       if (ix86_function_type_abi (type) == MS_ABI)
31880         parm_regs = x86_64_ms_abi_int_parameter_registers;
31881       else
31882         parm_regs = x86_64_int_parameter_registers;
31883       return gen_rtx_REG (DImode, parm_regs[aggr]);
31884     }
31885
31886   nregs = ix86_function_regparm (type, function);
31887
31888   if (nregs > 0 && !stdarg_p (type))
31889     {
31890       int regno;
31891       unsigned int ccvt = ix86_get_callcvt (type);
31892
31893       if ((ccvt & IX86_CALLCVT_FASTCALL) != 0)
31894         regno = aggr ? DX_REG : CX_REG;
31895       else if ((ccvt & IX86_CALLCVT_THISCALL) != 0)
31896         {
31897           regno = CX_REG;
31898           if (aggr)
31899             return gen_rtx_MEM (SImode,
31900                                 plus_constant (stack_pointer_rtx, 4));
31901         }
31902       else
31903         {
31904           regno = AX_REG;
31905           if (aggr)
31906             {
31907               regno = DX_REG;
31908               if (nregs == 1)
31909                 return gen_rtx_MEM (SImode,
31910                                     plus_constant (stack_pointer_rtx, 4));
31911             }
31912         }
31913       return gen_rtx_REG (SImode, regno);
31914     }
31915
31916   return gen_rtx_MEM (SImode, plus_constant (stack_pointer_rtx, aggr ? 8 : 4));
31917 }
31918
31919 /* Determine whether x86_output_mi_thunk can succeed.  */
31920
31921 static bool
31922 x86_can_output_mi_thunk (const_tree thunk ATTRIBUTE_UNUSED,
31923                          HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
31924                          HOST_WIDE_INT vcall_offset, const_tree function)
31925 {
31926   /* 64-bit can handle anything.  */
31927   if (TARGET_64BIT)
31928     return true;
31929
31930   /* For 32-bit, everything's fine if we have one free register.  */
31931   if (ix86_function_regparm (TREE_TYPE (function), function) < 3)
31932     return true;
31933
31934   /* Need a free register for vcall_offset.  */
31935   if (vcall_offset)
31936     return false;
31937
31938   /* Need a free register for GOT references.  */
31939   if (flag_pic && !targetm.binds_local_p (function))
31940     return false;
31941
31942   /* Otherwise ok.  */
31943   return true;
31944 }
31945
31946 /* Output the assembler code for a thunk function.  THUNK_DECL is the
31947    declaration for the thunk function itself, FUNCTION is the decl for
31948    the target function.  DELTA is an immediate constant offset to be
31949    added to THIS.  If VCALL_OFFSET is nonzero, the word at
31950    *(*this + vcall_offset) should be added to THIS.  */
31951
31952 static void
31953 x86_output_mi_thunk (FILE *file,
31954                      tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
31955                      HOST_WIDE_INT vcall_offset, tree function)
31956 {
31957   rtx this_param = x86_this_parameter (function);
31958   rtx this_reg, tmp, fnaddr;
31959
31960   emit_note (NOTE_INSN_PROLOGUE_END);
31961
31962   /* If VCALL_OFFSET, we'll need THIS in a register.  Might as well
31963      pull it in now and let DELTA benefit.  */
31964   if (REG_P (this_param))
31965     this_reg = this_param;
31966   else if (vcall_offset)
31967     {
31968       /* Put the this parameter into %eax.  */
31969       this_reg = gen_rtx_REG (Pmode, AX_REG);
31970       emit_move_insn (this_reg, this_param);
31971     }
31972   else
31973     this_reg = NULL_RTX;
31974
31975   /* Adjust the this parameter by a fixed constant.  */
31976   if (delta)
31977     {
31978       rtx delta_rtx = GEN_INT (delta);
31979       rtx delta_dst = this_reg ? this_reg : this_param;
31980
31981       if (TARGET_64BIT)
31982         {
31983           if (!x86_64_general_operand (delta_rtx, Pmode))
31984             {
31985               tmp = gen_rtx_REG (Pmode, R10_REG);
31986               emit_move_insn (tmp, delta_rtx);
31987               delta_rtx = tmp;
31988             }
31989         }
31990
31991       ix86_emit_binop (PLUS, Pmode, delta_dst, delta_rtx);
31992     }
31993
31994   /* Adjust the this parameter by a value stored in the vtable.  */
31995   if (vcall_offset)
31996     {
31997       rtx vcall_addr, vcall_mem, this_mem;
31998       unsigned int tmp_regno;
31999
32000       if (TARGET_64BIT)
32001         tmp_regno = R10_REG;
32002       else
32003         {
32004           unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (function));
32005           if ((ccvt & (IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL)) != 0)
32006             tmp_regno = AX_REG;
32007           else
32008             tmp_regno = CX_REG;
32009         }
32010       tmp = gen_rtx_REG (Pmode, tmp_regno);
32011
32012       this_mem = gen_rtx_MEM (ptr_mode, this_reg);
32013       if (Pmode != ptr_mode)
32014         this_mem = gen_rtx_ZERO_EXTEND (Pmode, this_mem);
32015       emit_move_insn (tmp, this_mem);
32016
32017       /* Adjust the this parameter.  */
32018       vcall_addr = plus_constant (tmp, vcall_offset);
32019       if (TARGET_64BIT
32020           && !ix86_legitimate_address_p (ptr_mode, vcall_addr, true))
32021         {
32022           rtx tmp2 = gen_rtx_REG (Pmode, R11_REG);
32023           emit_move_insn (tmp2, GEN_INT (vcall_offset));
32024           vcall_addr = gen_rtx_PLUS (Pmode, tmp, tmp2);
32025         }
32026
32027       vcall_mem = gen_rtx_MEM (ptr_mode, vcall_addr);
32028       if (Pmode != ptr_mode)
32029         emit_insn (gen_addsi_1_zext (this_reg,
32030                                      gen_rtx_REG (ptr_mode,
32031                                                   REGNO (this_reg)),
32032                                      vcall_mem));
32033       else
32034         ix86_emit_binop (PLUS, Pmode, this_reg, vcall_mem);
32035     }
32036
32037   /* If necessary, drop THIS back to its stack slot.  */
32038   if (this_reg && this_reg != this_param)
32039     emit_move_insn (this_param, this_reg);
32040
32041   fnaddr = XEXP (DECL_RTL (function), 0);
32042   if (TARGET_64BIT)
32043     {
32044       if (!flag_pic || targetm.binds_local_p (function)
32045           || cfun->machine->call_abi == MS_ABI)
32046         ;
32047       else
32048         {
32049           tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOTPCREL);
32050           tmp = gen_rtx_CONST (Pmode, tmp);
32051           fnaddr = gen_rtx_MEM (Pmode, tmp);
32052         }
32053     }
32054   else
32055     {
32056       if (!flag_pic || targetm.binds_local_p (function))
32057         ;
32058 #if TARGET_MACHO
32059       else if (TARGET_MACHO)
32060         {
32061           fnaddr = machopic_indirect_call_target (DECL_RTL (function));
32062           fnaddr = XEXP (fnaddr, 0);
32063         }
32064 #endif /* TARGET_MACHO */
32065       else
32066         {
32067           tmp = gen_rtx_REG (Pmode, CX_REG);
32068           output_set_got (tmp, NULL_RTX);
32069
32070           fnaddr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, fnaddr), UNSPEC_GOT);
32071           fnaddr = gen_rtx_PLUS (Pmode, fnaddr, tmp);
32072           fnaddr = gen_rtx_MEM (Pmode, fnaddr);
32073         }
32074     }
32075
32076   /* Our sibling call patterns do not allow memories, because we have no
32077      predicate that can distinguish between frame and non-frame memory.
32078      For our purposes here, we can get away with (ab)using a jump pattern,
32079      because we're going to do no optimization.  */
32080   if (MEM_P (fnaddr))
32081     emit_jump_insn (gen_indirect_jump (fnaddr));
32082   else
32083     {
32084       tmp = gen_rtx_MEM (QImode, fnaddr);
32085       tmp = gen_rtx_CALL (VOIDmode, tmp, const0_rtx);
32086       tmp = emit_call_insn (tmp);
32087       SIBLING_CALL_P (tmp) = 1;
32088     }
32089   emit_barrier ();
32090
32091   /* Emit just enough of rest_of_compilation to get the insns emitted.
32092      Note that use_thunk calls assemble_start_function et al.  */
32093   tmp = get_insns ();
32094   insn_locators_alloc ();
32095   shorten_branches (tmp);
32096   final_start_function (tmp, file, 1);
32097   final (tmp, file, 1);
32098   final_end_function ();
32099 }
32100
32101 static void
32102 x86_file_start (void)
32103 {
32104   default_file_start ();
32105 #if TARGET_MACHO
32106   darwin_file_start ();
32107 #endif
32108   if (X86_FILE_START_VERSION_DIRECTIVE)
32109     fputs ("\t.version\t\"01.01\"\n", asm_out_file);
32110   if (X86_FILE_START_FLTUSED)
32111     fputs ("\t.global\t__fltused\n", asm_out_file);
32112   if (ix86_asm_dialect == ASM_INTEL)
32113     fputs ("\t.intel_syntax noprefix\n", asm_out_file);
32114 }
32115
32116 int
32117 x86_field_alignment (tree field, int computed)
32118 {
32119   enum machine_mode mode;
32120   tree type = TREE_TYPE (field);
32121
32122   if (TARGET_64BIT || TARGET_ALIGN_DOUBLE)
32123     return computed;
32124   mode = TYPE_MODE (strip_array_types (type));
32125   if (mode == DFmode || mode == DCmode
32126       || GET_MODE_CLASS (mode) == MODE_INT
32127       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
32128     return MIN (32, computed);
32129   return computed;
32130 }
32131
32132 /* Output assembler code to FILE to increment profiler label # LABELNO
32133    for profiling a function entry.  */
32134 void
32135 x86_function_profiler (FILE *file, int labelno ATTRIBUTE_UNUSED)
32136 {
32137   const char *mcount_name = (flag_fentry ? MCOUNT_NAME_BEFORE_PROLOGUE
32138                                          : MCOUNT_NAME);
32139
32140   if (TARGET_64BIT)
32141     {
32142 #ifndef NO_PROFILE_COUNTERS
32143       fprintf (file, "\tleaq\t%sP%d(%%rip),%%r11\n", LPREFIX, labelno);
32144 #endif
32145
32146       if (DEFAULT_ABI == SYSV_ABI && flag_pic)
32147         fprintf (file, "\tcall\t*%s@GOTPCREL(%%rip)\n", mcount_name);
32148       else
32149         fprintf (file, "\tcall\t%s\n", mcount_name);
32150     }
32151   else if (flag_pic)
32152     {
32153 #ifndef NO_PROFILE_COUNTERS
32154       fprintf (file, "\tleal\t%sP%d@GOTOFF(%%ebx),%%" PROFILE_COUNT_REGISTER "\n",
32155                LPREFIX, labelno);
32156 #endif
32157       fprintf (file, "\tcall\t*%s@GOT(%%ebx)\n", mcount_name);
32158     }
32159   else
32160     {
32161 #ifndef NO_PROFILE_COUNTERS
32162       fprintf (file, "\tmovl\t$%sP%d,%%" PROFILE_COUNT_REGISTER "\n",
32163                LPREFIX, labelno);
32164 #endif
32165       fprintf (file, "\tcall\t%s\n", mcount_name);
32166     }
32167 }
32168
32169 /* We don't have exact information about the insn sizes, but we may assume
32170    quite safely that we are informed about all 1 byte insns and memory
32171    address sizes.  This is enough to eliminate unnecessary padding in
32172    99% of cases.  */
32173
32174 static int
32175 min_insn_size (rtx insn)
32176 {
32177   int l = 0, len;
32178
32179   if (!INSN_P (insn) || !active_insn_p (insn))
32180     return 0;
32181
32182   /* Discard alignments we've emit and jump instructions.  */
32183   if (GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE
32184       && XINT (PATTERN (insn), 1) == UNSPECV_ALIGN)
32185     return 0;
32186   if (JUMP_TABLE_DATA_P (insn))
32187     return 0;
32188
32189   /* Important case - calls are always 5 bytes.
32190      It is common to have many calls in the row.  */
32191   if (CALL_P (insn)
32192       && symbolic_reference_mentioned_p (PATTERN (insn))
32193       && !SIBLING_CALL_P (insn))
32194     return 5;
32195   len = get_attr_length (insn);
32196   if (len <= 1)
32197     return 1;
32198
32199   /* For normal instructions we rely on get_attr_length being exact,
32200      with a few exceptions.  */
32201   if (!JUMP_P (insn))
32202     {
32203       enum attr_type type = get_attr_type (insn);
32204
32205       switch (type)
32206         {
32207         case TYPE_MULTI:
32208           if (GET_CODE (PATTERN (insn)) == ASM_INPUT
32209               || asm_noperands (PATTERN (insn)) >= 0)
32210             return 0;
32211           break;
32212         case TYPE_OTHER:
32213         case TYPE_FCMP:
32214           break;
32215         default:
32216           /* Otherwise trust get_attr_length.  */
32217           return len;
32218         }
32219
32220       l = get_attr_length_address (insn);
32221       if (l < 4 && symbolic_reference_mentioned_p (PATTERN (insn)))
32222         l = 4;
32223     }
32224   if (l)
32225     return 1+l;
32226   else
32227     return 2;
32228 }
32229
32230 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
32231
32232 /* AMD K8 core mispredicts jumps when there are more than 3 jumps in 16 byte
32233    window.  */
32234
32235 static void
32236 ix86_avoid_jump_mispredicts (void)
32237 {
32238   rtx insn, start = get_insns ();
32239   int nbytes = 0, njumps = 0;
32240   int isjump = 0;
32241
32242   /* Look for all minimal intervals of instructions containing 4 jumps.
32243      The intervals are bounded by START and INSN.  NBYTES is the total
32244      size of instructions in the interval including INSN and not including
32245      START.  When the NBYTES is smaller than 16 bytes, it is possible
32246      that the end of START and INSN ends up in the same 16byte page.
32247
32248      The smallest offset in the page INSN can start is the case where START
32249      ends on the offset 0.  Offset of INSN is then NBYTES - sizeof (INSN).
32250      We add p2align to 16byte window with maxskip 15 - NBYTES + sizeof (INSN).
32251      */
32252   for (insn = start; insn; insn = NEXT_INSN (insn))
32253     {
32254       int min_size;
32255
32256       if (LABEL_P (insn))
32257         {
32258           int align = label_to_alignment (insn);
32259           int max_skip = label_to_max_skip (insn);
32260
32261           if (max_skip > 15)
32262             max_skip = 15;
32263           /* If align > 3, only up to 16 - max_skip - 1 bytes can be
32264              already in the current 16 byte page, because otherwise
32265              ASM_OUTPUT_MAX_SKIP_ALIGN could skip max_skip or fewer
32266              bytes to reach 16 byte boundary.  */
32267           if (align <= 0
32268               || (align <= 3 && max_skip != (1 << align) - 1))
32269             max_skip = 0;
32270           if (dump_file)
32271             fprintf (dump_file, "Label %i with max_skip %i\n",
32272                      INSN_UID (insn), max_skip);
32273           if (max_skip)
32274             {
32275               while (nbytes + max_skip >= 16)
32276                 {
32277                   start = NEXT_INSN (start);
32278                   if ((JUMP_P (start)
32279                        && GET_CODE (PATTERN (start)) != ADDR_VEC
32280                        && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
32281                       || CALL_P (start))
32282                     njumps--, isjump = 1;
32283                   else
32284                     isjump = 0;
32285                   nbytes -= min_insn_size (start);
32286                 }
32287             }
32288           continue;
32289         }
32290
32291       min_size = min_insn_size (insn);
32292       nbytes += min_size;
32293       if (dump_file)
32294         fprintf (dump_file, "Insn %i estimated to %i bytes\n",
32295                  INSN_UID (insn), min_size);
32296       if ((JUMP_P (insn)
32297            && GET_CODE (PATTERN (insn)) != ADDR_VEC
32298            && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
32299           || CALL_P (insn))
32300         njumps++;
32301       else
32302         continue;
32303
32304       while (njumps > 3)
32305         {
32306           start = NEXT_INSN (start);
32307           if ((JUMP_P (start)
32308                && GET_CODE (PATTERN (start)) != ADDR_VEC
32309                && GET_CODE (PATTERN (start)) != ADDR_DIFF_VEC)
32310               || CALL_P (start))
32311             njumps--, isjump = 1;
32312           else
32313             isjump = 0;
32314           nbytes -= min_insn_size (start);
32315         }
32316       gcc_assert (njumps >= 0);
32317       if (dump_file)
32318         fprintf (dump_file, "Interval %i to %i has %i bytes\n",
32319                  INSN_UID (start), INSN_UID (insn), nbytes);
32320
32321       if (njumps == 3 && isjump && nbytes < 16)
32322         {
32323           int padsize = 15 - nbytes + min_insn_size (insn);
32324
32325           if (dump_file)
32326             fprintf (dump_file, "Padding insn %i by %i bytes!\n",
32327                      INSN_UID (insn), padsize);
32328           emit_insn_before (gen_pad (GEN_INT (padsize)), insn);
32329         }
32330     }
32331 }
32332 #endif
32333
32334 /* AMD Athlon works faster
32335    when RET is not destination of conditional jump or directly preceded
32336    by other jump instruction.  We avoid the penalty by inserting NOP just
32337    before the RET instructions in such cases.  */
32338 static void
32339 ix86_pad_returns (void)
32340 {
32341   edge e;
32342   edge_iterator ei;
32343
32344   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
32345     {
32346       basic_block bb = e->src;
32347       rtx ret = BB_END (bb);
32348       rtx prev;
32349       bool replace = false;
32350
32351       if (!JUMP_P (ret) || !ANY_RETURN_P (PATTERN (ret))
32352           || optimize_bb_for_size_p (bb))
32353         continue;
32354       for (prev = PREV_INSN (ret); prev; prev = PREV_INSN (prev))
32355         if (active_insn_p (prev) || LABEL_P (prev))
32356           break;
32357       if (prev && LABEL_P (prev))
32358         {
32359           edge e;
32360           edge_iterator ei;
32361
32362           FOR_EACH_EDGE (e, ei, bb->preds)
32363             if (EDGE_FREQUENCY (e) && e->src->index >= 0
32364                 && !(e->flags & EDGE_FALLTHRU))
32365               replace = true;
32366         }
32367       if (!replace)
32368         {
32369           prev = prev_active_insn (ret);
32370           if (prev
32371               && ((JUMP_P (prev) && any_condjump_p (prev))
32372                   || CALL_P (prev)))
32373             replace = true;
32374           /* Empty functions get branch mispredict even when
32375              the jump destination is not visible to us.  */
32376           if (!prev && !optimize_function_for_size_p (cfun))
32377             replace = true;
32378         }
32379       if (replace)
32380         {
32381           emit_jump_insn_before (gen_simple_return_internal_long (), ret);
32382           delete_insn (ret);
32383         }
32384     }
32385 }
32386
32387 /* Count the minimum number of instructions in BB.  Return 4 if the
32388    number of instructions >= 4.  */
32389
32390 static int
32391 ix86_count_insn_bb (basic_block bb)
32392 {
32393   rtx insn;
32394   int insn_count = 0;
32395
32396   /* Count number of instructions in this block.  Return 4 if the number
32397      of instructions >= 4.  */
32398   FOR_BB_INSNS (bb, insn)
32399     {
32400       /* Only happen in exit blocks.  */
32401       if (JUMP_P (insn)
32402           && ANY_RETURN_P (PATTERN (insn)))
32403         break;
32404
32405       if (NONDEBUG_INSN_P (insn)
32406           && GET_CODE (PATTERN (insn)) != USE
32407           && GET_CODE (PATTERN (insn)) != CLOBBER)
32408         {
32409           insn_count++;
32410           if (insn_count >= 4)
32411             return insn_count;
32412         }
32413     }
32414
32415   return insn_count;
32416 }
32417
32418
32419 /* Count the minimum number of instructions in code path in BB.
32420    Return 4 if the number of instructions >= 4.  */
32421
32422 static int
32423 ix86_count_insn (basic_block bb)
32424 {
32425   edge e;
32426   edge_iterator ei;
32427   int min_prev_count;
32428
32429   /* Only bother counting instructions along paths with no
32430      more than 2 basic blocks between entry and exit.  Given
32431      that BB has an edge to exit, determine if a predecessor
32432      of BB has an edge from entry.  If so, compute the number
32433      of instructions in the predecessor block.  If there
32434      happen to be multiple such blocks, compute the minimum.  */
32435   min_prev_count = 4;
32436   FOR_EACH_EDGE (e, ei, bb->preds)
32437     {
32438       edge prev_e;
32439       edge_iterator prev_ei;
32440
32441       if (e->src == ENTRY_BLOCK_PTR)
32442         {
32443           min_prev_count = 0;
32444           break;
32445         }
32446       FOR_EACH_EDGE (prev_e, prev_ei, e->src->preds)
32447         {
32448           if (prev_e->src == ENTRY_BLOCK_PTR)
32449             {
32450               int count = ix86_count_insn_bb (e->src);
32451               if (count < min_prev_count)
32452                 min_prev_count = count;
32453               break;
32454             }
32455         }
32456     }
32457
32458   if (min_prev_count < 4)
32459     min_prev_count += ix86_count_insn_bb (bb);
32460
32461   return min_prev_count;
32462 }
32463
32464 /* Pad short funtion to 4 instructions.   */
32465
32466 static void
32467 ix86_pad_short_function (void)
32468 {
32469   edge e;
32470   edge_iterator ei;
32471
32472   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
32473     {
32474       rtx ret = BB_END (e->src);
32475       if (JUMP_P (ret) && ANY_RETURN_P (PATTERN (ret)))
32476         {
32477           int insn_count = ix86_count_insn (e->src);
32478
32479           /* Pad short function.  */
32480           if (insn_count < 4)
32481             {
32482               rtx insn = ret;
32483
32484               /* Find epilogue.  */
32485               while (insn
32486                      && (!NOTE_P (insn)
32487                          || NOTE_KIND (insn) != NOTE_INSN_EPILOGUE_BEG))
32488                 insn = PREV_INSN (insn);
32489
32490               if (!insn)
32491                 insn = ret;
32492
32493               /* Two NOPs count as one instruction.  */
32494               insn_count = 2 * (4 - insn_count);
32495               emit_insn_before (gen_nops (GEN_INT (insn_count)), insn);
32496             }
32497         }
32498     }
32499 }
32500
32501 /* Implement machine specific optimizations.  We implement padding of returns
32502    for K8 CPUs and pass to avoid 4 jumps in the single 16 byte window.  */
32503 static void
32504 ix86_reorg (void)
32505 {
32506   /* We are freeing block_for_insn in the toplev to keep compatibility
32507      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
32508   compute_bb_for_insn ();
32509
32510   /* Run the vzeroupper optimization if needed.  */
32511   if (TARGET_VZEROUPPER)
32512     move_or_delete_vzeroupper ();
32513
32514   if (optimize && optimize_function_for_speed_p (cfun))
32515     {
32516       if (TARGET_PAD_SHORT_FUNCTION)
32517         ix86_pad_short_function ();
32518       else if (TARGET_PAD_RETURNS)
32519         ix86_pad_returns ();
32520 #ifdef ASM_OUTPUT_MAX_SKIP_PAD
32521       if (TARGET_FOUR_JUMP_LIMIT)
32522         ix86_avoid_jump_mispredicts ();
32523 #endif
32524     }
32525 }
32526
32527 /* Return nonzero when QImode register that must be represented via REX prefix
32528    is used.  */
32529 bool
32530 x86_extended_QIreg_mentioned_p (rtx insn)
32531 {
32532   int i;
32533   extract_insn_cached (insn);
32534   for (i = 0; i < recog_data.n_operands; i++)
32535     if (REG_P (recog_data.operand[i])
32536         && REGNO (recog_data.operand[i]) > BX_REG)
32537        return true;
32538   return false;
32539 }
32540
32541 /* Return nonzero when P points to register encoded via REX prefix.
32542    Called via for_each_rtx.  */
32543 static int
32544 extended_reg_mentioned_1 (rtx *p, void *data ATTRIBUTE_UNUSED)
32545 {
32546    unsigned int regno;
32547    if (!REG_P (*p))
32548      return 0;
32549    regno = REGNO (*p);
32550    return REX_INT_REGNO_P (regno) || REX_SSE_REGNO_P (regno);
32551 }
32552
32553 /* Return true when INSN mentions register that must be encoded using REX
32554    prefix.  */
32555 bool
32556 x86_extended_reg_mentioned_p (rtx insn)
32557 {
32558   return for_each_rtx (INSN_P (insn) ? &PATTERN (insn) : &insn,
32559                        extended_reg_mentioned_1, NULL);
32560 }
32561
32562 /* If profitable, negate (without causing overflow) integer constant
32563    of mode MODE at location LOC.  Return true in this case.  */
32564 bool
32565 x86_maybe_negate_const_int (rtx *loc, enum machine_mode mode)
32566 {
32567   HOST_WIDE_INT val;
32568
32569   if (!CONST_INT_P (*loc))
32570     return false;
32571
32572   switch (mode)
32573     {
32574     case DImode:
32575       /* DImode x86_64 constants must fit in 32 bits.  */
32576       gcc_assert (x86_64_immediate_operand (*loc, mode));
32577
32578       mode = SImode;
32579       break;
32580
32581     case SImode:
32582     case HImode:
32583     case QImode:
32584       break;
32585
32586     default:
32587       gcc_unreachable ();
32588     }
32589
32590   /* Avoid overflows.  */
32591   if (mode_signbit_p (mode, *loc))
32592     return false;
32593
32594   val = INTVAL (*loc);
32595
32596   /* Make things pretty and `subl $4,%eax' rather than `addl $-4,%eax'.
32597      Exceptions: -128 encodes smaller than 128, so swap sign and op.  */
32598   if ((val < 0 && val != -128)
32599       || val == 128)
32600     {
32601       *loc = GEN_INT (-val);
32602       return true;
32603     }
32604
32605   return false;
32606 }
32607
32608 /* Generate an unsigned DImode/SImode to FP conversion.  This is the same code
32609    optabs would emit if we didn't have TFmode patterns.  */
32610
32611 void
32612 x86_emit_floatuns (rtx operands[2])
32613 {
32614   rtx neglab, donelab, i0, i1, f0, in, out;
32615   enum machine_mode mode, inmode;
32616
32617   inmode = GET_MODE (operands[1]);
32618   gcc_assert (inmode == SImode || inmode == DImode);
32619
32620   out = operands[0];
32621   in = force_reg (inmode, operands[1]);
32622   mode = GET_MODE (out);
32623   neglab = gen_label_rtx ();
32624   donelab = gen_label_rtx ();
32625   f0 = gen_reg_rtx (mode);
32626
32627   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, inmode, 0, neglab);
32628
32629   expand_float (out, in, 0);
32630
32631   emit_jump_insn (gen_jump (donelab));
32632   emit_barrier ();
32633
32634   emit_label (neglab);
32635
32636   i0 = expand_simple_binop (inmode, LSHIFTRT, in, const1_rtx, NULL,
32637                             1, OPTAB_DIRECT);
32638   i1 = expand_simple_binop (inmode, AND, in, const1_rtx, NULL,
32639                             1, OPTAB_DIRECT);
32640   i0 = expand_simple_binop (inmode, IOR, i0, i1, i0, 1, OPTAB_DIRECT);
32641
32642   expand_float (f0, i0, 0);
32643
32644   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
32645
32646   emit_label (donelab);
32647 }
32648 \f
32649 /* AVX2 does support 32-byte integer vector operations,
32650    thus the longest vector we are faced with is V32QImode.  */
32651 #define MAX_VECT_LEN    32
32652
32653 struct expand_vec_perm_d
32654 {
32655   rtx target, op0, op1;
32656   unsigned char perm[MAX_VECT_LEN];
32657   enum machine_mode vmode;
32658   unsigned char nelt;
32659   bool testing_p;
32660 };
32661
32662 static bool expand_vec_perm_1 (struct expand_vec_perm_d *d);
32663 static bool expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d);
32664
32665 /* Get a vector mode of the same size as the original but with elements
32666    twice as wide.  This is only guaranteed to apply to integral vectors.  */
32667
32668 static inline enum machine_mode
32669 get_mode_wider_vector (enum machine_mode o)
32670 {
32671   /* ??? Rely on the ordering that genmodes.c gives to vectors.  */
32672   enum machine_mode n = GET_MODE_WIDER_MODE (o);
32673   gcc_assert (GET_MODE_NUNITS (o) == GET_MODE_NUNITS (n) * 2);
32674   gcc_assert (GET_MODE_SIZE (o) == GET_MODE_SIZE (n));
32675   return n;
32676 }
32677
32678 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
32679    with all elements equal to VAR.  Return true if successful.  */
32680
32681 static bool
32682 ix86_expand_vector_init_duplicate (bool mmx_ok, enum machine_mode mode,
32683                                    rtx target, rtx val)
32684 {
32685   bool ok;
32686
32687   switch (mode)
32688     {
32689     case V2SImode:
32690     case V2SFmode:
32691       if (!mmx_ok)
32692         return false;
32693       /* FALLTHRU */
32694
32695     case V4DFmode:
32696     case V4DImode:
32697     case V8SFmode:
32698     case V8SImode:
32699     case V2DFmode:
32700     case V2DImode:
32701     case V4SFmode:
32702     case V4SImode:
32703       {
32704         rtx insn, dup;
32705
32706         /* First attempt to recognize VAL as-is.  */
32707         dup = gen_rtx_VEC_DUPLICATE (mode, val);
32708         insn = emit_insn (gen_rtx_SET (VOIDmode, target, dup));
32709         if (recog_memoized (insn) < 0)
32710           {
32711             rtx seq;
32712             /* If that fails, force VAL into a register.  */
32713
32714             start_sequence ();
32715             XEXP (dup, 0) = force_reg (GET_MODE_INNER (mode), val);
32716             seq = get_insns ();
32717             end_sequence ();
32718             if (seq)
32719               emit_insn_before (seq, insn);
32720
32721             ok = recog_memoized (insn) >= 0;
32722             gcc_assert (ok);
32723           }
32724       }
32725       return true;
32726
32727     case V4HImode:
32728       if (!mmx_ok)
32729         return false;
32730       if (TARGET_SSE || TARGET_3DNOW_A)
32731         {
32732           rtx x;
32733
32734           val = gen_lowpart (SImode, val);
32735           x = gen_rtx_TRUNCATE (HImode, val);
32736           x = gen_rtx_VEC_DUPLICATE (mode, x);
32737           emit_insn (gen_rtx_SET (VOIDmode, target, x));
32738           return true;
32739         }
32740       goto widen;
32741
32742     case V8QImode:
32743       if (!mmx_ok)
32744         return false;
32745       goto widen;
32746
32747     case V8HImode:
32748       if (TARGET_SSE2)
32749         {
32750           struct expand_vec_perm_d dperm;
32751           rtx tmp1, tmp2;
32752
32753         permute:
32754           memset (&dperm, 0, sizeof (dperm));
32755           dperm.target = target;
32756           dperm.vmode = mode;
32757           dperm.nelt = GET_MODE_NUNITS (mode);
32758           dperm.op0 = dperm.op1 = gen_reg_rtx (mode);
32759
32760           /* Extend to SImode using a paradoxical SUBREG.  */
32761           tmp1 = gen_reg_rtx (SImode);
32762           emit_move_insn (tmp1, gen_lowpart (SImode, val));
32763
32764           /* Insert the SImode value as low element of a V4SImode vector. */
32765           tmp2 = gen_lowpart (V4SImode, dperm.op0);
32766           emit_insn (gen_vec_setv4si_0 (tmp2, CONST0_RTX (V4SImode), tmp1));
32767
32768           ok = (expand_vec_perm_1 (&dperm)
32769                 || expand_vec_perm_broadcast_1 (&dperm));
32770           gcc_assert (ok);
32771           return ok;
32772         }
32773       goto widen;
32774
32775     case V16QImode:
32776       if (TARGET_SSE2)
32777         goto permute;
32778       goto widen;
32779
32780     widen:
32781       /* Replicate the value once into the next wider mode and recurse.  */
32782       {
32783         enum machine_mode smode, wsmode, wvmode;
32784         rtx x;
32785
32786         smode = GET_MODE_INNER (mode);
32787         wvmode = get_mode_wider_vector (mode);
32788         wsmode = GET_MODE_INNER (wvmode);
32789
32790         val = convert_modes (wsmode, smode, val, true);
32791         x = expand_simple_binop (wsmode, ASHIFT, val,
32792                                  GEN_INT (GET_MODE_BITSIZE (smode)),
32793                                  NULL_RTX, 1, OPTAB_LIB_WIDEN);
32794         val = expand_simple_binop (wsmode, IOR, val, x, x, 1, OPTAB_LIB_WIDEN);
32795
32796         x = gen_lowpart (wvmode, target);
32797         ok = ix86_expand_vector_init_duplicate (mmx_ok, wvmode, x, val);
32798         gcc_assert (ok);
32799         return ok;
32800       }
32801
32802     case V16HImode:
32803     case V32QImode:
32804       {
32805         enum machine_mode hvmode = (mode == V16HImode ? V8HImode : V16QImode);
32806         rtx x = gen_reg_rtx (hvmode);
32807
32808         ok = ix86_expand_vector_init_duplicate (false, hvmode, x, val);
32809         gcc_assert (ok);
32810
32811         x = gen_rtx_VEC_CONCAT (mode, x, x);
32812         emit_insn (gen_rtx_SET (VOIDmode, target, x));
32813       }
32814       return true;
32815
32816     default:
32817       return false;
32818     }
32819 }
32820
32821 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
32822    whose ONE_VAR element is VAR, and other elements are zero.  Return true
32823    if successful.  */
32824
32825 static bool
32826 ix86_expand_vector_init_one_nonzero (bool mmx_ok, enum machine_mode mode,
32827                                      rtx target, rtx var, int one_var)
32828 {
32829   enum machine_mode vsimode;
32830   rtx new_target;
32831   rtx x, tmp;
32832   bool use_vector_set = false;
32833
32834   switch (mode)
32835     {
32836     case V2DImode:
32837       /* For SSE4.1, we normally use vector set.  But if the second
32838          element is zero and inter-unit moves are OK, we use movq
32839          instead.  */
32840       use_vector_set = (TARGET_64BIT
32841                         && TARGET_SSE4_1
32842                         && !(TARGET_INTER_UNIT_MOVES
32843                              && one_var == 0));
32844       break;
32845     case V16QImode:
32846     case V4SImode:
32847     case V4SFmode:
32848       use_vector_set = TARGET_SSE4_1;
32849       break;
32850     case V8HImode:
32851       use_vector_set = TARGET_SSE2;
32852       break;
32853     case V4HImode:
32854       use_vector_set = TARGET_SSE || TARGET_3DNOW_A;
32855       break;
32856     case V32QImode:
32857     case V16HImode:
32858     case V8SImode:
32859     case V8SFmode:
32860     case V4DFmode:
32861       use_vector_set = TARGET_AVX;
32862       break;
32863     case V4DImode:
32864       /* Use ix86_expand_vector_set in 64bit mode only.  */
32865       use_vector_set = TARGET_AVX && TARGET_64BIT;
32866       break;
32867     default:
32868       break;
32869     }
32870
32871   if (use_vector_set)
32872     {
32873       emit_insn (gen_rtx_SET (VOIDmode, target, CONST0_RTX (mode)));
32874       var = force_reg (GET_MODE_INNER (mode), var);
32875       ix86_expand_vector_set (mmx_ok, target, var, one_var);
32876       return true;
32877     }
32878
32879   switch (mode)
32880     {
32881     case V2SFmode:
32882     case V2SImode:
32883       if (!mmx_ok)
32884         return false;
32885       /* FALLTHRU */
32886
32887     case V2DFmode:
32888     case V2DImode:
32889       if (one_var != 0)
32890         return false;
32891       var = force_reg (GET_MODE_INNER (mode), var);
32892       x = gen_rtx_VEC_CONCAT (mode, var, CONST0_RTX (GET_MODE_INNER (mode)));
32893       emit_insn (gen_rtx_SET (VOIDmode, target, x));
32894       return true;
32895
32896     case V4SFmode:
32897     case V4SImode:
32898       if (!REG_P (target) || REGNO (target) < FIRST_PSEUDO_REGISTER)
32899         new_target = gen_reg_rtx (mode);
32900       else
32901         new_target = target;
32902       var = force_reg (GET_MODE_INNER (mode), var);
32903       x = gen_rtx_VEC_DUPLICATE (mode, var);
32904       x = gen_rtx_VEC_MERGE (mode, x, CONST0_RTX (mode), const1_rtx);
32905       emit_insn (gen_rtx_SET (VOIDmode, new_target, x));
32906       if (one_var != 0)
32907         {
32908           /* We need to shuffle the value to the correct position, so
32909              create a new pseudo to store the intermediate result.  */
32910
32911           /* With SSE2, we can use the integer shuffle insns.  */
32912           if (mode != V4SFmode && TARGET_SSE2)
32913             {
32914               emit_insn (gen_sse2_pshufd_1 (new_target, new_target,
32915                                             const1_rtx,
32916                                             GEN_INT (one_var == 1 ? 0 : 1),
32917                                             GEN_INT (one_var == 2 ? 0 : 1),
32918                                             GEN_INT (one_var == 3 ? 0 : 1)));
32919               if (target != new_target)
32920                 emit_move_insn (target, new_target);
32921               return true;
32922             }
32923
32924           /* Otherwise convert the intermediate result to V4SFmode and
32925              use the SSE1 shuffle instructions.  */
32926           if (mode != V4SFmode)
32927             {
32928               tmp = gen_reg_rtx (V4SFmode);
32929               emit_move_insn (tmp, gen_lowpart (V4SFmode, new_target));
32930             }
32931           else
32932             tmp = new_target;
32933
32934           emit_insn (gen_sse_shufps_v4sf (tmp, tmp, tmp,
32935                                        const1_rtx,
32936                                        GEN_INT (one_var == 1 ? 0 : 1),
32937                                        GEN_INT (one_var == 2 ? 0+4 : 1+4),
32938                                        GEN_INT (one_var == 3 ? 0+4 : 1+4)));
32939
32940           if (mode != V4SFmode)
32941             emit_move_insn (target, gen_lowpart (V4SImode, tmp));
32942           else if (tmp != target)
32943             emit_move_insn (target, tmp);
32944         }
32945       else if (target != new_target)
32946         emit_move_insn (target, new_target);
32947       return true;
32948
32949     case V8HImode:
32950     case V16QImode:
32951       vsimode = V4SImode;
32952       goto widen;
32953     case V4HImode:
32954     case V8QImode:
32955       if (!mmx_ok)
32956         return false;
32957       vsimode = V2SImode;
32958       goto widen;
32959     widen:
32960       if (one_var != 0)
32961         return false;
32962
32963       /* Zero extend the variable element to SImode and recurse.  */
32964       var = convert_modes (SImode, GET_MODE_INNER (mode), var, true);
32965
32966       x = gen_reg_rtx (vsimode);
32967       if (!ix86_expand_vector_init_one_nonzero (mmx_ok, vsimode, x,
32968                                                 var, one_var))
32969         gcc_unreachable ();
32970
32971       emit_move_insn (target, gen_lowpart (mode, x));
32972       return true;
32973
32974     default:
32975       return false;
32976     }
32977 }
32978
32979 /* A subroutine of ix86_expand_vector_init.  Store into TARGET a vector
32980    consisting of the values in VALS.  It is known that all elements
32981    except ONE_VAR are constants.  Return true if successful.  */
32982
32983 static bool
32984 ix86_expand_vector_init_one_var (bool mmx_ok, enum machine_mode mode,
32985                                  rtx target, rtx vals, int one_var)
32986 {
32987   rtx var = XVECEXP (vals, 0, one_var);
32988   enum machine_mode wmode;
32989   rtx const_vec, x;
32990
32991   const_vec = copy_rtx (vals);
32992   XVECEXP (const_vec, 0, one_var) = CONST0_RTX (GET_MODE_INNER (mode));
32993   const_vec = gen_rtx_CONST_VECTOR (mode, XVEC (const_vec, 0));
32994
32995   switch (mode)
32996     {
32997     case V2DFmode:
32998     case V2DImode:
32999     case V2SFmode:
33000     case V2SImode:
33001       /* For the two element vectors, it's just as easy to use
33002          the general case.  */
33003       return false;
33004
33005     case V4DImode:
33006       /* Use ix86_expand_vector_set in 64bit mode only.  */
33007       if (!TARGET_64BIT)
33008         return false;
33009     case V4DFmode:
33010     case V8SFmode:
33011     case V8SImode:
33012     case V16HImode:
33013     case V32QImode:
33014     case V4SFmode:
33015     case V4SImode:
33016     case V8HImode:
33017     case V4HImode:
33018       break;
33019
33020     case V16QImode:
33021       if (TARGET_SSE4_1)
33022         break;
33023       wmode = V8HImode;
33024       goto widen;
33025     case V8QImode:
33026       wmode = V4HImode;
33027       goto widen;
33028     widen:
33029       /* There's no way to set one QImode entry easily.  Combine
33030          the variable value with its adjacent constant value, and
33031          promote to an HImode set.  */
33032       x = XVECEXP (vals, 0, one_var ^ 1);
33033       if (one_var & 1)
33034         {
33035           var = convert_modes (HImode, QImode, var, true);
33036           var = expand_simple_binop (HImode, ASHIFT, var, GEN_INT (8),
33037                                      NULL_RTX, 1, OPTAB_LIB_WIDEN);
33038           x = GEN_INT (INTVAL (x) & 0xff);
33039         }
33040       else
33041         {
33042           var = convert_modes (HImode, QImode, var, true);
33043           x = gen_int_mode (INTVAL (x) << 8, HImode);
33044         }
33045       if (x != const0_rtx)
33046         var = expand_simple_binop (HImode, IOR, var, x, var,
33047                                    1, OPTAB_LIB_WIDEN);
33048
33049       x = gen_reg_rtx (wmode);
33050       emit_move_insn (x, gen_lowpart (wmode, const_vec));
33051       ix86_expand_vector_set (mmx_ok, x, var, one_var >> 1);
33052
33053       emit_move_insn (target, gen_lowpart (mode, x));
33054       return true;
33055
33056     default:
33057       return false;
33058     }
33059
33060   emit_move_insn (target, const_vec);
33061   ix86_expand_vector_set (mmx_ok, target, var, one_var);
33062   return true;
33063 }
33064
33065 /* A subroutine of ix86_expand_vector_init_general.  Use vector
33066    concatenate to handle the most general case: all values variable,
33067    and none identical.  */
33068
33069 static void
33070 ix86_expand_vector_init_concat (enum machine_mode mode,
33071                                 rtx target, rtx *ops, int n)
33072 {
33073   enum machine_mode cmode, hmode = VOIDmode;
33074   rtx first[8], second[4];
33075   rtvec v;
33076   int i, j;
33077
33078   switch (n)
33079     {
33080     case 2:
33081       switch (mode)
33082         {
33083         case V8SImode:
33084           cmode = V4SImode;
33085           break;
33086         case V8SFmode:
33087           cmode = V4SFmode;
33088           break;
33089         case V4DImode:
33090           cmode = V2DImode;
33091           break;
33092         case V4DFmode:
33093           cmode = V2DFmode;
33094           break;
33095         case V4SImode:
33096           cmode = V2SImode;
33097           break;
33098         case V4SFmode:
33099           cmode = V2SFmode;
33100           break;
33101         case V2DImode:
33102           cmode = DImode;
33103           break;
33104         case V2SImode:
33105           cmode = SImode;
33106           break;
33107         case V2DFmode:
33108           cmode = DFmode;
33109           break;
33110         case V2SFmode:
33111           cmode = SFmode;
33112           break;
33113         default:
33114           gcc_unreachable ();
33115         }
33116
33117       if (!register_operand (ops[1], cmode))
33118         ops[1] = force_reg (cmode, ops[1]);
33119       if (!register_operand (ops[0], cmode))
33120         ops[0] = force_reg (cmode, ops[0]);
33121       emit_insn (gen_rtx_SET (VOIDmode, target,
33122                               gen_rtx_VEC_CONCAT (mode, ops[0],
33123                                                   ops[1])));
33124       break;
33125
33126     case 4:
33127       switch (mode)
33128         {
33129         case V4DImode:
33130           cmode = V2DImode;
33131           break;
33132         case V4DFmode:
33133           cmode = V2DFmode;
33134           break;
33135         case V4SImode:
33136           cmode = V2SImode;
33137           break;
33138         case V4SFmode:
33139           cmode = V2SFmode;
33140           break;
33141         default:
33142           gcc_unreachable ();
33143         }
33144       goto half;
33145
33146     case 8:
33147       switch (mode)
33148         {
33149         case V8SImode:
33150           cmode = V2SImode;
33151           hmode = V4SImode;
33152           break;
33153         case V8SFmode:
33154           cmode = V2SFmode;
33155           hmode = V4SFmode;
33156           break;
33157         default:
33158           gcc_unreachable ();
33159         }
33160       goto half;
33161
33162 half:
33163       /* FIXME: We process inputs backward to help RA.  PR 36222.  */
33164       i = n - 1;
33165       j = (n >> 1) - 1;
33166       for (; i > 0; i -= 2, j--)
33167         {
33168           first[j] = gen_reg_rtx (cmode);
33169           v = gen_rtvec (2, ops[i - 1], ops[i]);
33170           ix86_expand_vector_init (false, first[j],
33171                                    gen_rtx_PARALLEL (cmode, v));
33172         }
33173
33174       n >>= 1;
33175       if (n > 2)
33176         {
33177           gcc_assert (hmode != VOIDmode);
33178           for (i = j = 0; i < n; i += 2, j++)
33179             {
33180               second[j] = gen_reg_rtx (hmode);
33181               ix86_expand_vector_init_concat (hmode, second [j],
33182                                               &first [i], 2);
33183             }
33184           n >>= 1;
33185           ix86_expand_vector_init_concat (mode, target, second, n);
33186         }
33187       else
33188         ix86_expand_vector_init_concat (mode, target, first, n);
33189       break;
33190
33191     default:
33192       gcc_unreachable ();
33193     }
33194 }
33195
33196 /* A subroutine of ix86_expand_vector_init_general.  Use vector
33197    interleave to handle the most general case: all values variable,
33198    and none identical.  */
33199
33200 static void
33201 ix86_expand_vector_init_interleave (enum machine_mode mode,
33202                                     rtx target, rtx *ops, int n)
33203 {
33204   enum machine_mode first_imode, second_imode, third_imode, inner_mode;
33205   int i, j;
33206   rtx op0, op1;
33207   rtx (*gen_load_even) (rtx, rtx, rtx);
33208   rtx (*gen_interleave_first_low) (rtx, rtx, rtx);
33209   rtx (*gen_interleave_second_low) (rtx, rtx, rtx);
33210
33211   switch (mode)
33212     {
33213     case V8HImode:
33214       gen_load_even = gen_vec_setv8hi;
33215       gen_interleave_first_low = gen_vec_interleave_lowv4si;
33216       gen_interleave_second_low = gen_vec_interleave_lowv2di;
33217       inner_mode = HImode;
33218       first_imode = V4SImode;
33219       second_imode = V2DImode;
33220       third_imode = VOIDmode;
33221       break;
33222     case V16QImode:
33223       gen_load_even = gen_vec_setv16qi;
33224       gen_interleave_first_low = gen_vec_interleave_lowv8hi;
33225       gen_interleave_second_low = gen_vec_interleave_lowv4si;
33226       inner_mode = QImode;
33227       first_imode = V8HImode;
33228       second_imode = V4SImode;
33229       third_imode = V2DImode;
33230       break;
33231     default:
33232       gcc_unreachable ();
33233     }
33234
33235   for (i = 0; i < n; i++)
33236     {
33237       /* Extend the odd elment to SImode using a paradoxical SUBREG.  */
33238       op0 = gen_reg_rtx (SImode);
33239       emit_move_insn (op0, gen_lowpart (SImode, ops [i + i]));
33240
33241       /* Insert the SImode value as low element of V4SImode vector. */
33242       op1 = gen_reg_rtx (V4SImode);
33243       op0 = gen_rtx_VEC_MERGE (V4SImode,
33244                                gen_rtx_VEC_DUPLICATE (V4SImode,
33245                                                       op0),
33246                                CONST0_RTX (V4SImode),
33247                                const1_rtx);
33248       emit_insn (gen_rtx_SET (VOIDmode, op1, op0));
33249
33250       /* Cast the V4SImode vector back to a vector in orignal mode.  */
33251       op0 = gen_reg_rtx (mode);
33252       emit_move_insn (op0, gen_lowpart (mode, op1));
33253
33254       /* Load even elements into the second positon.  */
33255       emit_insn (gen_load_even (op0,
33256                                 force_reg (inner_mode,
33257                                            ops [i + i + 1]),
33258                                 const1_rtx));
33259
33260       /* Cast vector to FIRST_IMODE vector.  */
33261       ops[i] = gen_reg_rtx (first_imode);
33262       emit_move_insn (ops[i], gen_lowpart (first_imode, op0));
33263     }
33264
33265   /* Interleave low FIRST_IMODE vectors.  */
33266   for (i = j = 0; i < n; i += 2, j++)
33267     {
33268       op0 = gen_reg_rtx (first_imode);
33269       emit_insn (gen_interleave_first_low (op0, ops[i], ops[i + 1]));
33270
33271       /* Cast FIRST_IMODE vector to SECOND_IMODE vector.  */
33272       ops[j] = gen_reg_rtx (second_imode);
33273       emit_move_insn (ops[j], gen_lowpart (second_imode, op0));
33274     }
33275
33276   /* Interleave low SECOND_IMODE vectors.  */
33277   switch (second_imode)
33278     {
33279     case V4SImode:
33280       for (i = j = 0; i < n / 2; i += 2, j++)
33281         {
33282           op0 = gen_reg_rtx (second_imode);
33283           emit_insn (gen_interleave_second_low (op0, ops[i],
33284                                                 ops[i + 1]));
33285
33286           /* Cast the SECOND_IMODE vector to the THIRD_IMODE
33287              vector.  */
33288           ops[j] = gen_reg_rtx (third_imode);
33289           emit_move_insn (ops[j], gen_lowpart (third_imode, op0));
33290         }
33291       second_imode = V2DImode;
33292       gen_interleave_second_low = gen_vec_interleave_lowv2di;
33293       /* FALLTHRU */
33294
33295     case V2DImode:
33296       op0 = gen_reg_rtx (second_imode);
33297       emit_insn (gen_interleave_second_low (op0, ops[0],
33298                                             ops[1]));
33299
33300       /* Cast the SECOND_IMODE vector back to a vector on original
33301          mode.  */
33302       emit_insn (gen_rtx_SET (VOIDmode, target,
33303                               gen_lowpart (mode, op0)));
33304       break;
33305
33306     default:
33307       gcc_unreachable ();
33308     }
33309 }
33310
33311 /* A subroutine of ix86_expand_vector_init.  Handle the most general case:
33312    all values variable, and none identical.  */
33313
33314 static void
33315 ix86_expand_vector_init_general (bool mmx_ok, enum machine_mode mode,
33316                                  rtx target, rtx vals)
33317 {
33318   rtx ops[32], op0, op1;
33319   enum machine_mode half_mode = VOIDmode;
33320   int n, i;
33321
33322   switch (mode)
33323     {
33324     case V2SFmode:
33325     case V2SImode:
33326       if (!mmx_ok && !TARGET_SSE)
33327         break;
33328       /* FALLTHRU */
33329
33330     case V8SFmode:
33331     case V8SImode:
33332     case V4DFmode:
33333     case V4DImode:
33334     case V4SFmode:
33335     case V4SImode:
33336     case V2DFmode:
33337     case V2DImode:
33338       n = GET_MODE_NUNITS (mode);
33339       for (i = 0; i < n; i++)
33340         ops[i] = XVECEXP (vals, 0, i);
33341       ix86_expand_vector_init_concat (mode, target, ops, n);
33342       return;
33343
33344     case V32QImode:
33345       half_mode = V16QImode;
33346       goto half;
33347
33348     case V16HImode:
33349       half_mode = V8HImode;
33350       goto half;
33351
33352 half:
33353       n = GET_MODE_NUNITS (mode);
33354       for (i = 0; i < n; i++)
33355         ops[i] = XVECEXP (vals, 0, i);
33356       op0 = gen_reg_rtx (half_mode);
33357       op1 = gen_reg_rtx (half_mode);
33358       ix86_expand_vector_init_interleave (half_mode, op0, ops,
33359                                           n >> 2);
33360       ix86_expand_vector_init_interleave (half_mode, op1,
33361                                           &ops [n >> 1], n >> 2);
33362       emit_insn (gen_rtx_SET (VOIDmode, target,
33363                               gen_rtx_VEC_CONCAT (mode, op0, op1)));
33364       return;
33365
33366     case V16QImode:
33367       if (!TARGET_SSE4_1)
33368         break;
33369       /* FALLTHRU */
33370
33371     case V8HImode:
33372       if (!TARGET_SSE2)
33373         break;
33374
33375       /* Don't use ix86_expand_vector_init_interleave if we can't
33376          move from GPR to SSE register directly.  */
33377       if (!TARGET_INTER_UNIT_MOVES)
33378         break;
33379
33380       n = GET_MODE_NUNITS (mode);
33381       for (i = 0; i < n; i++)
33382         ops[i] = XVECEXP (vals, 0, i);
33383       ix86_expand_vector_init_interleave (mode, target, ops, n >> 1);
33384       return;
33385
33386     case V4HImode:
33387     case V8QImode:
33388       break;
33389
33390     default:
33391       gcc_unreachable ();
33392     }
33393
33394     {
33395       int i, j, n_elts, n_words, n_elt_per_word;
33396       enum machine_mode inner_mode;
33397       rtx words[4], shift;
33398
33399       inner_mode = GET_MODE_INNER (mode);
33400       n_elts = GET_MODE_NUNITS (mode);
33401       n_words = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
33402       n_elt_per_word = n_elts / n_words;
33403       shift = GEN_INT (GET_MODE_BITSIZE (inner_mode));
33404
33405       for (i = 0; i < n_words; ++i)
33406         {
33407           rtx word = NULL_RTX;
33408
33409           for (j = 0; j < n_elt_per_word; ++j)
33410             {
33411               rtx elt = XVECEXP (vals, 0, (i+1)*n_elt_per_word - j - 1);
33412               elt = convert_modes (word_mode, inner_mode, elt, true);
33413
33414               if (j == 0)
33415                 word = elt;
33416               else
33417                 {
33418                   word = expand_simple_binop (word_mode, ASHIFT, word, shift,
33419                                               word, 1, OPTAB_LIB_WIDEN);
33420                   word = expand_simple_binop (word_mode, IOR, word, elt,
33421                                               word, 1, OPTAB_LIB_WIDEN);
33422                 }
33423             }
33424
33425           words[i] = word;
33426         }
33427
33428       if (n_words == 1)
33429         emit_move_insn (target, gen_lowpart (mode, words[0]));
33430       else if (n_words == 2)
33431         {
33432           rtx tmp = gen_reg_rtx (mode);
33433           emit_clobber (tmp);
33434           emit_move_insn (gen_lowpart (word_mode, tmp), words[0]);
33435           emit_move_insn (gen_highpart (word_mode, tmp), words[1]);
33436           emit_move_insn (target, tmp);
33437         }
33438       else if (n_words == 4)
33439         {
33440           rtx tmp = gen_reg_rtx (V4SImode);
33441           gcc_assert (word_mode == SImode);
33442           vals = gen_rtx_PARALLEL (V4SImode, gen_rtvec_v (4, words));
33443           ix86_expand_vector_init_general (false, V4SImode, tmp, vals);
33444           emit_move_insn (target, gen_lowpart (mode, tmp));
33445         }
33446       else
33447         gcc_unreachable ();
33448     }
33449 }
33450
33451 /* Initialize vector TARGET via VALS.  Suppress the use of MMX
33452    instructions unless MMX_OK is true.  */
33453
33454 void
33455 ix86_expand_vector_init (bool mmx_ok, rtx target, rtx vals)
33456 {
33457   enum machine_mode mode = GET_MODE (target);
33458   enum machine_mode inner_mode = GET_MODE_INNER (mode);
33459   int n_elts = GET_MODE_NUNITS (mode);
33460   int n_var = 0, one_var = -1;
33461   bool all_same = true, all_const_zero = true;
33462   int i;
33463   rtx x;
33464
33465   for (i = 0; i < n_elts; ++i)
33466     {
33467       x = XVECEXP (vals, 0, i);
33468       if (!(CONST_INT_P (x)
33469             || GET_CODE (x) == CONST_DOUBLE
33470             || GET_CODE (x) == CONST_FIXED))
33471         n_var++, one_var = i;
33472       else if (x != CONST0_RTX (inner_mode))
33473         all_const_zero = false;
33474       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
33475         all_same = false;
33476     }
33477
33478   /* Constants are best loaded from the constant pool.  */
33479   if (n_var == 0)
33480     {
33481       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
33482       return;
33483     }
33484
33485   /* If all values are identical, broadcast the value.  */
33486   if (all_same
33487       && ix86_expand_vector_init_duplicate (mmx_ok, mode, target,
33488                                             XVECEXP (vals, 0, 0)))
33489     return;
33490
33491   /* Values where only one field is non-constant are best loaded from
33492      the pool and overwritten via move later.  */
33493   if (n_var == 1)
33494     {
33495       if (all_const_zero
33496           && ix86_expand_vector_init_one_nonzero (mmx_ok, mode, target,
33497                                                   XVECEXP (vals, 0, one_var),
33498                                                   one_var))
33499         return;
33500
33501       if (ix86_expand_vector_init_one_var (mmx_ok, mode, target, vals, one_var))
33502         return;
33503     }
33504
33505   ix86_expand_vector_init_general (mmx_ok, mode, target, vals);
33506 }
33507
33508 void
33509 ix86_expand_vector_set (bool mmx_ok, rtx target, rtx val, int elt)
33510 {
33511   enum machine_mode mode = GET_MODE (target);
33512   enum machine_mode inner_mode = GET_MODE_INNER (mode);
33513   enum machine_mode half_mode;
33514   bool use_vec_merge = false;
33515   rtx tmp;
33516   static rtx (*gen_extract[6][2]) (rtx, rtx)
33517     = {
33518         { gen_vec_extract_lo_v32qi, gen_vec_extract_hi_v32qi },
33519         { gen_vec_extract_lo_v16hi, gen_vec_extract_hi_v16hi },
33520         { gen_vec_extract_lo_v8si, gen_vec_extract_hi_v8si },
33521         { gen_vec_extract_lo_v4di, gen_vec_extract_hi_v4di },
33522         { gen_vec_extract_lo_v8sf, gen_vec_extract_hi_v8sf },
33523         { gen_vec_extract_lo_v4df, gen_vec_extract_hi_v4df }
33524       };
33525   static rtx (*gen_insert[6][2]) (rtx, rtx, rtx)
33526     = {
33527         { gen_vec_set_lo_v32qi, gen_vec_set_hi_v32qi },
33528         { gen_vec_set_lo_v16hi, gen_vec_set_hi_v16hi },
33529         { gen_vec_set_lo_v8si, gen_vec_set_hi_v8si },
33530         { gen_vec_set_lo_v4di, gen_vec_set_hi_v4di },
33531         { gen_vec_set_lo_v8sf, gen_vec_set_hi_v8sf },
33532         { gen_vec_set_lo_v4df, gen_vec_set_hi_v4df }
33533       };
33534   int i, j, n;
33535
33536   switch (mode)
33537     {
33538     case V2SFmode:
33539     case V2SImode:
33540       if (mmx_ok)
33541         {
33542           tmp = gen_reg_rtx (GET_MODE_INNER (mode));
33543           ix86_expand_vector_extract (true, tmp, target, 1 - elt);
33544           if (elt == 0)
33545             tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
33546           else
33547             tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
33548           emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
33549           return;
33550         }
33551       break;
33552
33553     case V2DImode:
33554       use_vec_merge = TARGET_SSE4_1 && TARGET_64BIT;
33555       if (use_vec_merge)
33556         break;
33557
33558       tmp = gen_reg_rtx (GET_MODE_INNER (mode));
33559       ix86_expand_vector_extract (false, tmp, target, 1 - elt);
33560       if (elt == 0)
33561         tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
33562       else
33563         tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
33564       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
33565       return;
33566
33567     case V2DFmode:
33568       {
33569         rtx op0, op1;
33570
33571         /* For the two element vectors, we implement a VEC_CONCAT with
33572            the extraction of the other element.  */
33573
33574         tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (1 - elt)));
33575         tmp = gen_rtx_VEC_SELECT (inner_mode, target, tmp);
33576
33577         if (elt == 0)
33578           op0 = val, op1 = tmp;
33579         else
33580           op0 = tmp, op1 = val;
33581
33582         tmp = gen_rtx_VEC_CONCAT (mode, op0, op1);
33583         emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
33584       }
33585       return;
33586
33587     case V4SFmode:
33588       use_vec_merge = TARGET_SSE4_1;
33589       if (use_vec_merge)
33590         break;
33591
33592       switch (elt)
33593         {
33594         case 0:
33595           use_vec_merge = true;
33596           break;
33597
33598         case 1:
33599           /* tmp = target = A B C D */
33600           tmp = copy_to_reg (target);
33601           /* target = A A B B */
33602           emit_insn (gen_vec_interleave_lowv4sf (target, target, target));
33603           /* target = X A B B */
33604           ix86_expand_vector_set (false, target, val, 0);
33605           /* target = A X C D  */
33606           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
33607                                           const1_rtx, const0_rtx,
33608                                           GEN_INT (2+4), GEN_INT (3+4)));
33609           return;
33610
33611         case 2:
33612           /* tmp = target = A B C D */
33613           tmp = copy_to_reg (target);
33614           /* tmp = X B C D */
33615           ix86_expand_vector_set (false, tmp, val, 0);
33616           /* target = A B X D */
33617           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
33618                                           const0_rtx, const1_rtx,
33619                                           GEN_INT (0+4), GEN_INT (3+4)));
33620           return;
33621
33622         case 3:
33623           /* tmp = target = A B C D */
33624           tmp = copy_to_reg (target);
33625           /* tmp = X B C D */
33626           ix86_expand_vector_set (false, tmp, val, 0);
33627           /* target = A B X D */
33628           emit_insn (gen_sse_shufps_v4sf (target, target, tmp,
33629                                           const0_rtx, const1_rtx,
33630                                           GEN_INT (2+4), GEN_INT (0+4)));
33631           return;
33632
33633         default:
33634           gcc_unreachable ();
33635         }
33636       break;
33637
33638     case V4SImode:
33639       use_vec_merge = TARGET_SSE4_1;
33640       if (use_vec_merge)
33641         break;
33642
33643       /* Element 0 handled by vec_merge below.  */
33644       if (elt == 0)
33645         {
33646           use_vec_merge = true;
33647           break;
33648         }
33649
33650       if (TARGET_SSE2)
33651         {
33652           /* With SSE2, use integer shuffles to swap element 0 and ELT,
33653              store into element 0, then shuffle them back.  */
33654
33655           rtx order[4];
33656
33657           order[0] = GEN_INT (elt);
33658           order[1] = const1_rtx;
33659           order[2] = const2_rtx;
33660           order[3] = GEN_INT (3);
33661           order[elt] = const0_rtx;
33662
33663           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
33664                                         order[1], order[2], order[3]));
33665
33666           ix86_expand_vector_set (false, target, val, 0);
33667
33668           emit_insn (gen_sse2_pshufd_1 (target, target, order[0],
33669                                         order[1], order[2], order[3]));
33670         }
33671       else
33672         {
33673           /* For SSE1, we have to reuse the V4SF code.  */
33674           ix86_expand_vector_set (false, gen_lowpart (V4SFmode, target),
33675                                   gen_lowpart (SFmode, val), elt);
33676         }
33677       return;
33678
33679     case V8HImode:
33680       use_vec_merge = TARGET_SSE2;
33681       break;
33682     case V4HImode:
33683       use_vec_merge = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
33684       break;
33685
33686     case V16QImode:
33687       use_vec_merge = TARGET_SSE4_1;
33688       break;
33689
33690     case V8QImode:
33691       break;
33692
33693     case V32QImode:
33694       half_mode = V16QImode;
33695       j = 0;
33696       n = 16;
33697       goto half;
33698
33699     case V16HImode:
33700       half_mode = V8HImode;
33701       j = 1;
33702       n = 8;
33703       goto half;
33704
33705     case V8SImode:
33706       half_mode = V4SImode;
33707       j = 2;
33708       n = 4;
33709       goto half;
33710
33711     case V4DImode:
33712       half_mode = V2DImode;
33713       j = 3;
33714       n = 2;
33715       goto half;
33716
33717     case V8SFmode:
33718       half_mode = V4SFmode;
33719       j = 4;
33720       n = 4;
33721       goto half;
33722
33723     case V4DFmode:
33724       half_mode = V2DFmode;
33725       j = 5;
33726       n = 2;
33727       goto half;
33728
33729 half:
33730       /* Compute offset.  */
33731       i = elt / n;
33732       elt %= n;
33733
33734       gcc_assert (i <= 1);
33735
33736       /* Extract the half.  */
33737       tmp = gen_reg_rtx (half_mode);
33738       emit_insn (gen_extract[j][i] (tmp, target));
33739
33740       /* Put val in tmp at elt.  */
33741       ix86_expand_vector_set (false, tmp, val, elt);
33742
33743       /* Put it back.  */
33744       emit_insn (gen_insert[j][i] (target, target, tmp));
33745       return;
33746
33747     default:
33748       break;
33749     }
33750
33751   if (use_vec_merge)
33752     {
33753       tmp = gen_rtx_VEC_DUPLICATE (mode, val);
33754       tmp = gen_rtx_VEC_MERGE (mode, tmp, target, GEN_INT (1 << elt));
33755       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
33756     }
33757   else
33758     {
33759       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
33760
33761       emit_move_insn (mem, target);
33762
33763       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
33764       emit_move_insn (tmp, val);
33765
33766       emit_move_insn (target, mem);
33767     }
33768 }
33769
33770 void
33771 ix86_expand_vector_extract (bool mmx_ok, rtx target, rtx vec, int elt)
33772 {
33773   enum machine_mode mode = GET_MODE (vec);
33774   enum machine_mode inner_mode = GET_MODE_INNER (mode);
33775   bool use_vec_extr = false;
33776   rtx tmp;
33777
33778   switch (mode)
33779     {
33780     case V2SImode:
33781     case V2SFmode:
33782       if (!mmx_ok)
33783         break;
33784       /* FALLTHRU */
33785
33786     case V2DFmode:
33787     case V2DImode:
33788       use_vec_extr = true;
33789       break;
33790
33791     case V4SFmode:
33792       use_vec_extr = TARGET_SSE4_1;
33793       if (use_vec_extr)
33794         break;
33795
33796       switch (elt)
33797         {
33798         case 0:
33799           tmp = vec;
33800           break;
33801
33802         case 1:
33803         case 3:
33804           tmp = gen_reg_rtx (mode);
33805           emit_insn (gen_sse_shufps_v4sf (tmp, vec, vec,
33806                                        GEN_INT (elt), GEN_INT (elt),
33807                                        GEN_INT (elt+4), GEN_INT (elt+4)));
33808           break;
33809
33810         case 2:
33811           tmp = gen_reg_rtx (mode);
33812           emit_insn (gen_vec_interleave_highv4sf (tmp, vec, vec));
33813           break;
33814
33815         default:
33816           gcc_unreachable ();
33817         }
33818       vec = tmp;
33819       use_vec_extr = true;
33820       elt = 0;
33821       break;
33822
33823     case V4SImode:
33824       use_vec_extr = TARGET_SSE4_1;
33825       if (use_vec_extr)
33826         break;
33827
33828       if (TARGET_SSE2)
33829         {
33830           switch (elt)
33831             {
33832             case 0:
33833               tmp = vec;
33834               break;
33835
33836             case 1:
33837             case 3:
33838               tmp = gen_reg_rtx (mode);
33839               emit_insn (gen_sse2_pshufd_1 (tmp, vec,
33840                                             GEN_INT (elt), GEN_INT (elt),
33841                                             GEN_INT (elt), GEN_INT (elt)));
33842               break;
33843
33844             case 2:
33845               tmp = gen_reg_rtx (mode);
33846               emit_insn (gen_vec_interleave_highv4si (tmp, vec, vec));
33847               break;
33848
33849             default:
33850               gcc_unreachable ();
33851             }
33852           vec = tmp;
33853           use_vec_extr = true;
33854           elt = 0;
33855         }
33856       else
33857         {
33858           /* For SSE1, we have to reuse the V4SF code.  */
33859           ix86_expand_vector_extract (false, gen_lowpart (SFmode, target),
33860                                       gen_lowpart (V4SFmode, vec), elt);
33861           return;
33862         }
33863       break;
33864
33865     case V8HImode:
33866       use_vec_extr = TARGET_SSE2;
33867       break;
33868     case V4HImode:
33869       use_vec_extr = mmx_ok && (TARGET_SSE || TARGET_3DNOW_A);
33870       break;
33871
33872     case V16QImode:
33873       use_vec_extr = TARGET_SSE4_1;
33874       break;
33875
33876     case V8SFmode:
33877       if (TARGET_AVX)
33878         {
33879           tmp = gen_reg_rtx (V4SFmode);
33880           if (elt < 4)
33881             emit_insn (gen_vec_extract_lo_v8sf (tmp, vec));
33882           else
33883             emit_insn (gen_vec_extract_hi_v8sf (tmp, vec));
33884           ix86_expand_vector_extract (false, target, tmp, elt & 3);
33885           return;
33886         }
33887       break;
33888
33889     case V4DFmode:
33890       if (TARGET_AVX)
33891         {
33892           tmp = gen_reg_rtx (V2DFmode);
33893           if (elt < 2)
33894             emit_insn (gen_vec_extract_lo_v4df (tmp, vec));
33895           else
33896             emit_insn (gen_vec_extract_hi_v4df (tmp, vec));
33897           ix86_expand_vector_extract (false, target, tmp, elt & 1);
33898           return;
33899         }
33900       break;
33901
33902     case V32QImode:
33903       if (TARGET_AVX)
33904         {
33905           tmp = gen_reg_rtx (V16QImode);
33906           if (elt < 16)
33907             emit_insn (gen_vec_extract_lo_v32qi (tmp, vec));
33908           else
33909             emit_insn (gen_vec_extract_hi_v32qi (tmp, vec));
33910           ix86_expand_vector_extract (false, target, tmp, elt & 15);
33911           return;
33912         }
33913       break;
33914
33915     case V16HImode:
33916       if (TARGET_AVX)
33917         {
33918           tmp = gen_reg_rtx (V8HImode);
33919           if (elt < 8)
33920             emit_insn (gen_vec_extract_lo_v16hi (tmp, vec));
33921           else
33922             emit_insn (gen_vec_extract_hi_v16hi (tmp, vec));
33923           ix86_expand_vector_extract (false, target, tmp, elt & 7);
33924           return;
33925         }
33926       break;
33927
33928     case V8SImode:
33929       if (TARGET_AVX)
33930         {
33931           tmp = gen_reg_rtx (V4SImode);
33932           if (elt < 4)
33933             emit_insn (gen_vec_extract_lo_v8si (tmp, vec));
33934           else
33935             emit_insn (gen_vec_extract_hi_v8si (tmp, vec));
33936           ix86_expand_vector_extract (false, target, tmp, elt & 3);
33937           return;
33938         }
33939       break;
33940
33941     case V4DImode:
33942       if (TARGET_AVX)
33943         {
33944           tmp = gen_reg_rtx (V2DImode);
33945           if (elt < 2)
33946             emit_insn (gen_vec_extract_lo_v4di (tmp, vec));
33947           else
33948             emit_insn (gen_vec_extract_hi_v4di (tmp, vec));
33949           ix86_expand_vector_extract (false, target, tmp, elt & 1);
33950           return;
33951         }
33952       break;
33953
33954     case V8QImode:
33955       /* ??? Could extract the appropriate HImode element and shift.  */
33956     default:
33957       break;
33958     }
33959
33960   if (use_vec_extr)
33961     {
33962       tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (elt)));
33963       tmp = gen_rtx_VEC_SELECT (inner_mode, vec, tmp);
33964
33965       /* Let the rtl optimizers know about the zero extension performed.  */
33966       if (inner_mode == QImode || inner_mode == HImode)
33967         {
33968           tmp = gen_rtx_ZERO_EXTEND (SImode, tmp);
33969           target = gen_lowpart (SImode, target);
33970         }
33971
33972       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
33973     }
33974   else
33975     {
33976       rtx mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), false);
33977
33978       emit_move_insn (mem, vec);
33979
33980       tmp = adjust_address (mem, inner_mode, elt*GET_MODE_SIZE (inner_mode));
33981       emit_move_insn (target, tmp);
33982     }
33983 }
33984
33985 /* Generate code to copy vector bits i / 2 ... i - 1 from vector SRC
33986    to bits 0 ... i / 2 - 1 of vector DEST, which has the same mode.
33987    The upper bits of DEST are undefined, though they shouldn't cause
33988    exceptions (some bits from src or all zeros are ok).  */
33989
33990 static void
33991 emit_reduc_half (rtx dest, rtx src, int i)
33992 {
33993   rtx tem;
33994   switch (GET_MODE (src))
33995     {
33996     case V4SFmode:
33997       if (i == 128)
33998         tem = gen_sse_movhlps (dest, src, src);
33999       else
34000         tem = gen_sse_shufps_v4sf (dest, src, src, const1_rtx, const1_rtx,
34001                                    GEN_INT (1 + 4), GEN_INT (1 + 4));
34002       break;
34003     case V2DFmode:
34004       tem = gen_vec_interleave_highv2df (dest, src, src);
34005       break;
34006     case V16QImode:
34007     case V8HImode:
34008     case V4SImode:
34009     case V2DImode:
34010       tem = gen_sse2_lshrv1ti3 (gen_lowpart (V1TImode, dest),
34011                                 gen_lowpart (V1TImode, src),
34012                                 GEN_INT (i / 2));
34013       break;
34014     case V8SFmode:
34015       if (i == 256)
34016         tem = gen_avx_vperm2f128v8sf3 (dest, src, src, const1_rtx);
34017       else
34018         tem = gen_avx_shufps256 (dest, src, src,
34019                                  GEN_INT (i == 128 ? 2 + (3 << 2) : 1));
34020       break;
34021     case V4DFmode:
34022       if (i == 256)
34023         tem = gen_avx_vperm2f128v4df3 (dest, src, src, const1_rtx);
34024       else
34025         tem = gen_avx_shufpd256 (dest, src, src, const1_rtx);
34026       break;
34027     case V32QImode:
34028     case V16HImode:
34029     case V8SImode:
34030     case V4DImode:
34031       if (i == 256)
34032         tem = gen_avx2_permv2ti (gen_lowpart (V4DImode, dest),
34033                                  gen_lowpart (V4DImode, src),
34034                                  gen_lowpart (V4DImode, src),
34035                                  const1_rtx);
34036       else
34037         tem = gen_avx2_lshrv2ti3 (gen_lowpart (V2TImode, dest),
34038                                   gen_lowpart (V2TImode, src),
34039                                   GEN_INT (i / 2));
34040       break;
34041     default:
34042       gcc_unreachable ();
34043     }
34044   emit_insn (tem);
34045 }
34046
34047 /* Expand a vector reduction.  FN is the binary pattern to reduce;
34048    DEST is the destination; IN is the input vector.  */
34049
34050 void
34051 ix86_expand_reduc (rtx (*fn) (rtx, rtx, rtx), rtx dest, rtx in)
34052 {
34053   rtx half, dst, vec = in;
34054   enum machine_mode mode = GET_MODE (in);
34055   int i;
34056
34057   /* SSE4 has a special instruction for V8HImode UMIN reduction.  */
34058   if (TARGET_SSE4_1
34059       && mode == V8HImode
34060       && fn == gen_uminv8hi3)
34061     {
34062       emit_insn (gen_sse4_1_phminposuw (dest, in));
34063       return;
34064     }
34065
34066   for (i = GET_MODE_BITSIZE (mode);
34067        i > GET_MODE_BITSIZE (GET_MODE_INNER (mode));
34068        i >>= 1)
34069     {
34070       half = gen_reg_rtx (mode);
34071       emit_reduc_half (half, vec, i);
34072       if (i == GET_MODE_BITSIZE (GET_MODE_INNER (mode)) * 2)
34073         dst = dest;
34074       else
34075         dst = gen_reg_rtx (mode);
34076       emit_insn (fn (dst, half, vec));
34077       vec = dst;
34078     }
34079 }
34080 \f
34081 /* Target hook for scalar_mode_supported_p.  */
34082 static bool
34083 ix86_scalar_mode_supported_p (enum machine_mode mode)
34084 {
34085   if (DECIMAL_FLOAT_MODE_P (mode))
34086     return default_decimal_float_supported_p ();
34087   else if (mode == TFmode)
34088     return true;
34089   else
34090     return default_scalar_mode_supported_p (mode);
34091 }
34092
34093 /* Implements target hook vector_mode_supported_p.  */
34094 static bool
34095 ix86_vector_mode_supported_p (enum machine_mode mode)
34096 {
34097   if (TARGET_SSE && VALID_SSE_REG_MODE (mode))
34098     return true;
34099   if (TARGET_SSE2 && VALID_SSE2_REG_MODE (mode))
34100     return true;
34101   if (TARGET_AVX && VALID_AVX256_REG_MODE (mode))
34102     return true;
34103   if (TARGET_MMX && VALID_MMX_REG_MODE (mode))
34104     return true;
34105   if (TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW (mode))
34106     return true;
34107   return false;
34108 }
34109
34110 /* Target hook for c_mode_for_suffix.  */
34111 static enum machine_mode
34112 ix86_c_mode_for_suffix (char suffix)
34113 {
34114   if (suffix == 'q')
34115     return TFmode;
34116   if (suffix == 'w')
34117     return XFmode;
34118
34119   return VOIDmode;
34120 }
34121
34122 /* Worker function for TARGET_MD_ASM_CLOBBERS.
34123
34124    We do this in the new i386 backend to maintain source compatibility
34125    with the old cc0-based compiler.  */
34126
34127 static tree
34128 ix86_md_asm_clobbers (tree outputs ATTRIBUTE_UNUSED,
34129                       tree inputs ATTRIBUTE_UNUSED,
34130                       tree clobbers)
34131 {
34132   clobbers = tree_cons (NULL_TREE, build_string (5, "flags"),
34133                         clobbers);
34134   clobbers = tree_cons (NULL_TREE, build_string (4, "fpsr"),
34135                         clobbers);
34136   return clobbers;
34137 }
34138
34139 /* Implements target vector targetm.asm.encode_section_info.  */
34140
34141 static void ATTRIBUTE_UNUSED
34142 ix86_encode_section_info (tree decl, rtx rtl, int first)
34143 {
34144   default_encode_section_info (decl, rtl, first);
34145
34146   if (TREE_CODE (decl) == VAR_DECL
34147       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
34148       && ix86_in_large_data_p (decl))
34149     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_FAR_ADDR;
34150 }
34151
34152 /* Worker function for REVERSE_CONDITION.  */
34153
34154 enum rtx_code
34155 ix86_reverse_condition (enum rtx_code code, enum machine_mode mode)
34156 {
34157   return (mode != CCFPmode && mode != CCFPUmode
34158           ? reverse_condition (code)
34159           : reverse_condition_maybe_unordered (code));
34160 }
34161
34162 /* Output code to perform an x87 FP register move, from OPERANDS[1]
34163    to OPERANDS[0].  */
34164
34165 const char *
34166 output_387_reg_move (rtx insn, rtx *operands)
34167 {
34168   if (REG_P (operands[0]))
34169     {
34170       if (REG_P (operands[1])
34171           && find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
34172         {
34173           if (REGNO (operands[0]) == FIRST_STACK_REG)
34174             return output_387_ffreep (operands, 0);
34175           return "fstp\t%y0";
34176         }
34177       if (STACK_TOP_P (operands[0]))
34178         return "fld%Z1\t%y1";
34179       return "fst\t%y0";
34180     }
34181   else if (MEM_P (operands[0]))
34182     {
34183       gcc_assert (REG_P (operands[1]));
34184       if (find_regno_note (insn, REG_DEAD, REGNO (operands[1])))
34185         return "fstp%Z0\t%y0";
34186       else
34187         {
34188           /* There is no non-popping store to memory for XFmode.
34189              So if we need one, follow the store with a load.  */
34190           if (GET_MODE (operands[0]) == XFmode)
34191             return "fstp%Z0\t%y0\n\tfld%Z0\t%y0";
34192           else
34193             return "fst%Z0\t%y0";
34194         }
34195     }
34196   else
34197     gcc_unreachable();
34198 }
34199
34200 /* Output code to perform a conditional jump to LABEL, if C2 flag in
34201    FP status register is set.  */
34202
34203 void
34204 ix86_emit_fp_unordered_jump (rtx label)
34205 {
34206   rtx reg = gen_reg_rtx (HImode);
34207   rtx temp;
34208
34209   emit_insn (gen_x86_fnstsw_1 (reg));
34210
34211   if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ()))
34212     {
34213       emit_insn (gen_x86_sahf_1 (reg));
34214
34215       temp = gen_rtx_REG (CCmode, FLAGS_REG);
34216       temp = gen_rtx_UNORDERED (VOIDmode, temp, const0_rtx);
34217     }
34218   else
34219     {
34220       emit_insn (gen_testqi_ext_ccno_0 (reg, GEN_INT (0x04)));
34221
34222       temp = gen_rtx_REG (CCNOmode, FLAGS_REG);
34223       temp = gen_rtx_NE (VOIDmode, temp, const0_rtx);
34224     }
34225
34226   temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
34227                               gen_rtx_LABEL_REF (VOIDmode, label),
34228                               pc_rtx);
34229   temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
34230
34231   emit_jump_insn (temp);
34232   predict_jump (REG_BR_PROB_BASE * 10 / 100);
34233 }
34234
34235 /* Output code to perform a log1p XFmode calculation.  */
34236
34237 void ix86_emit_i387_log1p (rtx op0, rtx op1)
34238 {
34239   rtx label1 = gen_label_rtx ();
34240   rtx label2 = gen_label_rtx ();
34241
34242   rtx tmp = gen_reg_rtx (XFmode);
34243   rtx tmp2 = gen_reg_rtx (XFmode);
34244   rtx test;
34245
34246   emit_insn (gen_absxf2 (tmp, op1));
34247   test = gen_rtx_GE (VOIDmode, tmp,
34248     CONST_DOUBLE_FROM_REAL_VALUE (
34249        REAL_VALUE_ATOF ("0.29289321881345247561810596348408353", XFmode),
34250        XFmode));
34251   emit_jump_insn (gen_cbranchxf4 (test, XEXP (test, 0), XEXP (test, 1), label1));
34252
34253   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
34254   emit_insn (gen_fyl2xp1xf3_i387 (op0, op1, tmp2));
34255   emit_jump (label2);
34256
34257   emit_label (label1);
34258   emit_move_insn (tmp, CONST1_RTX (XFmode));
34259   emit_insn (gen_addxf3 (tmp, op1, tmp));
34260   emit_move_insn (tmp2, standard_80387_constant_rtx (4)); /* fldln2 */
34261   emit_insn (gen_fyl2xxf3_i387 (op0, tmp, tmp2));
34262
34263   emit_label (label2);
34264 }
34265
34266 /* Emit code for round calculation.  */
34267 void ix86_emit_i387_round (rtx op0, rtx op1)
34268 {
34269   enum machine_mode inmode = GET_MODE (op1);
34270   enum machine_mode outmode = GET_MODE (op0);
34271   rtx e1, e2, res, tmp, tmp1, half;
34272   rtx scratch = gen_reg_rtx (HImode);
34273   rtx flags = gen_rtx_REG (CCNOmode, FLAGS_REG);
34274   rtx jump_label = gen_label_rtx ();
34275   rtx insn;
34276   rtx (*gen_abs) (rtx, rtx);
34277   rtx (*gen_neg) (rtx, rtx);
34278
34279   switch (inmode)
34280     {
34281     case SFmode:
34282       gen_abs = gen_abssf2;
34283       break;
34284     case DFmode:
34285       gen_abs = gen_absdf2;
34286       break;
34287     case XFmode:
34288       gen_abs = gen_absxf2;
34289       break;
34290     default:
34291       gcc_unreachable ();
34292     }
34293
34294   switch (outmode)
34295     {
34296     case SFmode:
34297       gen_neg = gen_negsf2;
34298       break;
34299     case DFmode:
34300       gen_neg = gen_negdf2;
34301       break;
34302     case XFmode:
34303       gen_neg = gen_negxf2;
34304       break;
34305     case HImode:
34306       gen_neg = gen_neghi2;
34307       break;
34308     case SImode:
34309       gen_neg = gen_negsi2;
34310       break;
34311     case DImode:
34312       gen_neg = gen_negdi2;
34313       break;
34314     default:
34315       gcc_unreachable ();
34316     }
34317
34318   e1 = gen_reg_rtx (inmode);
34319   e2 = gen_reg_rtx (inmode);
34320   res = gen_reg_rtx (outmode);
34321
34322   half = CONST_DOUBLE_FROM_REAL_VALUE (dconsthalf, inmode);
34323
34324   /* round(a) = sgn(a) * floor(fabs(a) + 0.5) */
34325
34326   /* scratch = fxam(op1) */
34327   emit_insn (gen_rtx_SET (VOIDmode, scratch,
34328                           gen_rtx_UNSPEC (HImode, gen_rtvec (1, op1),
34329                                           UNSPEC_FXAM)));
34330   /* e1 = fabs(op1) */
34331   emit_insn (gen_abs (e1, op1));
34332
34333   /* e2 = e1 + 0.5 */
34334   half = force_reg (inmode, half);
34335   emit_insn (gen_rtx_SET (VOIDmode, e2,
34336                           gen_rtx_PLUS (inmode, e1, half)));
34337
34338   /* res = floor(e2) */
34339   if (inmode != XFmode)
34340     {
34341       tmp1 = gen_reg_rtx (XFmode);
34342
34343       emit_insn (gen_rtx_SET (VOIDmode, tmp1,
34344                               gen_rtx_FLOAT_EXTEND (XFmode, e2)));
34345     }
34346   else
34347     tmp1 = e2;
34348
34349   switch (outmode)
34350     {
34351     case SFmode:
34352     case DFmode:
34353       {
34354         rtx tmp0 = gen_reg_rtx (XFmode);
34355
34356         emit_insn (gen_frndintxf2_floor (tmp0, tmp1));
34357
34358         emit_insn (gen_rtx_SET (VOIDmode, res,
34359                                 gen_rtx_UNSPEC (outmode, gen_rtvec (1, tmp0),
34360                                                 UNSPEC_TRUNC_NOOP)));
34361       }
34362       break;
34363     case XFmode:
34364       emit_insn (gen_frndintxf2_floor (res, tmp1));
34365       break;
34366     case HImode:
34367       emit_insn (gen_lfloorxfhi2 (res, tmp1));
34368       break;
34369     case SImode:
34370       emit_insn (gen_lfloorxfsi2 (res, tmp1));
34371       break;
34372     case DImode:
34373       emit_insn (gen_lfloorxfdi2 (res, tmp1));
34374         break;
34375     default:
34376       gcc_unreachable ();
34377     }
34378
34379   /* flags = signbit(a) */
34380   emit_insn (gen_testqi_ext_ccno_0 (scratch, GEN_INT (0x02)));
34381
34382   /* if (flags) then res = -res */
34383   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode,
34384                               gen_rtx_EQ (VOIDmode, flags, const0_rtx),
34385                               gen_rtx_LABEL_REF (VOIDmode, jump_label),
34386                               pc_rtx);
34387   insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
34388   predict_jump (REG_BR_PROB_BASE * 50 / 100);
34389   JUMP_LABEL (insn) = jump_label;
34390
34391   emit_insn (gen_neg (res, res));
34392
34393   emit_label (jump_label);
34394   LABEL_NUSES (jump_label) = 1;
34395
34396   emit_move_insn (op0, res);
34397 }
34398
34399 /* Output code to perform a Newton-Rhapson approximation of a single precision
34400    floating point divide [http://en.wikipedia.org/wiki/N-th_root_algorithm].  */
34401
34402 void ix86_emit_swdivsf (rtx res, rtx a, rtx b, enum machine_mode mode)
34403 {
34404   rtx x0, x1, e0, e1;
34405
34406   x0 = gen_reg_rtx (mode);
34407   e0 = gen_reg_rtx (mode);
34408   e1 = gen_reg_rtx (mode);
34409   x1 = gen_reg_rtx (mode);
34410
34411   /* a / b = a * ((rcp(b) + rcp(b)) - (b * rcp(b) * rcp (b))) */
34412
34413   b = force_reg (mode, b);
34414
34415   /* x0 = rcp(b) estimate */
34416   emit_insn (gen_rtx_SET (VOIDmode, x0,
34417                           gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
34418                                           UNSPEC_RCP)));
34419   /* e0 = x0 * b */
34420   emit_insn (gen_rtx_SET (VOIDmode, e0,
34421                           gen_rtx_MULT (mode, x0, b)));
34422
34423   /* e0 = x0 * e0 */
34424   emit_insn (gen_rtx_SET (VOIDmode, e0,
34425                           gen_rtx_MULT (mode, x0, e0)));
34426
34427   /* e1 = x0 + x0 */
34428   emit_insn (gen_rtx_SET (VOIDmode, e1,
34429                           gen_rtx_PLUS (mode, x0, x0)));
34430
34431   /* x1 = e1 - e0 */
34432   emit_insn (gen_rtx_SET (VOIDmode, x1,
34433                           gen_rtx_MINUS (mode, e1, e0)));
34434
34435   /* res = a * x1 */
34436   emit_insn (gen_rtx_SET (VOIDmode, res,
34437                           gen_rtx_MULT (mode, a, x1)));
34438 }
34439
34440 /* Output code to perform a Newton-Rhapson approximation of a
34441    single precision floating point [reciprocal] square root.  */
34442
34443 void ix86_emit_swsqrtsf (rtx res, rtx a, enum machine_mode mode,
34444                          bool recip)
34445 {
34446   rtx x0, e0, e1, e2, e3, mthree, mhalf;
34447   REAL_VALUE_TYPE r;
34448
34449   x0 = gen_reg_rtx (mode);
34450   e0 = gen_reg_rtx (mode);
34451   e1 = gen_reg_rtx (mode);
34452   e2 = gen_reg_rtx (mode);
34453   e3 = gen_reg_rtx (mode);
34454
34455   real_from_integer (&r, VOIDmode, -3, -1, 0);
34456   mthree = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
34457
34458   real_arithmetic (&r, NEGATE_EXPR, &dconsthalf, NULL);
34459   mhalf = CONST_DOUBLE_FROM_REAL_VALUE (r, SFmode);
34460
34461   if (VECTOR_MODE_P (mode))
34462     {
34463       mthree = ix86_build_const_vector (mode, true, mthree);
34464       mhalf = ix86_build_const_vector (mode, true, mhalf);
34465     }
34466
34467   /* sqrt(a)  = -0.5 * a * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0)
34468      rsqrt(a) = -0.5     * rsqrtss(a) * (a * rsqrtss(a) * rsqrtss(a) - 3.0) */
34469
34470   a = force_reg (mode, a);
34471
34472   /* x0 = rsqrt(a) estimate */
34473   emit_insn (gen_rtx_SET (VOIDmode, x0,
34474                           gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
34475                                           UNSPEC_RSQRT)));
34476
34477   /* If (a == 0.0) Filter out infinity to prevent NaN for sqrt(0.0).  */
34478   if (!recip)
34479     {
34480       rtx zero, mask;
34481
34482       zero = gen_reg_rtx (mode);
34483       mask = gen_reg_rtx (mode);
34484
34485       zero = force_reg (mode, CONST0_RTX(mode));
34486       emit_insn (gen_rtx_SET (VOIDmode, mask,
34487                               gen_rtx_NE (mode, zero, a)));
34488
34489       emit_insn (gen_rtx_SET (VOIDmode, x0,
34490                               gen_rtx_AND (mode, x0, mask)));
34491     }
34492
34493   /* e0 = x0 * a */
34494   emit_insn (gen_rtx_SET (VOIDmode, e0,
34495                           gen_rtx_MULT (mode, x0, a)));
34496   /* e1 = e0 * x0 */
34497   emit_insn (gen_rtx_SET (VOIDmode, e1,
34498                           gen_rtx_MULT (mode, e0, x0)));
34499
34500   /* e2 = e1 - 3. */
34501   mthree = force_reg (mode, mthree);
34502   emit_insn (gen_rtx_SET (VOIDmode, e2,
34503                           gen_rtx_PLUS (mode, e1, mthree)));
34504
34505   mhalf = force_reg (mode, mhalf);
34506   if (recip)
34507     /* e3 = -.5 * x0 */
34508     emit_insn (gen_rtx_SET (VOIDmode, e3,
34509                             gen_rtx_MULT (mode, x0, mhalf)));
34510   else
34511     /* e3 = -.5 * e0 */
34512     emit_insn (gen_rtx_SET (VOIDmode, e3,
34513                             gen_rtx_MULT (mode, e0, mhalf)));
34514   /* ret = e2 * e3 */
34515   emit_insn (gen_rtx_SET (VOIDmode, res,
34516                           gen_rtx_MULT (mode, e2, e3)));
34517 }
34518
34519 #ifdef TARGET_SOLARIS
34520 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
34521
34522 static void
34523 i386_solaris_elf_named_section (const char *name, unsigned int flags,
34524                                 tree decl)
34525 {
34526   /* With Binutils 2.15, the "@unwind" marker must be specified on
34527      every occurrence of the ".eh_frame" section, not just the first
34528      one.  */
34529   if (TARGET_64BIT
34530       && strcmp (name, ".eh_frame") == 0)
34531     {
34532       fprintf (asm_out_file, "\t.section\t%s,\"%s\",@unwind\n", name,
34533                flags & SECTION_WRITE ? "aw" : "a");
34534       return;
34535     }
34536
34537 #ifndef USE_GAS
34538   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
34539     {
34540       solaris_elf_asm_comdat_section (name, flags, decl);
34541       return;
34542     }
34543 #endif
34544
34545   default_elf_asm_named_section (name, flags, decl);
34546 }
34547 #endif /* TARGET_SOLARIS */
34548
34549 /* Return the mangling of TYPE if it is an extended fundamental type.  */
34550
34551 static const char *
34552 ix86_mangle_type (const_tree type)
34553 {
34554   type = TYPE_MAIN_VARIANT (type);
34555
34556   if (TREE_CODE (type) != VOID_TYPE && TREE_CODE (type) != BOOLEAN_TYPE
34557       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
34558     return NULL;
34559
34560   switch (TYPE_MODE (type))
34561     {
34562     case TFmode:
34563       /* __float128 is "g".  */
34564       return "g";
34565     case XFmode:
34566       /* "long double" or __float80 is "e".  */
34567       return "e";
34568     default:
34569       return NULL;
34570     }
34571 }
34572
34573 /* For 32-bit code we can save PIC register setup by using
34574    __stack_chk_fail_local hidden function instead of calling
34575    __stack_chk_fail directly.  64-bit code doesn't need to setup any PIC
34576    register, so it is better to call __stack_chk_fail directly.  */
34577
34578 static tree ATTRIBUTE_UNUSED
34579 ix86_stack_protect_fail (void)
34580 {
34581   return TARGET_64BIT
34582          ? default_external_stack_protect_fail ()
34583          : default_hidden_stack_protect_fail ();
34584 }
34585
34586 /* Select a format to encode pointers in exception handling data.  CODE
34587    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
34588    true if the symbol may be affected by dynamic relocations.
34589
34590    ??? All x86 object file formats are capable of representing this.
34591    After all, the relocation needed is the same as for the call insn.
34592    Whether or not a particular assembler allows us to enter such, I
34593    guess we'll have to see.  */
34594 int
34595 asm_preferred_eh_data_format (int code, int global)
34596 {
34597   if (flag_pic)
34598     {
34599       int type = DW_EH_PE_sdata8;
34600       if (!TARGET_64BIT
34601           || ix86_cmodel == CM_SMALL_PIC
34602           || (ix86_cmodel == CM_MEDIUM_PIC && (global || code)))
34603         type = DW_EH_PE_sdata4;
34604       return (global ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | type;
34605     }
34606   if (ix86_cmodel == CM_SMALL
34607       || (ix86_cmodel == CM_MEDIUM && code))
34608     return DW_EH_PE_udata4;
34609   return DW_EH_PE_absptr;
34610 }
34611 \f
34612 /* Expand copysign from SIGN to the positive value ABS_VALUE
34613    storing in RESULT.  If MASK is non-null, it shall be a mask to mask out
34614    the sign-bit.  */
34615 static void
34616 ix86_sse_copysign_to_positive (rtx result, rtx abs_value, rtx sign, rtx mask)
34617 {
34618   enum machine_mode mode = GET_MODE (sign);
34619   rtx sgn = gen_reg_rtx (mode);
34620   if (mask == NULL_RTX)
34621     {
34622       enum machine_mode vmode;
34623
34624       if (mode == SFmode)
34625         vmode = V4SFmode;
34626       else if (mode == DFmode)
34627         vmode = V2DFmode;
34628       else
34629         vmode = mode;
34630
34631       mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), false);
34632       if (!VECTOR_MODE_P (mode))
34633         {
34634           /* We need to generate a scalar mode mask in this case.  */
34635           rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
34636           tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
34637           mask = gen_reg_rtx (mode);
34638           emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
34639         }
34640     }
34641   else
34642     mask = gen_rtx_NOT (mode, mask);
34643   emit_insn (gen_rtx_SET (VOIDmode, sgn,
34644                           gen_rtx_AND (mode, mask, sign)));
34645   emit_insn (gen_rtx_SET (VOIDmode, result,
34646                           gen_rtx_IOR (mode, abs_value, sgn)));
34647 }
34648
34649 /* Expand fabs (OP0) and return a new rtx that holds the result.  The
34650    mask for masking out the sign-bit is stored in *SMASK, if that is
34651    non-null.  */
34652 static rtx
34653 ix86_expand_sse_fabs (rtx op0, rtx *smask)
34654 {
34655   enum machine_mode vmode, mode = GET_MODE (op0);
34656   rtx xa, mask;
34657
34658   xa = gen_reg_rtx (mode);
34659   if (mode == SFmode)
34660     vmode = V4SFmode;
34661   else if (mode == DFmode)
34662     vmode = V2DFmode;
34663   else
34664     vmode = mode;
34665   mask = ix86_build_signbit_mask (vmode, VECTOR_MODE_P (mode), true);
34666   if (!VECTOR_MODE_P (mode))
34667     {
34668       /* We need to generate a scalar mode mask in this case.  */
34669       rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
34670       tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
34671       mask = gen_reg_rtx (mode);
34672       emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
34673     }
34674   emit_insn (gen_rtx_SET (VOIDmode, xa,
34675                           gen_rtx_AND (mode, op0, mask)));
34676
34677   if (smask)
34678     *smask = mask;
34679
34680   return xa;
34681 }
34682
34683 /* Expands a comparison of OP0 with OP1 using comparison code CODE,
34684    swapping the operands if SWAP_OPERANDS is true.  The expanded
34685    code is a forward jump to a newly created label in case the
34686    comparison is true.  The generated label rtx is returned.  */
34687 static rtx
34688 ix86_expand_sse_compare_and_jump (enum rtx_code code, rtx op0, rtx op1,
34689                                   bool swap_operands)
34690 {
34691   rtx label, tmp;
34692
34693   if (swap_operands)
34694     {
34695       tmp = op0;
34696       op0 = op1;
34697       op1 = tmp;
34698     }
34699
34700   label = gen_label_rtx ();
34701   tmp = gen_rtx_REG (CCFPUmode, FLAGS_REG);
34702   emit_insn (gen_rtx_SET (VOIDmode, tmp,
34703                           gen_rtx_COMPARE (CCFPUmode, op0, op1)));
34704   tmp = gen_rtx_fmt_ee (code, VOIDmode, tmp, const0_rtx);
34705   tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
34706                               gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
34707   tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
34708   JUMP_LABEL (tmp) = label;
34709
34710   return label;
34711 }
34712
34713 /* Expand a mask generating SSE comparison instruction comparing OP0 with OP1
34714    using comparison code CODE.  Operands are swapped for the comparison if
34715    SWAP_OPERANDS is true.  Returns a rtx for the generated mask.  */
34716 static rtx
34717 ix86_expand_sse_compare_mask (enum rtx_code code, rtx op0, rtx op1,
34718                               bool swap_operands)
34719 {
34720   rtx (*insn)(rtx, rtx, rtx, rtx);
34721   enum machine_mode mode = GET_MODE (op0);
34722   rtx mask = gen_reg_rtx (mode);
34723
34724   if (swap_operands)
34725     {
34726       rtx tmp = op0;
34727       op0 = op1;
34728       op1 = tmp;
34729     }
34730
34731   insn = mode == DFmode ? gen_setcc_df_sse : gen_setcc_sf_sse;
34732
34733   emit_insn (insn (mask, op0, op1,
34734                    gen_rtx_fmt_ee (code, mode, op0, op1)));
34735   return mask;
34736 }
34737
34738 /* Generate and return a rtx of mode MODE for 2**n where n is the number
34739    of bits of the mantissa of MODE, which must be one of DFmode or SFmode.  */
34740 static rtx
34741 ix86_gen_TWO52 (enum machine_mode mode)
34742 {
34743   REAL_VALUE_TYPE TWO52r;
34744   rtx TWO52;
34745
34746   real_ldexp (&TWO52r, &dconst1, mode == DFmode ? 52 : 23);
34747   TWO52 = const_double_from_real_value (TWO52r, mode);
34748   TWO52 = force_reg (mode, TWO52);
34749
34750   return TWO52;
34751 }
34752
34753 /* Expand SSE sequence for computing lround from OP1 storing
34754    into OP0.  */
34755 void
34756 ix86_expand_lround (rtx op0, rtx op1)
34757 {
34758   /* C code for the stuff we're doing below:
34759        tmp = op1 + copysign (nextafter (0.5, 0.0), op1)
34760        return (long)tmp;
34761    */
34762   enum machine_mode mode = GET_MODE (op1);
34763   const struct real_format *fmt;
34764   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
34765   rtx adj;
34766
34767   /* load nextafter (0.5, 0.0) */
34768   fmt = REAL_MODE_FORMAT (mode);
34769   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
34770   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
34771
34772   /* adj = copysign (0.5, op1) */
34773   adj = force_reg (mode, const_double_from_real_value (pred_half, mode));
34774   ix86_sse_copysign_to_positive (adj, adj, force_reg (mode, op1), NULL_RTX);
34775
34776   /* adj = op1 + adj */
34777   adj = expand_simple_binop (mode, PLUS, adj, op1, NULL_RTX, 0, OPTAB_DIRECT);
34778
34779   /* op0 = (imode)adj */
34780   expand_fix (op0, adj, 0);
34781 }
34782
34783 /* Expand SSE2 sequence for computing lround from OPERAND1 storing
34784    into OPERAND0.  */
34785 void
34786 ix86_expand_lfloorceil (rtx op0, rtx op1, bool do_floor)
34787 {
34788   /* C code for the stuff we're doing below (for do_floor):
34789         xi = (long)op1;
34790         xi -= (double)xi > op1 ? 1 : 0;
34791         return xi;
34792    */
34793   enum machine_mode fmode = GET_MODE (op1);
34794   enum machine_mode imode = GET_MODE (op0);
34795   rtx ireg, freg, label, tmp;
34796
34797   /* reg = (long)op1 */
34798   ireg = gen_reg_rtx (imode);
34799   expand_fix (ireg, op1, 0);
34800
34801   /* freg = (double)reg */
34802   freg = gen_reg_rtx (fmode);
34803   expand_float (freg, ireg, 0);
34804
34805   /* ireg = (freg > op1) ? ireg - 1 : ireg */
34806   label = ix86_expand_sse_compare_and_jump (UNLE,
34807                                             freg, op1, !do_floor);
34808   tmp = expand_simple_binop (imode, do_floor ? MINUS : PLUS,
34809                              ireg, const1_rtx, NULL_RTX, 0, OPTAB_DIRECT);
34810   emit_move_insn (ireg, tmp);
34811
34812   emit_label (label);
34813   LABEL_NUSES (label) = 1;
34814
34815   emit_move_insn (op0, ireg);
34816 }
34817
34818 /* Expand rint (IEEE round to nearest) rounding OPERAND1 and storing the
34819    result in OPERAND0.  */
34820 void
34821 ix86_expand_rint (rtx operand0, rtx operand1)
34822 {
34823   /* C code for the stuff we're doing below:
34824         xa = fabs (operand1);
34825         if (!isless (xa, 2**52))
34826           return operand1;
34827         xa = xa + 2**52 - 2**52;
34828         return copysign (xa, operand1);
34829    */
34830   enum machine_mode mode = GET_MODE (operand0);
34831   rtx res, xa, label, TWO52, mask;
34832
34833   res = gen_reg_rtx (mode);
34834   emit_move_insn (res, operand1);
34835
34836   /* xa = abs (operand1) */
34837   xa = ix86_expand_sse_fabs (res, &mask);
34838
34839   /* if (!isless (xa, TWO52)) goto label; */
34840   TWO52 = ix86_gen_TWO52 (mode);
34841   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
34842
34843   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
34844   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
34845
34846   ix86_sse_copysign_to_positive (res, xa, res, mask);
34847
34848   emit_label (label);
34849   LABEL_NUSES (label) = 1;
34850
34851   emit_move_insn (operand0, res);
34852 }
34853
34854 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
34855    into OPERAND0.  */
34856 void
34857 ix86_expand_floorceildf_32 (rtx operand0, rtx operand1, bool do_floor)
34858 {
34859   /* C code for the stuff we expand below.
34860         double xa = fabs (x), x2;
34861         if (!isless (xa, TWO52))
34862           return x;
34863         xa = xa + TWO52 - TWO52;
34864         x2 = copysign (xa, x);
34865      Compensate.  Floor:
34866         if (x2 > x)
34867           x2 -= 1;
34868      Compensate.  Ceil:
34869         if (x2 < x)
34870           x2 -= -1;
34871         return x2;
34872    */
34873   enum machine_mode mode = GET_MODE (operand0);
34874   rtx xa, TWO52, tmp, label, one, res, mask;
34875
34876   TWO52 = ix86_gen_TWO52 (mode);
34877
34878   /* Temporary for holding the result, initialized to the input
34879      operand to ease control flow.  */
34880   res = gen_reg_rtx (mode);
34881   emit_move_insn (res, operand1);
34882
34883   /* xa = abs (operand1) */
34884   xa = ix86_expand_sse_fabs (res, &mask);
34885
34886   /* if (!isless (xa, TWO52)) goto label; */
34887   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
34888
34889   /* xa = xa + TWO52 - TWO52; */
34890   xa = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
34891   xa = expand_simple_binop (mode, MINUS, xa, TWO52, xa, 0, OPTAB_DIRECT);
34892
34893   /* xa = copysign (xa, operand1) */
34894   ix86_sse_copysign_to_positive (xa, xa, res, mask);
34895
34896   /* generate 1.0 or -1.0 */
34897   one = force_reg (mode,
34898                    const_double_from_real_value (do_floor
34899                                                  ? dconst1 : dconstm1, mode));
34900
34901   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
34902   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
34903   emit_insn (gen_rtx_SET (VOIDmode, tmp,
34904                           gen_rtx_AND (mode, one, tmp)));
34905   /* We always need to subtract here to preserve signed zero.  */
34906   tmp = expand_simple_binop (mode, MINUS,
34907                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
34908   emit_move_insn (res, tmp);
34909
34910   emit_label (label);
34911   LABEL_NUSES (label) = 1;
34912
34913   emit_move_insn (operand0, res);
34914 }
34915
34916 /* Expand SSE2 sequence for computing floor or ceil from OPERAND1 storing
34917    into OPERAND0.  */
34918 void
34919 ix86_expand_floorceil (rtx operand0, rtx operand1, bool do_floor)
34920 {
34921   /* C code for the stuff we expand below.
34922         double xa = fabs (x), x2;
34923         if (!isless (xa, TWO52))
34924           return x;
34925         x2 = (double)(long)x;
34926      Compensate.  Floor:
34927         if (x2 > x)
34928           x2 -= 1;
34929      Compensate.  Ceil:
34930         if (x2 < x)
34931           x2 += 1;
34932         if (HONOR_SIGNED_ZEROS (mode))
34933           return copysign (x2, x);
34934         return x2;
34935    */
34936   enum machine_mode mode = GET_MODE (operand0);
34937   rtx xa, xi, TWO52, tmp, label, one, res, mask;
34938
34939   TWO52 = ix86_gen_TWO52 (mode);
34940
34941   /* Temporary for holding the result, initialized to the input
34942      operand to ease control flow.  */
34943   res = gen_reg_rtx (mode);
34944   emit_move_insn (res, operand1);
34945
34946   /* xa = abs (operand1) */
34947   xa = ix86_expand_sse_fabs (res, &mask);
34948
34949   /* if (!isless (xa, TWO52)) goto label; */
34950   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
34951
34952   /* xa = (double)(long)x */
34953   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
34954   expand_fix (xi, res, 0);
34955   expand_float (xa, xi, 0);
34956
34957   /* generate 1.0 */
34958   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
34959
34960   /* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
34961   tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
34962   emit_insn (gen_rtx_SET (VOIDmode, tmp,
34963                           gen_rtx_AND (mode, one, tmp)));
34964   tmp = expand_simple_binop (mode, do_floor ? MINUS : PLUS,
34965                              xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
34966   emit_move_insn (res, tmp);
34967
34968   if (HONOR_SIGNED_ZEROS (mode))
34969     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
34970
34971   emit_label (label);
34972   LABEL_NUSES (label) = 1;
34973
34974   emit_move_insn (operand0, res);
34975 }
34976
34977 /* Expand SSE sequence for computing round from OPERAND1 storing
34978    into OPERAND0.  Sequence that works without relying on DImode truncation
34979    via cvttsd2siq that is only available on 64bit targets.  */
34980 void
34981 ix86_expand_rounddf_32 (rtx operand0, rtx operand1)
34982 {
34983   /* C code for the stuff we expand below.
34984         double xa = fabs (x), xa2, x2;
34985         if (!isless (xa, TWO52))
34986           return x;
34987      Using the absolute value and copying back sign makes
34988      -0.0 -> -0.0 correct.
34989         xa2 = xa + TWO52 - TWO52;
34990      Compensate.
34991         dxa = xa2 - xa;
34992         if (dxa <= -0.5)
34993           xa2 += 1;
34994         else if (dxa > 0.5)
34995           xa2 -= 1;
34996         x2 = copysign (xa2, x);
34997         return x2;
34998    */
34999   enum machine_mode mode = GET_MODE (operand0);
35000   rtx xa, xa2, dxa, TWO52, tmp, label, half, mhalf, one, res, mask;
35001
35002   TWO52 = ix86_gen_TWO52 (mode);
35003
35004   /* Temporary for holding the result, initialized to the input
35005      operand to ease control flow.  */
35006   res = gen_reg_rtx (mode);
35007   emit_move_insn (res, operand1);
35008
35009   /* xa = abs (operand1) */
35010   xa = ix86_expand_sse_fabs (res, &mask);
35011
35012   /* if (!isless (xa, TWO52)) goto label; */
35013   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
35014
35015   /* xa2 = xa + TWO52 - TWO52; */
35016   xa2 = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
35017   xa2 = expand_simple_binop (mode, MINUS, xa2, TWO52, xa2, 0, OPTAB_DIRECT);
35018
35019   /* dxa = xa2 - xa; */
35020   dxa = expand_simple_binop (mode, MINUS, xa2, xa, NULL_RTX, 0, OPTAB_DIRECT);
35021
35022   /* generate 0.5, 1.0 and -0.5 */
35023   half = force_reg (mode, const_double_from_real_value (dconsthalf, mode));
35024   one = expand_simple_binop (mode, PLUS, half, half, NULL_RTX, 0, OPTAB_DIRECT);
35025   mhalf = expand_simple_binop (mode, MINUS, half, one, NULL_RTX,
35026                                0, OPTAB_DIRECT);
35027
35028   /* Compensate.  */
35029   tmp = gen_reg_rtx (mode);
35030   /* xa2 = xa2 - (dxa > 0.5 ? 1 : 0) */
35031   tmp = ix86_expand_sse_compare_mask (UNGT, dxa, half, false);
35032   emit_insn (gen_rtx_SET (VOIDmode, tmp,
35033                           gen_rtx_AND (mode, one, tmp)));
35034   xa2 = expand_simple_binop (mode, MINUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
35035   /* xa2 = xa2 + (dxa <= -0.5 ? 1 : 0) */
35036   tmp = ix86_expand_sse_compare_mask (UNGE, mhalf, dxa, false);
35037   emit_insn (gen_rtx_SET (VOIDmode, tmp,
35038                           gen_rtx_AND (mode, one, tmp)));
35039   xa2 = expand_simple_binop (mode, PLUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
35040
35041   /* res = copysign (xa2, operand1) */
35042   ix86_sse_copysign_to_positive (res, xa2, force_reg (mode, operand1), mask);
35043
35044   emit_label (label);
35045   LABEL_NUSES (label) = 1;
35046
35047   emit_move_insn (operand0, res);
35048 }
35049
35050 /* Expand SSE sequence for computing trunc from OPERAND1 storing
35051    into OPERAND0.  */
35052 void
35053 ix86_expand_trunc (rtx operand0, rtx operand1)
35054 {
35055   /* C code for SSE variant we expand below.
35056         double xa = fabs (x), x2;
35057         if (!isless (xa, TWO52))
35058           return x;
35059         x2 = (double)(long)x;
35060         if (HONOR_SIGNED_ZEROS (mode))
35061           return copysign (x2, x);
35062         return x2;
35063    */
35064   enum machine_mode mode = GET_MODE (operand0);
35065   rtx xa, xi, TWO52, label, res, mask;
35066
35067   TWO52 = ix86_gen_TWO52 (mode);
35068
35069   /* Temporary for holding the result, initialized to the input
35070      operand to ease control flow.  */
35071   res = gen_reg_rtx (mode);
35072   emit_move_insn (res, operand1);
35073
35074   /* xa = abs (operand1) */
35075   xa = ix86_expand_sse_fabs (res, &mask);
35076
35077   /* if (!isless (xa, TWO52)) goto label; */
35078   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
35079
35080   /* x = (double)(long)x */
35081   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
35082   expand_fix (xi, res, 0);
35083   expand_float (res, xi, 0);
35084
35085   if (HONOR_SIGNED_ZEROS (mode))
35086     ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), mask);
35087
35088   emit_label (label);
35089   LABEL_NUSES (label) = 1;
35090
35091   emit_move_insn (operand0, res);
35092 }
35093
35094 /* Expand SSE sequence for computing trunc from OPERAND1 storing
35095    into OPERAND0.  */
35096 void
35097 ix86_expand_truncdf_32 (rtx operand0, rtx operand1)
35098 {
35099   enum machine_mode mode = GET_MODE (operand0);
35100   rtx xa, mask, TWO52, label, one, res, smask, tmp;
35101
35102   /* C code for SSE variant we expand below.
35103         double xa = fabs (x), x2;
35104         if (!isless (xa, TWO52))
35105           return x;
35106         xa2 = xa + TWO52 - TWO52;
35107      Compensate:
35108         if (xa2 > xa)
35109           xa2 -= 1.0;
35110         x2 = copysign (xa2, x);
35111         return x2;
35112    */
35113
35114   TWO52 = ix86_gen_TWO52 (mode);
35115
35116   /* Temporary for holding the result, initialized to the input
35117      operand to ease control flow.  */
35118   res = gen_reg_rtx (mode);
35119   emit_move_insn (res, operand1);
35120
35121   /* xa = abs (operand1) */
35122   xa = ix86_expand_sse_fabs (res, &smask);
35123
35124   /* if (!isless (xa, TWO52)) goto label; */
35125   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
35126
35127   /* res = xa + TWO52 - TWO52; */
35128   tmp = expand_simple_binop (mode, PLUS, xa, TWO52, NULL_RTX, 0, OPTAB_DIRECT);
35129   tmp = expand_simple_binop (mode, MINUS, tmp, TWO52, tmp, 0, OPTAB_DIRECT);
35130   emit_move_insn (res, tmp);
35131
35132   /* generate 1.0 */
35133   one = force_reg (mode, const_double_from_real_value (dconst1, mode));
35134
35135   /* Compensate: res = xa2 - (res > xa ? 1 : 0)  */
35136   mask = ix86_expand_sse_compare_mask (UNGT, res, xa, false);
35137   emit_insn (gen_rtx_SET (VOIDmode, mask,
35138                           gen_rtx_AND (mode, mask, one)));
35139   tmp = expand_simple_binop (mode, MINUS,
35140                              res, mask, NULL_RTX, 0, OPTAB_DIRECT);
35141   emit_move_insn (res, tmp);
35142
35143   /* res = copysign (res, operand1) */
35144   ix86_sse_copysign_to_positive (res, res, force_reg (mode, operand1), smask);
35145
35146   emit_label (label);
35147   LABEL_NUSES (label) = 1;
35148
35149   emit_move_insn (operand0, res);
35150 }
35151
35152 /* Expand SSE sequence for computing round from OPERAND1 storing
35153    into OPERAND0.  */
35154 void
35155 ix86_expand_round (rtx operand0, rtx operand1)
35156 {
35157   /* C code for the stuff we're doing below:
35158         double xa = fabs (x);
35159         if (!isless (xa, TWO52))
35160           return x;
35161         xa = (double)(long)(xa + nextafter (0.5, 0.0));
35162         return copysign (xa, x);
35163    */
35164   enum machine_mode mode = GET_MODE (operand0);
35165   rtx res, TWO52, xa, label, xi, half, mask;
35166   const struct real_format *fmt;
35167   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
35168
35169   /* Temporary for holding the result, initialized to the input
35170      operand to ease control flow.  */
35171   res = gen_reg_rtx (mode);
35172   emit_move_insn (res, operand1);
35173
35174   TWO52 = ix86_gen_TWO52 (mode);
35175   xa = ix86_expand_sse_fabs (res, &mask);
35176   label = ix86_expand_sse_compare_and_jump (UNLE, TWO52, xa, false);
35177
35178   /* load nextafter (0.5, 0.0) */
35179   fmt = REAL_MODE_FORMAT (mode);
35180   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
35181   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
35182
35183   /* xa = xa + 0.5 */
35184   half = force_reg (mode, const_double_from_real_value (pred_half, mode));
35185   xa = expand_simple_binop (mode, PLUS, xa, half, NULL_RTX, 0, OPTAB_DIRECT);
35186
35187   /* xa = (double)(int64_t)xa */
35188   xi = gen_reg_rtx (mode == DFmode ? DImode : SImode);
35189   expand_fix (xi, xa, 0);
35190   expand_float (xa, xi, 0);
35191
35192   /* res = copysign (xa, operand1) */
35193   ix86_sse_copysign_to_positive (res, xa, force_reg (mode, operand1), mask);
35194
35195   emit_label (label);
35196   LABEL_NUSES (label) = 1;
35197
35198   emit_move_insn (operand0, res);
35199 }
35200
35201 /* Expand SSE sequence for computing round
35202    from OP1 storing into OP0 using sse4 round insn.  */
35203 void
35204 ix86_expand_round_sse4 (rtx op0, rtx op1)
35205 {
35206   enum machine_mode mode = GET_MODE (op0);
35207   rtx e1, e2, res, half;
35208   const struct real_format *fmt;
35209   REAL_VALUE_TYPE pred_half, half_minus_pred_half;
35210   rtx (*gen_copysign) (rtx, rtx, rtx);
35211   rtx (*gen_round) (rtx, rtx, rtx);
35212
35213   switch (mode)
35214     {
35215     case SFmode:
35216       gen_copysign = gen_copysignsf3;
35217       gen_round = gen_sse4_1_roundsf2;
35218       break;
35219     case DFmode:
35220       gen_copysign = gen_copysigndf3;
35221       gen_round = gen_sse4_1_rounddf2;
35222       break;
35223     default:
35224       gcc_unreachable ();
35225     }
35226
35227   /* round (a) = trunc (a + copysign (0.5, a)) */
35228
35229   /* load nextafter (0.5, 0.0) */
35230   fmt = REAL_MODE_FORMAT (mode);
35231   real_2expN (&half_minus_pred_half, -(fmt->p) - 1, mode);
35232   REAL_ARITHMETIC (pred_half, MINUS_EXPR, dconsthalf, half_minus_pred_half);
35233   half = const_double_from_real_value (pred_half, mode);
35234
35235   /* e1 = copysign (0.5, op1) */
35236   e1 = gen_reg_rtx (mode);
35237   emit_insn (gen_copysign (e1, half, op1));
35238
35239   /* e2 = op1 + e1 */
35240   e2 = expand_simple_binop (mode, PLUS, op1, e1, NULL_RTX, 0, OPTAB_DIRECT);
35241
35242   /* res = trunc (e2) */
35243   res = gen_reg_rtx (mode);
35244   emit_insn (gen_round (res, e2, GEN_INT (ROUND_TRUNC)));
35245
35246   emit_move_insn (op0, res);
35247 }
35248 \f
35249
35250 /* Table of valid machine attributes.  */
35251 static const struct attribute_spec ix86_attribute_table[] =
35252 {
35253   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
35254        affects_type_identity } */
35255   /* Stdcall attribute says callee is responsible for popping arguments
35256      if they are not variable.  */
35257   { "stdcall",   0, 0, false, true,  true,  ix86_handle_cconv_attribute,
35258     true },
35259   /* Fastcall attribute says callee is responsible for popping arguments
35260      if they are not variable.  */
35261   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
35262     true },
35263   /* Thiscall attribute says callee is responsible for popping arguments
35264      if they are not variable.  */
35265   { "thiscall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute,
35266     true },
35267   /* Cdecl attribute says the callee is a normal C declaration */
35268   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute,
35269     true },
35270   /* Regparm attribute specifies how many integer arguments are to be
35271      passed in registers.  */
35272   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute,
35273     true },
35274   /* Sseregparm attribute says we are using x86_64 calling conventions
35275      for FP arguments.  */
35276   { "sseregparm", 0, 0, false, true, true, ix86_handle_cconv_attribute,
35277     true },
35278   /* The transactional memory builtins are implicitly regparm or fastcall
35279      depending on the ABI.  Override the generic do-nothing attribute that
35280      these builtins were declared with.  */
35281   { "*tm regparm", 0, 0, false, true, true, ix86_handle_tm_regparm_attribute,
35282     true },
35283   /* force_align_arg_pointer says this function realigns the stack at entry.  */
35284   { (const char *)&ix86_force_align_arg_pointer_string, 0, 0,
35285     false, true,  true, ix86_handle_cconv_attribute, false },
35286 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
35287   { "dllimport", 0, 0, false, false, false, handle_dll_attribute, false },
35288   { "dllexport", 0, 0, false, false, false, handle_dll_attribute, false },
35289   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute,
35290     false },
35291 #endif
35292   { "ms_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
35293     false },
35294   { "gcc_struct", 0, 0, false, false,  false, ix86_handle_struct_attribute,
35295     false },
35296 #ifdef SUBTARGET_ATTRIBUTE_TABLE
35297   SUBTARGET_ATTRIBUTE_TABLE,
35298 #endif
35299   /* ms_abi and sysv_abi calling convention function attributes.  */
35300   { "ms_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
35301   { "sysv_abi", 0, 0, false, true, true, ix86_handle_abi_attribute, true },
35302   { "ms_hook_prologue", 0, 0, true, false, false, ix86_handle_fndecl_attribute,
35303     false },
35304   { "callee_pop_aggregate_return", 1, 1, false, true, true,
35305     ix86_handle_callee_pop_aggregate_return, true },
35306   /* End element.  */
35307   { NULL,        0, 0, false, false, false, NULL, false }
35308 };
35309
35310 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
35311 static int
35312 ix86_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
35313                                  tree vectype ATTRIBUTE_UNUSED,
35314                                  int misalign ATTRIBUTE_UNUSED)
35315 {
35316   switch (type_of_cost)
35317     {
35318       case scalar_stmt:
35319         return ix86_cost->scalar_stmt_cost;
35320
35321       case scalar_load:
35322         return ix86_cost->scalar_load_cost;
35323
35324       case scalar_store:
35325         return ix86_cost->scalar_store_cost;
35326
35327       case vector_stmt:
35328         return ix86_cost->vec_stmt_cost;
35329
35330       case vector_load:
35331         return ix86_cost->vec_align_load_cost;
35332
35333       case vector_store:
35334         return ix86_cost->vec_store_cost;
35335
35336       case vec_to_scalar:
35337         return ix86_cost->vec_to_scalar_cost;
35338
35339       case scalar_to_vec:
35340         return ix86_cost->scalar_to_vec_cost;
35341
35342       case unaligned_load:
35343       case unaligned_store:
35344         return ix86_cost->vec_unalign_load_cost;
35345
35346       case cond_branch_taken:
35347         return ix86_cost->cond_taken_branch_cost;
35348
35349       case cond_branch_not_taken:
35350         return ix86_cost->cond_not_taken_branch_cost;
35351
35352       case vec_perm:
35353       case vec_promote_demote:
35354         return ix86_cost->vec_stmt_cost;
35355
35356       default:
35357         gcc_unreachable ();
35358     }
35359 }
35360
35361 /* Construct (set target (vec_select op0 (parallel perm))) and
35362    return true if that's a valid instruction in the active ISA.  */
35363
35364 static bool
35365 expand_vselect (rtx target, rtx op0, const unsigned char *perm, unsigned nelt)
35366 {
35367   rtx rperm[MAX_VECT_LEN], x;
35368   unsigned i;
35369
35370   for (i = 0; i < nelt; ++i)
35371     rperm[i] = GEN_INT (perm[i]);
35372
35373   x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
35374   x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
35375   x = gen_rtx_SET (VOIDmode, target, x);
35376
35377   x = emit_insn (x);
35378   if (recog_memoized (x) < 0)
35379     {
35380       remove_insn (x);
35381       return false;
35382     }
35383   return true;
35384 }
35385
35386 /* Similar, but generate a vec_concat from op0 and op1 as well.  */
35387
35388 static bool
35389 expand_vselect_vconcat (rtx target, rtx op0, rtx op1,
35390                         const unsigned char *perm, unsigned nelt)
35391 {
35392   enum machine_mode v2mode;
35393   rtx x;
35394
35395   v2mode = GET_MODE_2XWIDER_MODE (GET_MODE (op0));
35396   x = gen_rtx_VEC_CONCAT (v2mode, op0, op1);
35397   return expand_vselect (target, x, perm, nelt);
35398 }
35399
35400 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
35401    in terms of blendp[sd] / pblendw / pblendvb / vpblendd.  */
35402
35403 static bool
35404 expand_vec_perm_blend (struct expand_vec_perm_d *d)
35405 {
35406   enum machine_mode vmode = d->vmode;
35407   unsigned i, mask, nelt = d->nelt;
35408   rtx target, op0, op1, x;
35409   rtx rperm[32], vperm;
35410
35411   if (d->op0 == d->op1)
35412     return false;
35413   if (TARGET_AVX2 && GET_MODE_SIZE (vmode) == 32)
35414     ;
35415   else if (TARGET_AVX && (vmode == V4DFmode || vmode == V8SFmode))
35416     ;
35417   else if (TARGET_SSE4_1 && GET_MODE_SIZE (vmode) == 16)
35418     ;
35419   else
35420     return false;
35421
35422   /* This is a blend, not a permute.  Elements must stay in their
35423      respective lanes.  */
35424   for (i = 0; i < nelt; ++i)
35425     {
35426       unsigned e = d->perm[i];
35427       if (!(e == i || e == i + nelt))
35428         return false;
35429     }
35430
35431   if (d->testing_p)
35432     return true;
35433
35434   /* ??? Without SSE4.1, we could implement this with and/andn/or.  This
35435      decision should be extracted elsewhere, so that we only try that
35436      sequence once all budget==3 options have been tried.  */
35437   target = d->target;
35438   op0 = d->op0;
35439   op1 = d->op1;
35440   mask = 0;
35441
35442   switch (vmode)
35443     {
35444     case V4DFmode:
35445     case V8SFmode:
35446     case V2DFmode:
35447     case V4SFmode:
35448     case V8HImode:
35449     case V8SImode:
35450       for (i = 0; i < nelt; ++i)
35451         mask |= (d->perm[i] >= nelt) << i;
35452       break;
35453
35454     case V2DImode:
35455       for (i = 0; i < 2; ++i)
35456         mask |= (d->perm[i] >= 2 ? 15 : 0) << (i * 4);
35457       vmode = V8HImode;
35458       goto do_subreg;
35459
35460     case V4SImode:
35461       for (i = 0; i < 4; ++i)
35462         mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
35463       vmode = V8HImode;
35464       goto do_subreg;
35465
35466     case V16QImode:
35467       /* See if bytes move in pairs so we can use pblendw with
35468          an immediate argument, rather than pblendvb with a vector
35469          argument.  */
35470       for (i = 0; i < 16; i += 2)
35471         if (d->perm[i] + 1 != d->perm[i + 1])
35472           {
35473           use_pblendvb:
35474             for (i = 0; i < nelt; ++i)
35475               rperm[i] = (d->perm[i] < nelt ? const0_rtx : constm1_rtx);
35476
35477           finish_pblendvb:
35478             vperm = gen_rtx_CONST_VECTOR (vmode, gen_rtvec_v (nelt, rperm));
35479             vperm = force_reg (vmode, vperm);
35480
35481             if (GET_MODE_SIZE (vmode) == 16)
35482               emit_insn (gen_sse4_1_pblendvb (target, op0, op1, vperm));
35483             else
35484               emit_insn (gen_avx2_pblendvb (target, op0, op1, vperm));
35485             return true;
35486           }
35487
35488       for (i = 0; i < 8; ++i)
35489         mask |= (d->perm[i * 2] >= 16) << i;
35490       vmode = V8HImode;
35491       /* FALLTHRU */
35492
35493     do_subreg:
35494       target = gen_lowpart (vmode, target);
35495       op0 = gen_lowpart (vmode, op0);
35496       op1 = gen_lowpart (vmode, op1);
35497       break;
35498
35499     case V32QImode:
35500       /* See if bytes move in pairs.  If not, vpblendvb must be used.  */
35501       for (i = 0; i < 32; i += 2)
35502         if (d->perm[i] + 1 != d->perm[i + 1])
35503           goto use_pblendvb;
35504       /* See if bytes move in quadruplets.  If yes, vpblendd
35505          with immediate can be used.  */
35506       for (i = 0; i < 32; i += 4)
35507         if (d->perm[i] + 2 != d->perm[i + 2])
35508           break;
35509       if (i < 32)
35510         {
35511           /* See if bytes move the same in both lanes.  If yes,
35512              vpblendw with immediate can be used.  */
35513           for (i = 0; i < 16; i += 2)
35514             if (d->perm[i] + 16 != d->perm[i + 16])
35515               goto use_pblendvb;
35516
35517           /* Use vpblendw.  */
35518           for (i = 0; i < 16; ++i)
35519             mask |= (d->perm[i * 2] >= 32) << i;
35520           vmode = V16HImode;
35521           goto do_subreg;
35522         }
35523
35524       /* Use vpblendd.  */
35525       for (i = 0; i < 8; ++i)
35526         mask |= (d->perm[i * 4] >= 32) << i;
35527       vmode = V8SImode;
35528       goto do_subreg;
35529
35530     case V16HImode:
35531       /* See if words move in pairs.  If yes, vpblendd can be used.  */
35532       for (i = 0; i < 16; i += 2)
35533         if (d->perm[i] + 1 != d->perm[i + 1])
35534           break;
35535       if (i < 16)
35536         {
35537           /* See if words move the same in both lanes.  If not,
35538              vpblendvb must be used.  */
35539           for (i = 0; i < 8; i++)
35540             if (d->perm[i] + 8 != d->perm[i + 8])
35541               {
35542                 /* Use vpblendvb.  */
35543                 for (i = 0; i < 32; ++i)
35544                   rperm[i] = (d->perm[i / 2] < 16 ? const0_rtx : constm1_rtx);
35545
35546                 vmode = V32QImode;
35547                 nelt = 32;
35548                 target = gen_lowpart (vmode, target);
35549                 op0 = gen_lowpart (vmode, op0);
35550                 op1 = gen_lowpart (vmode, op1);
35551                 goto finish_pblendvb;
35552               }
35553
35554           /* Use vpblendw.  */
35555           for (i = 0; i < 16; ++i)
35556             mask |= (d->perm[i] >= 16) << i;
35557           break;
35558         }
35559
35560       /* Use vpblendd.  */
35561       for (i = 0; i < 8; ++i)
35562         mask |= (d->perm[i * 2] >= 16) << i;
35563       vmode = V8SImode;
35564       goto do_subreg;
35565
35566     case V4DImode:
35567       /* Use vpblendd.  */
35568       for (i = 0; i < 4; ++i)
35569         mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
35570       vmode = V8SImode;
35571       goto do_subreg;
35572
35573     default:
35574       gcc_unreachable ();
35575     }
35576
35577   /* This matches five different patterns with the different modes.  */
35578   x = gen_rtx_VEC_MERGE (vmode, op1, op0, GEN_INT (mask));
35579   x = gen_rtx_SET (VOIDmode, target, x);
35580   emit_insn (x);
35581
35582   return true;
35583 }
35584
35585 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
35586    in terms of the variable form of vpermilps.
35587
35588    Note that we will have already failed the immediate input vpermilps,
35589    which requires that the high and low part shuffle be identical; the
35590    variable form doesn't require that.  */
35591
35592 static bool
35593 expand_vec_perm_vpermil (struct expand_vec_perm_d *d)
35594 {
35595   rtx rperm[8], vperm;
35596   unsigned i;
35597
35598   if (!TARGET_AVX || d->vmode != V8SFmode || d->op0 != d->op1)
35599     return false;
35600
35601   /* We can only permute within the 128-bit lane.  */
35602   for (i = 0; i < 8; ++i)
35603     {
35604       unsigned e = d->perm[i];
35605       if (i < 4 ? e >= 4 : e < 4)
35606         return false;
35607     }
35608
35609   if (d->testing_p)
35610     return true;
35611
35612   for (i = 0; i < 8; ++i)
35613     {
35614       unsigned e = d->perm[i];
35615
35616       /* Within each 128-bit lane, the elements of op0 are numbered
35617          from 0 and the elements of op1 are numbered from 4.  */
35618       if (e >= 8 + 4)
35619         e -= 8;
35620       else if (e >= 4)
35621         e -= 4;
35622
35623       rperm[i] = GEN_INT (e);
35624     }
35625
35626   vperm = gen_rtx_CONST_VECTOR (V8SImode, gen_rtvec_v (8, rperm));
35627   vperm = force_reg (V8SImode, vperm);
35628   emit_insn (gen_avx_vpermilvarv8sf3 (d->target, d->op0, vperm));
35629
35630   return true;
35631 }
35632
35633 /* Return true if permutation D can be performed as VMODE permutation
35634    instead.  */
35635
35636 static bool
35637 valid_perm_using_mode_p (enum machine_mode vmode, struct expand_vec_perm_d *d)
35638 {
35639   unsigned int i, j, chunk;
35640
35641   if (GET_MODE_CLASS (vmode) != MODE_VECTOR_INT
35642       || GET_MODE_CLASS (d->vmode) != MODE_VECTOR_INT
35643       || GET_MODE_SIZE (vmode) != GET_MODE_SIZE (d->vmode))
35644     return false;
35645
35646   if (GET_MODE_NUNITS (vmode) >= d->nelt)
35647     return true;
35648
35649   chunk = d->nelt / GET_MODE_NUNITS (vmode);
35650   for (i = 0; i < d->nelt; i += chunk)
35651     if (d->perm[i] & (chunk - 1))
35652       return false;
35653     else
35654       for (j = 1; j < chunk; ++j)
35655         if (d->perm[i] + j != d->perm[i + j])
35656           return false;
35657
35658   return true;
35659 }
35660
35661 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
35662    in terms of pshufb, vpperm, vpermq, vpermd or vperm2i128.  */
35663
35664 static bool
35665 expand_vec_perm_pshufb (struct expand_vec_perm_d *d)
35666 {
35667   unsigned i, nelt, eltsz, mask;
35668   unsigned char perm[32];
35669   enum machine_mode vmode = V16QImode;
35670   rtx rperm[32], vperm, target, op0, op1;
35671
35672   nelt = d->nelt;
35673
35674   if (d->op0 != d->op1)
35675     {
35676       if (!TARGET_XOP || GET_MODE_SIZE (d->vmode) != 16)
35677         {
35678           if (TARGET_AVX2
35679               && valid_perm_using_mode_p (V2TImode, d))
35680             {
35681               if (d->testing_p)
35682                 return true;
35683
35684               /* Use vperm2i128 insn.  The pattern uses
35685                  V4DImode instead of V2TImode.  */
35686               target = gen_lowpart (V4DImode, d->target);
35687               op0 = gen_lowpart (V4DImode, d->op0);
35688               op1 = gen_lowpart (V4DImode, d->op1);
35689               rperm[0]
35690                 = GEN_INT (((d->perm[0] & (nelt / 2)) ? 1 : 0)
35691                            || ((d->perm[nelt / 2] & (nelt / 2)) ? 2 : 0));
35692               emit_insn (gen_avx2_permv2ti (target, op0, op1, rperm[0]));
35693               return true;
35694             }
35695           return false;
35696         }
35697     }
35698   else
35699     {
35700       if (GET_MODE_SIZE (d->vmode) == 16)
35701         {
35702           if (!TARGET_SSSE3)
35703             return false;
35704         }
35705       else if (GET_MODE_SIZE (d->vmode) == 32)
35706         {
35707           if (!TARGET_AVX2)
35708             return false;
35709
35710           /* V4DImode should be already handled through
35711              expand_vselect by vpermq instruction.  */
35712           gcc_assert (d->vmode != V4DImode);
35713
35714           vmode = V32QImode;
35715           if (d->vmode == V8SImode
35716               || d->vmode == V16HImode
35717               || d->vmode == V32QImode)
35718             {
35719               /* First see if vpermq can be used for
35720                  V8SImode/V16HImode/V32QImode.  */
35721               if (valid_perm_using_mode_p (V4DImode, d))
35722                 {
35723                   for (i = 0; i < 4; i++)
35724                     perm[i] = (d->perm[i * nelt / 4] * 4 / nelt) & 3;
35725                   if (d->testing_p)
35726                     return true;
35727                   return expand_vselect (gen_lowpart (V4DImode, d->target),
35728                                          gen_lowpart (V4DImode, d->op0),
35729                                          perm, 4);
35730                 }
35731
35732               /* Next see if vpermd can be used.  */
35733               if (valid_perm_using_mode_p (V8SImode, d))
35734                 vmode = V8SImode;
35735             }
35736
35737           if (vmode == V32QImode)
35738             {
35739               /* vpshufb only works intra lanes, it is not
35740                  possible to shuffle bytes in between the lanes.  */
35741               for (i = 0; i < nelt; ++i)
35742                 if ((d->perm[i] ^ i) & (nelt / 2))
35743                   return false;
35744             }
35745         }
35746       else
35747         return false;
35748     }
35749
35750   if (d->testing_p)
35751     return true;
35752
35753   if (vmode == V8SImode)
35754     for (i = 0; i < 8; ++i)
35755       rperm[i] = GEN_INT ((d->perm[i * nelt / 8] * 8 / nelt) & 7);
35756   else
35757     {
35758       eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
35759       if (d->op0 != d->op1)
35760         mask = 2 * nelt - 1;
35761       else if (vmode == V16QImode)
35762         mask = nelt - 1;
35763       else
35764         mask = nelt / 2 - 1;
35765
35766       for (i = 0; i < nelt; ++i)
35767         {
35768           unsigned j, e = d->perm[i] & mask;
35769           for (j = 0; j < eltsz; ++j)
35770             rperm[i * eltsz + j] = GEN_INT (e * eltsz + j);
35771         }
35772     }
35773
35774   vperm = gen_rtx_CONST_VECTOR (vmode,
35775                                 gen_rtvec_v (GET_MODE_NUNITS (vmode), rperm));
35776   vperm = force_reg (vmode, vperm);
35777
35778   target = gen_lowpart (vmode, d->target);
35779   op0 = gen_lowpart (vmode, d->op0);
35780   if (d->op0 == d->op1)
35781     {
35782       if (vmode == V16QImode)
35783         emit_insn (gen_ssse3_pshufbv16qi3 (target, op0, vperm));
35784       else if (vmode == V32QImode)
35785         emit_insn (gen_avx2_pshufbv32qi3 (target, op0, vperm));
35786       else
35787         emit_insn (gen_avx2_permvarv8si (target, vperm, op0));
35788     }
35789   else
35790     {
35791       op1 = gen_lowpart (vmode, d->op1);
35792       emit_insn (gen_xop_pperm (target, op0, op1, vperm));
35793     }
35794
35795   return true;
35796 }
35797
35798 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to instantiate D
35799    in a single instruction.  */
35800
35801 static bool
35802 expand_vec_perm_1 (struct expand_vec_perm_d *d)
35803 {
35804   unsigned i, nelt = d->nelt;
35805   unsigned char perm2[MAX_VECT_LEN];
35806
35807   /* Check plain VEC_SELECT first, because AVX has instructions that could
35808      match both SEL and SEL+CONCAT, but the plain SEL will allow a memory
35809      input where SEL+CONCAT may not.  */
35810   if (d->op0 == d->op1)
35811     {
35812       int mask = nelt - 1;
35813       bool identity_perm = true;
35814       bool broadcast_perm = true;
35815
35816       for (i = 0; i < nelt; i++)
35817         {
35818           perm2[i] = d->perm[i] & mask;
35819           if (perm2[i] != i)
35820             identity_perm = false;
35821           if (perm2[i])
35822             broadcast_perm = false;
35823         }
35824
35825       if (identity_perm)
35826         {
35827           if (!d->testing_p)
35828             emit_move_insn (d->target, d->op0);
35829           return true;
35830         }
35831       else if (broadcast_perm && TARGET_AVX2)
35832         {
35833           /* Use vpbroadcast{b,w,d}.  */
35834           rtx op = d->op0, (*gen) (rtx, rtx) = NULL;
35835           switch (d->vmode)
35836             {
35837             case V32QImode:
35838               op = gen_lowpart (V16QImode, op);
35839               gen = gen_avx2_pbroadcastv32qi;
35840               break;
35841             case V16HImode:
35842               op = gen_lowpart (V8HImode, op);
35843               gen = gen_avx2_pbroadcastv16hi;
35844               break;
35845             case V8SImode:
35846               op = gen_lowpart (V4SImode, op);
35847               gen = gen_avx2_pbroadcastv8si;
35848               break;
35849             case V16QImode:
35850               gen = gen_avx2_pbroadcastv16qi;
35851               break;
35852             case V8HImode:
35853               gen = gen_avx2_pbroadcastv8hi;
35854               break;
35855             /* For other modes prefer other shuffles this function creates.  */
35856             default: break;
35857             }
35858           if (gen != NULL)
35859             {
35860               if (!d->testing_p)
35861                 emit_insn (gen (d->target, op));
35862               return true;
35863             }
35864         }
35865
35866       if (expand_vselect (d->target, d->op0, perm2, nelt))
35867         return true;
35868
35869       /* There are plenty of patterns in sse.md that are written for
35870          SEL+CONCAT and are not replicated for a single op.  Perhaps
35871          that should be changed, to avoid the nastiness here.  */
35872
35873       /* Recognize interleave style patterns, which means incrementing
35874          every other permutation operand.  */
35875       for (i = 0; i < nelt; i += 2)
35876         {
35877           perm2[i] = d->perm[i] & mask;
35878           perm2[i + 1] = (d->perm[i + 1] & mask) + nelt;
35879         }
35880       if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
35881         return true;
35882
35883       /* Recognize shufps, which means adding {0, 0, nelt, nelt}.  */
35884       if (nelt >= 4)
35885         {
35886           for (i = 0; i < nelt; i += 4)
35887             {
35888               perm2[i + 0] = d->perm[i + 0] & mask;
35889               perm2[i + 1] = d->perm[i + 1] & mask;
35890               perm2[i + 2] = (d->perm[i + 2] & mask) + nelt;
35891               perm2[i + 3] = (d->perm[i + 3] & mask) + nelt;
35892             }
35893
35894           if (expand_vselect_vconcat (d->target, d->op0, d->op0, perm2, nelt))
35895             return true;
35896         }
35897     }
35898
35899   /* Finally, try the fully general two operand permute.  */
35900   if (expand_vselect_vconcat (d->target, d->op0, d->op1, d->perm, nelt))
35901     return true;
35902
35903   /* Recognize interleave style patterns with reversed operands.  */
35904   if (d->op0 != d->op1)
35905     {
35906       for (i = 0; i < nelt; ++i)
35907         {
35908           unsigned e = d->perm[i];
35909           if (e >= nelt)
35910             e -= nelt;
35911           else
35912             e += nelt;
35913           perm2[i] = e;
35914         }
35915
35916       if (expand_vselect_vconcat (d->target, d->op1, d->op0, perm2, nelt))
35917         return true;
35918     }
35919
35920   /* Try the SSE4.1 blend variable merge instructions.  */
35921   if (expand_vec_perm_blend (d))
35922     return true;
35923
35924   /* Try one of the AVX vpermil variable permutations.  */
35925   if (expand_vec_perm_vpermil (d))
35926     return true;
35927
35928   /* Try the SSSE3 pshufb or XOP vpperm or AVX2 vperm2i128,
35929      vpshufb, vpermd or vpermq variable permutation.  */
35930   if (expand_vec_perm_pshufb (d))
35931     return true;
35932
35933   return false;
35934 }
35935
35936 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to implement D
35937    in terms of a pair of pshuflw + pshufhw instructions.  */
35938
35939 static bool
35940 expand_vec_perm_pshuflw_pshufhw (struct expand_vec_perm_d *d)
35941 {
35942   unsigned char perm2[MAX_VECT_LEN];
35943   unsigned i;
35944   bool ok;
35945
35946   if (d->vmode != V8HImode || d->op0 != d->op1)
35947     return false;
35948
35949   /* The two permutations only operate in 64-bit lanes.  */
35950   for (i = 0; i < 4; ++i)
35951     if (d->perm[i] >= 4)
35952       return false;
35953   for (i = 4; i < 8; ++i)
35954     if (d->perm[i] < 4)
35955       return false;
35956
35957   if (d->testing_p)
35958     return true;
35959
35960   /* Emit the pshuflw.  */
35961   memcpy (perm2, d->perm, 4);
35962   for (i = 4; i < 8; ++i)
35963     perm2[i] = i;
35964   ok = expand_vselect (d->target, d->op0, perm2, 8);
35965   gcc_assert (ok);
35966
35967   /* Emit the pshufhw.  */
35968   memcpy (perm2 + 4, d->perm + 4, 4);
35969   for (i = 0; i < 4; ++i)
35970     perm2[i] = i;
35971   ok = expand_vselect (d->target, d->target, perm2, 8);
35972   gcc_assert (ok);
35973
35974   return true;
35975 }
35976
35977 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
35978    the permutation using the SSSE3 palignr instruction.  This succeeds
35979    when all of the elements in PERM fit within one vector and we merely
35980    need to shift them down so that a single vector permutation has a
35981    chance to succeed.  */
35982
35983 static bool
35984 expand_vec_perm_palignr (struct expand_vec_perm_d *d)
35985 {
35986   unsigned i, nelt = d->nelt;
35987   unsigned min, max;
35988   bool in_order, ok;
35989   rtx shift;
35990
35991   /* Even with AVX, palignr only operates on 128-bit vectors.  */
35992   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
35993     return false;
35994
35995   min = nelt, max = 0;
35996   for (i = 0; i < nelt; ++i)
35997     {
35998       unsigned e = d->perm[i];
35999       if (e < min)
36000         min = e;
36001       if (e > max)
36002         max = e;
36003     }
36004   if (min == 0 || max - min >= nelt)
36005     return false;
36006
36007   /* Given that we have SSSE3, we know we'll be able to implement the
36008      single operand permutation after the palignr with pshufb.  */
36009   if (d->testing_p)
36010     return true;
36011
36012   shift = GEN_INT (min * GET_MODE_BITSIZE (GET_MODE_INNER (d->vmode)));
36013   emit_insn (gen_ssse3_palignrti (gen_lowpart (TImode, d->target),
36014                                   gen_lowpart (TImode, d->op1),
36015                                   gen_lowpart (TImode, d->op0), shift));
36016
36017   d->op0 = d->op1 = d->target;
36018
36019   in_order = true;
36020   for (i = 0; i < nelt; ++i)
36021     {
36022       unsigned e = d->perm[i] - min;
36023       if (e != i)
36024         in_order = false;
36025       d->perm[i] = e;
36026     }
36027
36028   /* Test for the degenerate case where the alignment by itself
36029      produces the desired permutation.  */
36030   if (in_order)
36031     return true;
36032
36033   ok = expand_vec_perm_1 (d);
36034   gcc_assert (ok);
36035
36036   return ok;
36037 }
36038
36039 static bool expand_vec_perm_interleave3 (struct expand_vec_perm_d *d);
36040
36041 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
36042    a two vector permutation into a single vector permutation by using
36043    an interleave operation to merge the vectors.  */
36044
36045 static bool
36046 expand_vec_perm_interleave2 (struct expand_vec_perm_d *d)
36047 {
36048   struct expand_vec_perm_d dremap, dfinal;
36049   unsigned i, nelt = d->nelt, nelt2 = nelt / 2;
36050   unsigned HOST_WIDE_INT contents;
36051   unsigned char remap[2 * MAX_VECT_LEN];
36052   rtx seq;
36053   bool ok, same_halves = false;
36054
36055   if (GET_MODE_SIZE (d->vmode) == 16)
36056     {
36057       if (d->op0 == d->op1)
36058         return false;
36059     }
36060   else if (GET_MODE_SIZE (d->vmode) == 32)
36061     {
36062       if (!TARGET_AVX)
36063         return false;
36064       /* For 32-byte modes allow even d->op0 == d->op1.
36065          The lack of cross-lane shuffling in some instructions
36066          might prevent a single insn shuffle.  */
36067       dfinal = *d;
36068       dfinal.testing_p = true;
36069       /* If expand_vec_perm_interleave3 can expand this into
36070          a 3 insn sequence, give up and let it be expanded as
36071          3 insn sequence.  While that is one insn longer,
36072          it doesn't need a memory operand and in the common
36073          case that both interleave low and high permutations
36074          with the same operands are adjacent needs 4 insns
36075          for both after CSE.  */
36076       if (expand_vec_perm_interleave3 (&dfinal))
36077         return false;
36078     }
36079   else
36080     return false;
36081
36082   /* Examine from whence the elements come.  */
36083   contents = 0;
36084   for (i = 0; i < nelt; ++i)
36085     contents |= ((unsigned HOST_WIDE_INT) 1) << d->perm[i];
36086
36087   memset (remap, 0xff, sizeof (remap));
36088   dremap = *d;
36089
36090   if (GET_MODE_SIZE (d->vmode) == 16)
36091     {
36092       unsigned HOST_WIDE_INT h1, h2, h3, h4;
36093
36094       /* Split the two input vectors into 4 halves.  */
36095       h1 = (((unsigned HOST_WIDE_INT) 1) << nelt2) - 1;
36096       h2 = h1 << nelt2;
36097       h3 = h2 << nelt2;
36098       h4 = h3 << nelt2;
36099
36100       /* If the elements from the low halves use interleave low, and similarly
36101          for interleave high.  If the elements are from mis-matched halves, we
36102          can use shufps for V4SF/V4SI or do a DImode shuffle.  */
36103       if ((contents & (h1 | h3)) == contents)
36104         {
36105           /* punpckl* */
36106           for (i = 0; i < nelt2; ++i)
36107             {
36108               remap[i] = i * 2;
36109               remap[i + nelt] = i * 2 + 1;
36110               dremap.perm[i * 2] = i;
36111               dremap.perm[i * 2 + 1] = i + nelt;
36112             }
36113           if (!TARGET_SSE2 && d->vmode == V4SImode)
36114             dremap.vmode = V4SFmode;
36115         }
36116       else if ((contents & (h2 | h4)) == contents)
36117         {
36118           /* punpckh* */
36119           for (i = 0; i < nelt2; ++i)
36120             {
36121               remap[i + nelt2] = i * 2;
36122               remap[i + nelt + nelt2] = i * 2 + 1;
36123               dremap.perm[i * 2] = i + nelt2;
36124               dremap.perm[i * 2 + 1] = i + nelt + nelt2;
36125             }
36126           if (!TARGET_SSE2 && d->vmode == V4SImode)
36127             dremap.vmode = V4SFmode;
36128         }
36129       else if ((contents & (h1 | h4)) == contents)
36130         {
36131           /* shufps */
36132           for (i = 0; i < nelt2; ++i)
36133             {
36134               remap[i] = i;
36135               remap[i + nelt + nelt2] = i + nelt2;
36136               dremap.perm[i] = i;
36137               dremap.perm[i + nelt2] = i + nelt + nelt2;
36138             }
36139           if (nelt != 4)
36140             {
36141               /* shufpd */
36142               dremap.vmode = V2DImode;
36143               dremap.nelt = 2;
36144               dremap.perm[0] = 0;
36145               dremap.perm[1] = 3;
36146             }
36147         }
36148       else if ((contents & (h2 | h3)) == contents)
36149         {
36150           /* shufps */
36151           for (i = 0; i < nelt2; ++i)
36152             {
36153               remap[i + nelt2] = i;
36154               remap[i + nelt] = i + nelt2;
36155               dremap.perm[i] = i + nelt2;
36156               dremap.perm[i + nelt2] = i + nelt;
36157             }
36158           if (nelt != 4)
36159             {
36160               /* shufpd */
36161               dremap.vmode = V2DImode;
36162               dremap.nelt = 2;
36163               dremap.perm[0] = 1;
36164               dremap.perm[1] = 2;
36165             }
36166         }
36167       else
36168         return false;
36169     }
36170   else
36171     {
36172       unsigned int nelt4 = nelt / 4, nzcnt = 0;
36173       unsigned HOST_WIDE_INT q[8];
36174       unsigned int nonzero_halves[4];
36175
36176       /* Split the two input vectors into 8 quarters.  */
36177       q[0] = (((unsigned HOST_WIDE_INT) 1) << nelt4) - 1;
36178       for (i = 1; i < 8; ++i)
36179         q[i] = q[0] << (nelt4 * i);
36180       for (i = 0; i < 4; ++i)
36181         if (((q[2 * i] | q[2 * i + 1]) & contents) != 0)
36182           {
36183             nonzero_halves[nzcnt] = i;
36184             ++nzcnt;
36185           }
36186
36187       if (nzcnt == 1)
36188         {
36189           gcc_assert (d->op0 == d->op1);
36190           nonzero_halves[1] = nonzero_halves[0];
36191           same_halves = true;
36192         }
36193       else if (d->op0 == d->op1)
36194         {
36195           gcc_assert (nonzero_halves[0] == 0);
36196           gcc_assert (nonzero_halves[1] == 1);
36197         }
36198
36199       if (nzcnt <= 2)
36200         {
36201           if (d->perm[0] / nelt2 == nonzero_halves[1])
36202             {
36203               /* Attempt to increase the likelyhood that dfinal
36204                  shuffle will be intra-lane.  */
36205               char tmph = nonzero_halves[0];
36206               nonzero_halves[0] = nonzero_halves[1];
36207               nonzero_halves[1] = tmph;
36208             }
36209
36210           /* vperm2f128 or vperm2i128.  */
36211           for (i = 0; i < nelt2; ++i)
36212             {
36213               remap[i + nonzero_halves[1] * nelt2] = i + nelt2;
36214               remap[i + nonzero_halves[0] * nelt2] = i;
36215               dremap.perm[i + nelt2] = i + nonzero_halves[1] * nelt2;
36216               dremap.perm[i] = i + nonzero_halves[0] * nelt2;
36217             }
36218
36219           if (d->vmode != V8SFmode
36220               && d->vmode != V4DFmode
36221               && d->vmode != V8SImode)
36222             {
36223               dremap.vmode = V8SImode;
36224               dremap.nelt = 8;
36225               for (i = 0; i < 4; ++i)
36226                 {
36227                   dremap.perm[i] = i + nonzero_halves[0] * 4;
36228                   dremap.perm[i + 4] = i + nonzero_halves[1] * 4;
36229                 }
36230             }
36231         }
36232       else if (d->op0 == d->op1)
36233         return false;
36234       else if (TARGET_AVX2
36235                && (contents & (q[0] | q[2] | q[4] | q[6])) == contents)
36236         {
36237           /* vpunpckl* */
36238           for (i = 0; i < nelt4; ++i)
36239             {
36240               remap[i] = i * 2;
36241               remap[i + nelt] = i * 2 + 1;
36242               remap[i + nelt2] = i * 2 + nelt2;
36243               remap[i + nelt + nelt2] = i * 2 + nelt2 + 1;
36244               dremap.perm[i * 2] = i;
36245               dremap.perm[i * 2 + 1] = i + nelt;
36246               dremap.perm[i * 2 + nelt2] = i + nelt2;
36247               dremap.perm[i * 2 + nelt2 + 1] = i + nelt + nelt2;
36248             }
36249         }
36250       else if (TARGET_AVX2
36251                && (contents & (q[1] | q[3] | q[5] | q[7])) == contents)
36252         {
36253           /* vpunpckh* */
36254           for (i = 0; i < nelt4; ++i)
36255             {
36256               remap[i + nelt4] = i * 2;
36257               remap[i + nelt + nelt4] = i * 2 + 1;
36258               remap[i + nelt2 + nelt4] = i * 2 + nelt2;
36259               remap[i + nelt + nelt2 + nelt4] = i * 2 + nelt2 + 1;
36260               dremap.perm[i * 2] = i + nelt4;
36261               dremap.perm[i * 2 + 1] = i + nelt + nelt4;
36262               dremap.perm[i * 2 + nelt2] = i + nelt2 + nelt4;
36263               dremap.perm[i * 2 + nelt2 + 1] = i + nelt + nelt2 + nelt4;
36264             }
36265         }
36266       else
36267         return false;
36268     }
36269
36270   /* Use the remapping array set up above to move the elements from their
36271      swizzled locations into their final destinations.  */
36272   dfinal = *d;
36273   for (i = 0; i < nelt; ++i)
36274     {
36275       unsigned e = remap[d->perm[i]];
36276       gcc_assert (e < nelt);
36277       /* If same_halves is true, both halves of the remapped vector are the
36278          same.  Avoid cross-lane accesses if possible.  */
36279       if (same_halves && i >= nelt2)
36280         {
36281           gcc_assert (e < nelt2);
36282           dfinal.perm[i] = e + nelt2;
36283         }
36284       else
36285         dfinal.perm[i] = e;
36286     }
36287   dfinal.op0 = gen_reg_rtx (dfinal.vmode);
36288   dfinal.op1 = dfinal.op0;
36289   dremap.target = dfinal.op0;
36290
36291   /* Test if the final remap can be done with a single insn.  For V4SFmode or
36292      V4SImode this *will* succeed.  For V8HImode or V16QImode it may not.  */
36293   start_sequence ();
36294   ok = expand_vec_perm_1 (&dfinal);
36295   seq = get_insns ();
36296   end_sequence ();
36297
36298   if (!ok)
36299     return false;
36300
36301   if (d->testing_p)
36302     return true;
36303
36304   if (dremap.vmode != dfinal.vmode)
36305     {
36306       dremap.target = gen_lowpart (dremap.vmode, dremap.target);
36307       dremap.op0 = gen_lowpart (dremap.vmode, dremap.op0);
36308       dremap.op1 = gen_lowpart (dremap.vmode, dremap.op1);
36309     }
36310
36311   ok = expand_vec_perm_1 (&dremap);
36312   gcc_assert (ok);
36313
36314   emit_insn (seq);
36315   return true;
36316 }
36317
36318 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
36319    a single vector cross-lane permutation into vpermq followed
36320    by any of the single insn permutations.  */
36321
36322 static bool
36323 expand_vec_perm_vpermq_perm_1 (struct expand_vec_perm_d *d)
36324 {
36325   struct expand_vec_perm_d dremap, dfinal;
36326   unsigned i, j, nelt = d->nelt, nelt2 = nelt / 2, nelt4 = nelt / 4;
36327   unsigned contents[2];
36328   bool ok;
36329
36330   if (!(TARGET_AVX2
36331         && (d->vmode == V32QImode || d->vmode == V16HImode)
36332         && d->op0 == d->op1))
36333     return false;
36334
36335   contents[0] = 0;
36336   contents[1] = 0;
36337   for (i = 0; i < nelt2; ++i)
36338     {
36339       contents[0] |= 1u << (d->perm[i] / nelt4);
36340       contents[1] |= 1u << (d->perm[i + nelt2] / nelt4);
36341     }
36342
36343   for (i = 0; i < 2; ++i)
36344     {
36345       unsigned int cnt = 0;
36346       for (j = 0; j < 4; ++j)
36347         if ((contents[i] & (1u << j)) != 0 && ++cnt > 2)
36348           return false;
36349     }
36350
36351   if (d->testing_p)
36352     return true;
36353
36354   dremap = *d;
36355   dremap.vmode = V4DImode;
36356   dremap.nelt = 4;
36357   dremap.target = gen_reg_rtx (V4DImode);
36358   dremap.op0 = gen_lowpart (V4DImode, d->op0);
36359   dremap.op1 = dremap.op0;
36360   for (i = 0; i < 2; ++i)
36361     {
36362       unsigned int cnt = 0;
36363       for (j = 0; j < 4; ++j)
36364         if ((contents[i] & (1u << j)) != 0)
36365           dremap.perm[2 * i + cnt++] = j;
36366       for (; cnt < 2; ++cnt)
36367         dremap.perm[2 * i + cnt] = 0;
36368     }
36369
36370   dfinal = *d;
36371   dfinal.op0 = gen_lowpart (dfinal.vmode, dremap.target);
36372   dfinal.op1 = dfinal.op0;
36373   for (i = 0, j = 0; i < nelt; ++i)
36374     {
36375       if (i == nelt2)
36376         j = 2;
36377       dfinal.perm[i] = (d->perm[i] & (nelt4 - 1)) | (j ? nelt2 : 0);
36378       if ((d->perm[i] / nelt4) == dremap.perm[j])
36379         ;
36380       else if ((d->perm[i] / nelt4) == dremap.perm[j + 1])
36381         dfinal.perm[i] |= nelt4;
36382       else
36383         gcc_unreachable ();
36384     }
36385
36386   ok = expand_vec_perm_1 (&dremap);
36387   gcc_assert (ok);
36388
36389   ok = expand_vec_perm_1 (&dfinal);
36390   gcc_assert (ok);
36391
36392   return true;
36393 }
36394
36395 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Try to simplify
36396    a two vector permutation using 2 intra-lane interleave insns
36397    and cross-lane shuffle for 32-byte vectors.  */
36398
36399 static bool
36400 expand_vec_perm_interleave3 (struct expand_vec_perm_d *d)
36401 {
36402   unsigned i, nelt;
36403   rtx (*gen) (rtx, rtx, rtx);
36404
36405   if (d->op0 == d->op1)
36406     return false;
36407   if (TARGET_AVX2 && GET_MODE_SIZE (d->vmode) == 32)
36408     ;
36409   else if (TARGET_AVX && (d->vmode == V8SFmode || d->vmode == V4DFmode))
36410     ;
36411   else
36412     return false;
36413
36414   nelt = d->nelt;
36415   if (d->perm[0] != 0 && d->perm[0] != nelt / 2)
36416     return false;
36417   for (i = 0; i < nelt; i += 2)
36418     if (d->perm[i] != d->perm[0] + i / 2
36419         || d->perm[i + 1] != d->perm[0] + i / 2 + nelt)
36420       return false;
36421
36422   if (d->testing_p)
36423     return true;
36424
36425   switch (d->vmode)
36426     {
36427     case V32QImode:
36428       if (d->perm[0])
36429         gen = gen_vec_interleave_highv32qi;
36430       else
36431         gen = gen_vec_interleave_lowv32qi;
36432       break;
36433     case V16HImode:
36434       if (d->perm[0])
36435         gen = gen_vec_interleave_highv16hi;
36436       else
36437         gen = gen_vec_interleave_lowv16hi;
36438       break;
36439     case V8SImode:
36440       if (d->perm[0])
36441         gen = gen_vec_interleave_highv8si;
36442       else
36443         gen = gen_vec_interleave_lowv8si;
36444       break;
36445     case V4DImode:
36446       if (d->perm[0])
36447         gen = gen_vec_interleave_highv4di;
36448       else
36449         gen = gen_vec_interleave_lowv4di;
36450       break;
36451     case V8SFmode:
36452       if (d->perm[0])
36453         gen = gen_vec_interleave_highv8sf;
36454       else
36455         gen = gen_vec_interleave_lowv8sf;
36456       break;
36457     case V4DFmode:
36458       if (d->perm[0])
36459         gen = gen_vec_interleave_highv4df;
36460       else
36461         gen = gen_vec_interleave_lowv4df;
36462       break;
36463     default:
36464       gcc_unreachable ();
36465     }
36466
36467   emit_insn (gen (d->target, d->op0, d->op1));
36468   return true;
36469 }
36470
36471 /* A subroutine of expand_vec_perm_even_odd_1.  Implement the double-word
36472    permutation with two pshufb insns and an ior.  We should have already
36473    failed all two instruction sequences.  */
36474
36475 static bool
36476 expand_vec_perm_pshufb2 (struct expand_vec_perm_d *d)
36477 {
36478   rtx rperm[2][16], vperm, l, h, op, m128;
36479   unsigned int i, nelt, eltsz;
36480
36481   if (!TARGET_SSSE3 || GET_MODE_SIZE (d->vmode) != 16)
36482     return false;
36483   gcc_assert (d->op0 != d->op1);
36484
36485   nelt = d->nelt;
36486   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
36487
36488   /* Generate two permutation masks.  If the required element is within
36489      the given vector it is shuffled into the proper lane.  If the required
36490      element is in the other vector, force a zero into the lane by setting
36491      bit 7 in the permutation mask.  */
36492   m128 = GEN_INT (-128);
36493   for (i = 0; i < nelt; ++i)
36494     {
36495       unsigned j, e = d->perm[i];
36496       unsigned which = (e >= nelt);
36497       if (e >= nelt)
36498         e -= nelt;
36499
36500       for (j = 0; j < eltsz; ++j)
36501         {
36502           rperm[which][i*eltsz + j] = GEN_INT (e*eltsz + j);
36503           rperm[1-which][i*eltsz + j] = m128;
36504         }
36505     }
36506
36507   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[0]));
36508   vperm = force_reg (V16QImode, vperm);
36509
36510   l = gen_reg_rtx (V16QImode);
36511   op = gen_lowpart (V16QImode, d->op0);
36512   emit_insn (gen_ssse3_pshufbv16qi3 (l, op, vperm));
36513
36514   vperm = gen_rtx_CONST_VECTOR (V16QImode, gen_rtvec_v (16, rperm[1]));
36515   vperm = force_reg (V16QImode, vperm);
36516
36517   h = gen_reg_rtx (V16QImode);
36518   op = gen_lowpart (V16QImode, d->op1);
36519   emit_insn (gen_ssse3_pshufbv16qi3 (h, op, vperm));
36520
36521   op = gen_lowpart (V16QImode, d->target);
36522   emit_insn (gen_iorv16qi3 (op, l, h));
36523
36524   return true;
36525 }
36526
36527 /* Implement arbitrary permutation of one V32QImode and V16QImode operand
36528    with two vpshufb insns, vpermq and vpor.  We should have already failed
36529    all two or three instruction sequences.  */
36530
36531 static bool
36532 expand_vec_perm_vpshufb2_vpermq (struct expand_vec_perm_d *d)
36533 {
36534   rtx rperm[2][32], vperm, l, h, hp, op, m128;
36535   unsigned int i, nelt, eltsz;
36536
36537   if (!TARGET_AVX2
36538       || d->op0 != d->op1
36539       || (d->vmode != V32QImode && d->vmode != V16HImode))
36540     return false;
36541
36542   if (d->testing_p)
36543     return true;
36544
36545   nelt = d->nelt;
36546   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
36547
36548   /* Generate two permutation masks.  If the required element is within
36549      the same lane, it is shuffled in.  If the required element from the
36550      other lane, force a zero by setting bit 7 in the permutation mask.
36551      In the other mask the mask has non-negative elements if element
36552      is requested from the other lane, but also moved to the other lane,
36553      so that the result of vpshufb can have the two V2TImode halves
36554      swapped.  */
36555   m128 = GEN_INT (-128);
36556   for (i = 0; i < nelt; ++i)
36557     {
36558       unsigned j, e = d->perm[i] & (nelt / 2 - 1);
36559       unsigned which = ((d->perm[i] ^ i) & (nelt / 2)) * eltsz;
36560
36561       for (j = 0; j < eltsz; ++j)
36562         {
36563           rperm[!!which][(i * eltsz + j) ^ which] = GEN_INT (e * eltsz + j);
36564           rperm[!which][(i * eltsz + j) ^ (which ^ 16)] = m128;
36565         }
36566     }
36567
36568   vperm = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, rperm[1]));
36569   vperm = force_reg (V32QImode, vperm);
36570
36571   h = gen_reg_rtx (V32QImode);
36572   op = gen_lowpart (V32QImode, d->op0);
36573   emit_insn (gen_avx2_pshufbv32qi3 (h, op, vperm));
36574
36575   /* Swap the 128-byte lanes of h into hp.  */
36576   hp = gen_reg_rtx (V4DImode);
36577   op = gen_lowpart (V4DImode, h);
36578   emit_insn (gen_avx2_permv4di_1 (hp, op, const2_rtx, GEN_INT (3), const0_rtx,
36579                                   const1_rtx));
36580
36581   vperm = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, rperm[0]));
36582   vperm = force_reg (V32QImode, vperm);
36583
36584   l = gen_reg_rtx (V32QImode);
36585   op = gen_lowpart (V32QImode, d->op0);
36586   emit_insn (gen_avx2_pshufbv32qi3 (l, op, vperm));
36587
36588   op = gen_lowpart (V32QImode, d->target);
36589   emit_insn (gen_iorv32qi3 (op, l, gen_lowpart (V32QImode, hp)));
36590
36591   return true;
36592 }
36593
36594 /* A subroutine of expand_vec_perm_even_odd_1.  Implement extract-even
36595    and extract-odd permutations of two V32QImode and V16QImode operand
36596    with two vpshufb insns, vpor and vpermq.  We should have already
36597    failed all two or three instruction sequences.  */
36598
36599 static bool
36600 expand_vec_perm_vpshufb2_vpermq_even_odd (struct expand_vec_perm_d *d)
36601 {
36602   rtx rperm[2][32], vperm, l, h, ior, op, m128;
36603   unsigned int i, nelt, eltsz;
36604
36605   if (!TARGET_AVX2
36606       || d->op0 == d->op1
36607       || (d->vmode != V32QImode && d->vmode != V16HImode))
36608     return false;
36609
36610   for (i = 0; i < d->nelt; ++i)
36611     if ((d->perm[i] ^ (i * 2)) & (3 * d->nelt / 2))
36612       return false;
36613
36614   if (d->testing_p)
36615     return true;
36616
36617   nelt = d->nelt;
36618   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
36619
36620   /* Generate two permutation masks.  In the first permutation mask
36621      the first quarter will contain indexes for the first half
36622      of the op0, the second quarter will contain bit 7 set, third quarter
36623      will contain indexes for the second half of the op0 and the
36624      last quarter bit 7 set.  In the second permutation mask
36625      the first quarter will contain bit 7 set, the second quarter
36626      indexes for the first half of the op1, the third quarter bit 7 set
36627      and last quarter indexes for the second half of the op1.
36628      I.e. the first mask e.g. for V32QImode extract even will be:
36629      0, 2, ..., 0xe, -128, ..., -128, 0, 2, ..., 0xe, -128, ..., -128
36630      (all values masked with 0xf except for -128) and second mask
36631      for extract even will be
36632      -128, ..., -128, 0, 2, ..., 0xe, -128, ..., -128, 0, 2, ..., 0xe.  */
36633   m128 = GEN_INT (-128);
36634   for (i = 0; i < nelt; ++i)
36635     {
36636       unsigned j, e = d->perm[i] & (nelt / 2 - 1);
36637       unsigned which = d->perm[i] >= nelt;
36638       unsigned xorv = (i >= nelt / 4 && i < 3 * nelt / 4) ? 24 : 0;
36639
36640       for (j = 0; j < eltsz; ++j)
36641         {
36642           rperm[which][(i * eltsz + j) ^ xorv] = GEN_INT (e * eltsz + j);
36643           rperm[1 - which][(i * eltsz + j) ^ xorv] = m128;
36644         }
36645     }
36646
36647   vperm = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, rperm[0]));
36648   vperm = force_reg (V32QImode, vperm);
36649
36650   l = gen_reg_rtx (V32QImode);
36651   op = gen_lowpart (V32QImode, d->op0);
36652   emit_insn (gen_avx2_pshufbv32qi3 (l, op, vperm));
36653
36654   vperm = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, rperm[1]));
36655   vperm = force_reg (V32QImode, vperm);
36656
36657   h = gen_reg_rtx (V32QImode);
36658   op = gen_lowpart (V32QImode, d->op1);
36659   emit_insn (gen_avx2_pshufbv32qi3 (h, op, vperm));
36660
36661   ior = gen_reg_rtx (V32QImode);
36662   emit_insn (gen_iorv32qi3 (ior, l, h));
36663
36664   /* Permute the V4DImode quarters using { 0, 2, 1, 3 } permutation.  */
36665   op = gen_lowpart (V4DImode, d->target);
36666   ior = gen_lowpart (V4DImode, ior);
36667   emit_insn (gen_avx2_permv4di_1 (op, ior, const0_rtx, const2_rtx,
36668                                   const1_rtx, GEN_INT (3)));
36669
36670   return true;
36671 }
36672
36673 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement extract-even
36674    and extract-odd permutations.  */
36675
36676 static bool
36677 expand_vec_perm_even_odd_1 (struct expand_vec_perm_d *d, unsigned odd)
36678 {
36679   rtx t1, t2, t3;
36680
36681   switch (d->vmode)
36682     {
36683     case V4DFmode:
36684       t1 = gen_reg_rtx (V4DFmode);
36685       t2 = gen_reg_rtx (V4DFmode);
36686
36687       /* Shuffle the lanes around into { 0 1 4 5 } and { 2 3 6 7 }.  */
36688       emit_insn (gen_avx_vperm2f128v4df3 (t1, d->op0, d->op1, GEN_INT (0x20)));
36689       emit_insn (gen_avx_vperm2f128v4df3 (t2, d->op0, d->op1, GEN_INT (0x31)));
36690
36691       /* Now an unpck[lh]pd will produce the result required.  */
36692       if (odd)
36693         t3 = gen_avx_unpckhpd256 (d->target, t1, t2);
36694       else
36695         t3 = gen_avx_unpcklpd256 (d->target, t1, t2);
36696       emit_insn (t3);
36697       break;
36698
36699     case V8SFmode:
36700       {
36701         int mask = odd ? 0xdd : 0x88;
36702
36703         t1 = gen_reg_rtx (V8SFmode);
36704         t2 = gen_reg_rtx (V8SFmode);
36705         t3 = gen_reg_rtx (V8SFmode);
36706
36707         /* Shuffle within the 128-bit lanes to produce:
36708            { 0 2 8 a 4 6 c e } | { 1 3 9 b 5 7 d f }.  */
36709         emit_insn (gen_avx_shufps256 (t1, d->op0, d->op1,
36710                                       GEN_INT (mask)));
36711
36712         /* Shuffle the lanes around to produce:
36713            { 4 6 c e 0 2 8 a } and { 5 7 d f 1 3 9 b }.  */
36714         emit_insn (gen_avx_vperm2f128v8sf3 (t2, t1, t1,
36715                                             GEN_INT (0x3)));
36716
36717         /* Shuffle within the 128-bit lanes to produce:
36718            { 0 2 4 6 4 6 0 2 } | { 1 3 5 7 5 7 1 3 }.  */
36719         emit_insn (gen_avx_shufps256 (t3, t1, t2, GEN_INT (0x44)));
36720
36721         /* Shuffle within the 128-bit lanes to produce:
36722            { 8 a c e c e 8 a } | { 9 b d f d f 9 b }.  */
36723         emit_insn (gen_avx_shufps256 (t2, t1, t2, GEN_INT (0xee)));
36724
36725         /* Shuffle the lanes around to produce:
36726            { 0 2 4 6 8 a c e } | { 1 3 5 7 9 b d f }.  */
36727         emit_insn (gen_avx_vperm2f128v8sf3 (d->target, t3, t2,
36728                                             GEN_INT (0x20)));
36729       }
36730       break;
36731
36732     case V2DFmode:
36733     case V4SFmode:
36734     case V2DImode:
36735     case V4SImode:
36736       /* These are always directly implementable by expand_vec_perm_1.  */
36737       gcc_unreachable ();
36738
36739     case V8HImode:
36740       if (TARGET_SSSE3)
36741         return expand_vec_perm_pshufb2 (d);
36742       else
36743         {
36744           /* We need 2*log2(N)-1 operations to achieve odd/even
36745              with interleave. */
36746           t1 = gen_reg_rtx (V8HImode);
36747           t2 = gen_reg_rtx (V8HImode);
36748           emit_insn (gen_vec_interleave_highv8hi (t1, d->op0, d->op1));
36749           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->op0, d->op1));
36750           emit_insn (gen_vec_interleave_highv8hi (t2, d->target, t1));
36751           emit_insn (gen_vec_interleave_lowv8hi (d->target, d->target, t1));
36752           if (odd)
36753             t3 = gen_vec_interleave_highv8hi (d->target, d->target, t2);
36754           else
36755             t3 = gen_vec_interleave_lowv8hi (d->target, d->target, t2);
36756           emit_insn (t3);
36757         }
36758       break;
36759
36760     case V16QImode:
36761       if (TARGET_SSSE3)
36762         return expand_vec_perm_pshufb2 (d);
36763       else
36764         {
36765           t1 = gen_reg_rtx (V16QImode);
36766           t2 = gen_reg_rtx (V16QImode);
36767           t3 = gen_reg_rtx (V16QImode);
36768           emit_insn (gen_vec_interleave_highv16qi (t1, d->op0, d->op1));
36769           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->op0, d->op1));
36770           emit_insn (gen_vec_interleave_highv16qi (t2, d->target, t1));
36771           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t1));
36772           emit_insn (gen_vec_interleave_highv16qi (t3, d->target, t2));
36773           emit_insn (gen_vec_interleave_lowv16qi (d->target, d->target, t2));
36774           if (odd)
36775             t3 = gen_vec_interleave_highv16qi (d->target, d->target, t3);
36776           else
36777             t3 = gen_vec_interleave_lowv16qi (d->target, d->target, t3);
36778           emit_insn (t3);
36779         }
36780       break;
36781
36782     case V16HImode:
36783     case V32QImode:
36784       return expand_vec_perm_vpshufb2_vpermq_even_odd (d);
36785
36786     case V4DImode:
36787       if (!TARGET_AVX2)
36788         {
36789           struct expand_vec_perm_d d_copy = *d;
36790           d_copy.vmode = V4DFmode;
36791           d_copy.target = gen_lowpart (V4DFmode, d->target);
36792           d_copy.op0 = gen_lowpart (V4DFmode, d->op0);
36793           d_copy.op1 = gen_lowpart (V4DFmode, d->op1);
36794           return expand_vec_perm_even_odd_1 (&d_copy, odd);
36795         }
36796
36797       t1 = gen_reg_rtx (V4DImode);
36798       t2 = gen_reg_rtx (V4DImode);
36799
36800       /* Shuffle the lanes around into { 0 1 4 5 } and { 2 3 6 7 }.  */
36801       emit_insn (gen_avx2_permv2ti (t1, d->op0, d->op1, GEN_INT (0x20)));
36802       emit_insn (gen_avx2_permv2ti (t2, d->op0, d->op1, GEN_INT (0x31)));
36803
36804       /* Now an vpunpck[lh]qdq will produce the result required.  */
36805       if (odd)
36806         t3 = gen_avx2_interleave_highv4di (d->target, t1, t2);
36807       else
36808         t3 = gen_avx2_interleave_lowv4di (d->target, t1, t2);
36809       emit_insn (t3);
36810       break;
36811
36812     case V8SImode:
36813       if (!TARGET_AVX2)
36814         {
36815           struct expand_vec_perm_d d_copy = *d;
36816           d_copy.vmode = V8SFmode;
36817           d_copy.target = gen_lowpart (V8SFmode, d->target);
36818           d_copy.op0 = gen_lowpart (V8SFmode, d->op0);
36819           d_copy.op1 = gen_lowpart (V8SFmode, d->op1);
36820           return expand_vec_perm_even_odd_1 (&d_copy, odd);
36821         }
36822
36823       t1 = gen_reg_rtx (V8SImode);
36824       t2 = gen_reg_rtx (V8SImode);
36825
36826       /* Shuffle the lanes around into
36827          { 0 1 2 3 8 9 a b } and { 4 5 6 7 c d e f }.  */
36828       emit_insn (gen_avx2_permv2ti (gen_lowpart (V4DImode, t1),
36829                                     gen_lowpart (V4DImode, d->op0),
36830                                     gen_lowpart (V4DImode, d->op1),
36831                                     GEN_INT (0x20)));
36832       emit_insn (gen_avx2_permv2ti (gen_lowpart (V4DImode, t2),
36833                                     gen_lowpart (V4DImode, d->op0),
36834                                     gen_lowpart (V4DImode, d->op1),
36835                                     GEN_INT (0x31)));
36836
36837       /* Swap the 2nd and 3rd position in each lane into
36838          { 0 2 1 3 8 a 9 b } and { 4 6 5 7 c e d f }.  */
36839       emit_insn (gen_avx2_pshufdv3 (t1, t1,
36840                                     GEN_INT (2 * 4 + 1 * 16 + 3 * 64)));
36841       emit_insn (gen_avx2_pshufdv3 (t2, t2,
36842                                     GEN_INT (2 * 4 + 1 * 16 + 3 * 64)));
36843
36844       /* Now an vpunpck[lh]qdq will produce
36845          { 0 2 4 6 8 a c e } resp. { 1 3 5 7 9 b d f }.  */
36846       if (odd)
36847         t3 = gen_avx2_interleave_highv4di (gen_lowpart (V4DImode, d->target),
36848                                            gen_lowpart (V4DImode, t1),
36849                                            gen_lowpart (V4DImode, t2));
36850       else
36851         t3 = gen_avx2_interleave_lowv4di (gen_lowpart (V4DImode, d->target),
36852                                           gen_lowpart (V4DImode, t1),
36853                                           gen_lowpart (V4DImode, t2));
36854       emit_insn (t3);
36855       break;
36856
36857     default:
36858       gcc_unreachable ();
36859     }
36860
36861   return true;
36862 }
36863
36864 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
36865    extract-even and extract-odd permutations.  */
36866
36867 static bool
36868 expand_vec_perm_even_odd (struct expand_vec_perm_d *d)
36869 {
36870   unsigned i, odd, nelt = d->nelt;
36871
36872   odd = d->perm[0];
36873   if (odd != 0 && odd != 1)
36874     return false;
36875
36876   for (i = 1; i < nelt; ++i)
36877     if (d->perm[i] != 2 * i + odd)
36878       return false;
36879
36880   return expand_vec_perm_even_odd_1 (d, odd);
36881 }
36882
36883 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Implement broadcast
36884    permutations.  We assume that expand_vec_perm_1 has already failed.  */
36885
36886 static bool
36887 expand_vec_perm_broadcast_1 (struct expand_vec_perm_d *d)
36888 {
36889   unsigned elt = d->perm[0], nelt2 = d->nelt / 2;
36890   enum machine_mode vmode = d->vmode;
36891   unsigned char perm2[4];
36892   rtx op0 = d->op0;
36893   bool ok;
36894
36895   switch (vmode)
36896     {
36897     case V4DFmode:
36898     case V8SFmode:
36899       /* These are special-cased in sse.md so that we can optionally
36900          use the vbroadcast instruction.  They expand to two insns
36901          if the input happens to be in a register.  */
36902       gcc_unreachable ();
36903
36904     case V2DFmode:
36905     case V2DImode:
36906     case V4SFmode:
36907     case V4SImode:
36908       /* These are always implementable using standard shuffle patterns.  */
36909       gcc_unreachable ();
36910
36911     case V8HImode:
36912     case V16QImode:
36913       /* These can be implemented via interleave.  We save one insn by
36914          stopping once we have promoted to V4SImode and then use pshufd.  */
36915       do
36916         {
36917           rtx dest;
36918           rtx (*gen) (rtx, rtx, rtx)
36919             = vmode == V16QImode ? gen_vec_interleave_lowv16qi
36920                                  : gen_vec_interleave_lowv8hi;
36921
36922           if (elt >= nelt2)
36923             {
36924               gen = vmode == V16QImode ? gen_vec_interleave_highv16qi
36925                                        : gen_vec_interleave_highv8hi;
36926               elt -= nelt2;
36927             }
36928           nelt2 /= 2;
36929
36930           dest = gen_reg_rtx (vmode);
36931           emit_insn (gen (dest, op0, op0));
36932           vmode = get_mode_wider_vector (vmode);
36933           op0 = gen_lowpart (vmode, dest);
36934         }
36935       while (vmode != V4SImode);
36936
36937       memset (perm2, elt, 4);
36938       ok = expand_vselect (gen_lowpart (V4SImode, d->target), op0, perm2, 4);
36939       gcc_assert (ok);
36940       return true;
36941
36942     case V32QImode:
36943     case V16HImode:
36944     case V8SImode:
36945     case V4DImode:
36946       /* For AVX2 broadcasts of the first element vpbroadcast* or
36947          vpermq should be used by expand_vec_perm_1.  */
36948       gcc_assert (!TARGET_AVX2 || d->perm[0]);
36949       return false;
36950
36951     default:
36952       gcc_unreachable ();
36953     }
36954 }
36955
36956 /* A subroutine of ix86_expand_vec_perm_builtin_1.  Pattern match
36957    broadcast permutations.  */
36958
36959 static bool
36960 expand_vec_perm_broadcast (struct expand_vec_perm_d *d)
36961 {
36962   unsigned i, elt, nelt = d->nelt;
36963
36964   if (d->op0 != d->op1)
36965     return false;
36966
36967   elt = d->perm[0];
36968   for (i = 1; i < nelt; ++i)
36969     if (d->perm[i] != elt)
36970       return false;
36971
36972   return expand_vec_perm_broadcast_1 (d);
36973 }
36974
36975 /* Implement arbitrary permutation of two V32QImode and V16QImode operands
36976    with 4 vpshufb insns, 2 vpermq and 3 vpor.  We should have already failed
36977    all the shorter instruction sequences.  */
36978
36979 static bool
36980 expand_vec_perm_vpshufb4_vpermq2 (struct expand_vec_perm_d *d)
36981 {
36982   rtx rperm[4][32], vperm, l[2], h[2], op, m128;
36983   unsigned int i, nelt, eltsz;
36984   bool used[4];
36985
36986   if (!TARGET_AVX2
36987       || d->op0 == d->op1
36988       || (d->vmode != V32QImode && d->vmode != V16HImode))
36989     return false;
36990
36991   if (d->testing_p)
36992     return true;
36993
36994   nelt = d->nelt;
36995   eltsz = GET_MODE_SIZE (GET_MODE_INNER (d->vmode));
36996
36997   /* Generate 4 permutation masks.  If the required element is within
36998      the same lane, it is shuffled in.  If the required element from the
36999      other lane, force a zero by setting bit 7 in the permutation mask.
37000      In the other mask the mask has non-negative elements if element
37001      is requested from the other lane, but also moved to the other lane,
37002      so that the result of vpshufb can have the two V2TImode halves
37003      swapped.  */
37004   m128 = GEN_INT (-128);
37005   for (i = 0; i < 32; ++i)
37006     {
37007       rperm[0][i] = m128;
37008       rperm[1][i] = m128;
37009       rperm[2][i] = m128;
37010       rperm[3][i] = m128;
37011     }
37012   used[0] = false;
37013   used[1] = false;
37014   used[2] = false;
37015   used[3] = false;
37016   for (i = 0; i < nelt; ++i)
37017     {
37018       unsigned j, e = d->perm[i] & (nelt / 2 - 1);
37019       unsigned xlane = ((d->perm[i] ^ i) & (nelt / 2)) * eltsz;
37020       unsigned int which = ((d->perm[i] & nelt) ? 2 : 0) + (xlane ? 1 : 0);
37021
37022       for (j = 0; j < eltsz; ++j)
37023         rperm[which][(i * eltsz + j) ^ xlane] = GEN_INT (e * eltsz + j);
37024       used[which] = true;
37025     }
37026
37027   for (i = 0; i < 2; ++i)
37028     {
37029       if (!used[2 * i + 1])
37030         {
37031           h[i] = NULL_RTX;
37032           continue;
37033         }
37034       vperm = gen_rtx_CONST_VECTOR (V32QImode,
37035                                     gen_rtvec_v (32, rperm[2 * i + 1]));
37036       vperm = force_reg (V32QImode, vperm);
37037       h[i] = gen_reg_rtx (V32QImode);
37038       op = gen_lowpart (V32QImode, i ? d->op1 : d->op0);
37039       emit_insn (gen_avx2_pshufbv32qi3 (h[i], op, vperm));
37040     }
37041
37042   /* Swap the 128-byte lanes of h[X].  */
37043   for (i = 0; i < 2; ++i)
37044    {
37045      if (h[i] == NULL_RTX)
37046        continue;
37047      op = gen_reg_rtx (V4DImode);
37048      emit_insn (gen_avx2_permv4di_1 (op, gen_lowpart (V4DImode, h[i]),
37049                                      const2_rtx, GEN_INT (3), const0_rtx,
37050                                      const1_rtx));
37051      h[i] = gen_lowpart (V32QImode, op);
37052    }
37053
37054   for (i = 0; i < 2; ++i)
37055     {
37056       if (!used[2 * i])
37057         {
37058           l[i] = NULL_RTX;
37059           continue;
37060         }
37061       vperm = gen_rtx_CONST_VECTOR (V32QImode, gen_rtvec_v (32, rperm[2 * i]));
37062       vperm = force_reg (V32QImode, vperm);
37063       l[i] = gen_reg_rtx (V32QImode);
37064       op = gen_lowpart (V32QImode, i ? d->op1 : d->op0);
37065       emit_insn (gen_avx2_pshufbv32qi3 (l[i], op, vperm));
37066     }
37067
37068   for (i = 0; i < 2; ++i)
37069     {
37070       if (h[i] && l[i])
37071         {
37072           op = gen_reg_rtx (V32QImode);
37073           emit_insn (gen_iorv32qi3 (op, l[i], h[i]));
37074           l[i] = op;
37075         }
37076       else if (h[i])
37077         l[i] = h[i];
37078     }
37079
37080   gcc_assert (l[0] && l[1]);
37081   op = gen_lowpart (V32QImode, d->target);
37082   emit_insn (gen_iorv32qi3 (op, l[0], l[1]));
37083   return true;
37084 }
37085
37086 /* The guts of ix86_expand_vec_perm_const, also used by the ok hook.
37087    With all of the interface bits taken care of, perform the expansion
37088    in D and return true on success.  */
37089
37090 static bool
37091 ix86_expand_vec_perm_const_1 (struct expand_vec_perm_d *d)
37092 {
37093   /* Try a single instruction expansion.  */
37094   if (expand_vec_perm_1 (d))
37095     return true;
37096
37097   /* Try sequences of two instructions.  */
37098
37099   if (expand_vec_perm_pshuflw_pshufhw (d))
37100     return true;
37101
37102   if (expand_vec_perm_palignr (d))
37103     return true;
37104
37105   if (expand_vec_perm_interleave2 (d))
37106     return true;
37107
37108   if (expand_vec_perm_broadcast (d))
37109     return true;
37110
37111   if (expand_vec_perm_vpermq_perm_1 (d))
37112     return true;
37113
37114   /* Try sequences of three instructions.  */
37115
37116   if (expand_vec_perm_pshufb2 (d))
37117     return true;
37118
37119   if (expand_vec_perm_interleave3 (d))
37120     return true;
37121
37122   /* Try sequences of four instructions.  */
37123
37124   if (expand_vec_perm_vpshufb2_vpermq (d))
37125     return true;
37126
37127   if (expand_vec_perm_vpshufb2_vpermq_even_odd (d))
37128     return true;
37129
37130   /* ??? Look for narrow permutations whose element orderings would
37131      allow the promotion to a wider mode.  */
37132
37133   /* ??? Look for sequences of interleave or a wider permute that place
37134      the data into the correct lanes for a half-vector shuffle like
37135      pshuf[lh]w or vpermilps.  */
37136
37137   /* ??? Look for sequences of interleave that produce the desired results.
37138      The combinatorics of punpck[lh] get pretty ugly... */
37139
37140   if (expand_vec_perm_even_odd (d))
37141     return true;
37142
37143   /* Even longer sequences.  */
37144   if (expand_vec_perm_vpshufb4_vpermq2 (d))
37145     return true;
37146
37147   return false;
37148 }
37149
37150 bool
37151 ix86_expand_vec_perm_const (rtx operands[4])
37152 {
37153   struct expand_vec_perm_d d;
37154   unsigned char perm[MAX_VECT_LEN];
37155   int i, nelt, which;
37156   rtx sel;
37157
37158   d.target = operands[0];
37159   d.op0 = operands[1];
37160   d.op1 = operands[2];
37161   sel = operands[3];
37162
37163   d.vmode = GET_MODE (d.target);
37164   gcc_assert (VECTOR_MODE_P (d.vmode));
37165   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
37166   d.testing_p = false;
37167
37168   gcc_assert (GET_CODE (sel) == CONST_VECTOR);
37169   gcc_assert (XVECLEN (sel, 0) == nelt);
37170   gcc_checking_assert (sizeof (d.perm) == sizeof (perm));
37171
37172   for (i = which = 0; i < nelt; ++i)
37173     {
37174       rtx e = XVECEXP (sel, 0, i);
37175       int ei = INTVAL (e) & (2 * nelt - 1);
37176
37177       which |= (ei < nelt ? 1 : 2);
37178       d.perm[i] = ei;
37179       perm[i] = ei;
37180     }
37181
37182   switch (which)
37183     {
37184     default:
37185       gcc_unreachable();
37186
37187     case 3:
37188       if (!rtx_equal_p (d.op0, d.op1))
37189         break;
37190
37191       /* The elements of PERM do not suggest that only the first operand
37192          is used, but both operands are identical.  Allow easier matching
37193          of the permutation by folding the permutation into the single
37194          input vector.  */
37195       for (i = 0; i < nelt; ++i)
37196         if (d.perm[i] >= nelt)
37197           d.perm[i] -= nelt;
37198       /* FALLTHRU */
37199
37200     case 1:
37201       d.op1 = d.op0;
37202       break;
37203
37204     case 2:
37205       for (i = 0; i < nelt; ++i)
37206         d.perm[i] -= nelt;
37207       d.op0 = d.op1;
37208       break;
37209     }
37210
37211   if (ix86_expand_vec_perm_const_1 (&d))
37212     return true;
37213
37214   /* If the mask says both arguments are needed, but they are the same,
37215      the above tried to expand with d.op0 == d.op1.  If that didn't work,
37216      retry with d.op0 != d.op1 as that is what testing has been done with.  */
37217   if (which == 3 && d.op0 == d.op1)
37218     {
37219       rtx seq;
37220       bool ok;
37221
37222       memcpy (d.perm, perm, sizeof (perm));
37223       d.op1 = gen_reg_rtx (d.vmode);
37224       start_sequence ();
37225       ok = ix86_expand_vec_perm_const_1 (&d);
37226       seq = get_insns ();
37227       end_sequence ();
37228       if (ok)
37229         {
37230           emit_move_insn (d.op1, d.op0);
37231           emit_insn (seq);
37232           return true;
37233         }
37234     }
37235
37236   return false;
37237 }
37238
37239 /* Implement targetm.vectorize.vec_perm_const_ok.  */
37240
37241 static bool
37242 ix86_vectorize_vec_perm_const_ok (enum machine_mode vmode,
37243                                   const unsigned char *sel)
37244 {
37245   struct expand_vec_perm_d d;
37246   unsigned int i, nelt, which;
37247   bool ret, one_vec;
37248
37249   d.vmode = vmode;
37250   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
37251   d.testing_p = true;
37252
37253   /* Given sufficient ISA support we can just return true here
37254      for selected vector modes.  */
37255   if (GET_MODE_SIZE (d.vmode) == 16)
37256     {
37257       /* All implementable with a single vpperm insn.  */
37258       if (TARGET_XOP)
37259         return true;
37260       /* All implementable with 2 pshufb + 1 ior.  */
37261       if (TARGET_SSSE3)
37262         return true;
37263       /* All implementable with shufpd or unpck[lh]pd.  */
37264       if (d.nelt == 2)
37265         return true;
37266     }
37267
37268   /* Extract the values from the vector CST into the permutation
37269      array in D.  */
37270   memcpy (d.perm, sel, nelt);
37271   for (i = which = 0; i < nelt; ++i)
37272     {
37273       unsigned char e = d.perm[i];
37274       gcc_assert (e < 2 * nelt);
37275       which |= (e < nelt ? 1 : 2);
37276     }
37277
37278   /* For all elements from second vector, fold the elements to first.  */
37279   if (which == 2)
37280     for (i = 0; i < nelt; ++i)
37281       d.perm[i] -= nelt;
37282
37283   /* Check whether the mask can be applied to the vector type.  */
37284   one_vec = (which != 3);
37285
37286   /* Implementable with shufps or pshufd.  */
37287   if (one_vec && (d.vmode == V4SFmode || d.vmode == V4SImode))
37288     return true;
37289
37290   /* Otherwise we have to go through the motions and see if we can
37291      figure out how to generate the requested permutation.  */
37292   d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1);
37293   d.op1 = d.op0 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 2);
37294   if (!one_vec)
37295     d.op1 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 3);
37296
37297   start_sequence ();
37298   ret = ix86_expand_vec_perm_const_1 (&d);
37299   end_sequence ();
37300
37301   return ret;
37302 }
37303
37304 void
37305 ix86_expand_vec_extract_even_odd (rtx targ, rtx op0, rtx op1, unsigned odd)
37306 {
37307   struct expand_vec_perm_d d;
37308   unsigned i, nelt;
37309
37310   d.target = targ;
37311   d.op0 = op0;
37312   d.op1 = op1;
37313   d.vmode = GET_MODE (targ);
37314   d.nelt = nelt = GET_MODE_NUNITS (d.vmode);
37315   d.testing_p = false;
37316
37317   for (i = 0; i < nelt; ++i)
37318     d.perm[i] = i * 2 + odd;
37319
37320   /* We'll either be able to implement the permutation directly...  */
37321   if (expand_vec_perm_1 (&d))
37322     return;
37323
37324   /* ... or we use the special-case patterns.  */
37325   expand_vec_perm_even_odd_1 (&d, odd);
37326 }
37327
37328 /* Expand an insert into a vector register through pinsr insn.
37329    Return true if successful.  */
37330
37331 bool
37332 ix86_expand_pinsr (rtx *operands)
37333 {
37334   rtx dst = operands[0];
37335   rtx src = operands[3];
37336
37337   unsigned int size = INTVAL (operands[1]);
37338   unsigned int pos = INTVAL (operands[2]);
37339
37340   if (GET_CODE (dst) == SUBREG)
37341     {
37342       pos += SUBREG_BYTE (dst) * BITS_PER_UNIT;
37343       dst = SUBREG_REG (dst);
37344     }
37345
37346   if (GET_CODE (src) == SUBREG)
37347     src = SUBREG_REG (src);
37348
37349   switch (GET_MODE (dst))
37350     {
37351     case V16QImode:
37352     case V8HImode:
37353     case V4SImode:
37354     case V2DImode:
37355       {
37356         enum machine_mode srcmode, dstmode;
37357         rtx (*pinsr)(rtx, rtx, rtx, rtx);
37358
37359         srcmode = mode_for_size (size, MODE_INT, 0);
37360
37361         switch (srcmode)
37362           {
37363           case QImode:
37364             if (!TARGET_SSE4_1)
37365               return false;
37366             dstmode = V16QImode;
37367             pinsr = gen_sse4_1_pinsrb;
37368             break;
37369
37370           case HImode:
37371             if (!TARGET_SSE2)
37372               return false;
37373             dstmode = V8HImode;
37374             pinsr = gen_sse2_pinsrw;
37375             break;
37376
37377           case SImode:
37378             if (!TARGET_SSE4_1)
37379               return false;
37380             dstmode = V4SImode;
37381             pinsr = gen_sse4_1_pinsrd;
37382             break;
37383
37384           case DImode:
37385             gcc_assert (TARGET_64BIT);
37386             if (!TARGET_SSE4_1)
37387               return false;
37388             dstmode = V2DImode;
37389             pinsr = gen_sse4_1_pinsrq;
37390             break;
37391
37392           default:
37393             return false;
37394           }
37395
37396         dst = gen_lowpart (dstmode, dst);
37397         src = gen_lowpart (srcmode, src);
37398
37399         pos /= size;
37400
37401         emit_insn (pinsr (dst, dst, src, GEN_INT (1 << pos)));
37402         return true;
37403       }
37404
37405     default:
37406       return false;
37407     }
37408 }
37409 \f
37410 /* This function returns the calling abi specific va_list type node.
37411    It returns  the FNDECL specific va_list type.  */
37412
37413 static tree
37414 ix86_fn_abi_va_list (tree fndecl)
37415 {
37416   if (!TARGET_64BIT)
37417     return va_list_type_node;
37418   gcc_assert (fndecl != NULL_TREE);
37419
37420   if (ix86_function_abi ((const_tree) fndecl) == MS_ABI)
37421     return ms_va_list_type_node;
37422   else
37423     return sysv_va_list_type_node;
37424 }
37425
37426 /* Returns the canonical va_list type specified by TYPE. If there
37427    is no valid TYPE provided, it return NULL_TREE.  */
37428
37429 static tree
37430 ix86_canonical_va_list_type (tree type)
37431 {
37432   tree wtype, htype;
37433
37434   /* Resolve references and pointers to va_list type.  */
37435   if (TREE_CODE (type) == MEM_REF)
37436     type = TREE_TYPE (type);
37437   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
37438     type = TREE_TYPE (type);
37439   else if (POINTER_TYPE_P (type) && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
37440     type = TREE_TYPE (type);
37441
37442   if (TARGET_64BIT && va_list_type_node != NULL_TREE)
37443     {
37444       wtype = va_list_type_node;
37445           gcc_assert (wtype != NULL_TREE);
37446       htype = type;
37447       if (TREE_CODE (wtype) == ARRAY_TYPE)
37448         {
37449           /* If va_list is an array type, the argument may have decayed
37450              to a pointer type, e.g. by being passed to another function.
37451              In that case, unwrap both types so that we can compare the
37452              underlying records.  */
37453           if (TREE_CODE (htype) == ARRAY_TYPE
37454               || POINTER_TYPE_P (htype))
37455             {
37456               wtype = TREE_TYPE (wtype);
37457               htype = TREE_TYPE (htype);
37458             }
37459         }
37460       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
37461         return va_list_type_node;
37462       wtype = sysv_va_list_type_node;
37463           gcc_assert (wtype != NULL_TREE);
37464       htype = type;
37465       if (TREE_CODE (wtype) == ARRAY_TYPE)
37466         {
37467           /* If va_list is an array type, the argument may have decayed
37468              to a pointer type, e.g. by being passed to another function.
37469              In that case, unwrap both types so that we can compare the
37470              underlying records.  */
37471           if (TREE_CODE (htype) == ARRAY_TYPE
37472               || POINTER_TYPE_P (htype))
37473             {
37474               wtype = TREE_TYPE (wtype);
37475               htype = TREE_TYPE (htype);
37476             }
37477         }
37478       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
37479         return sysv_va_list_type_node;
37480       wtype = ms_va_list_type_node;
37481           gcc_assert (wtype != NULL_TREE);
37482       htype = type;
37483       if (TREE_CODE (wtype) == ARRAY_TYPE)
37484         {
37485           /* If va_list is an array type, the argument may have decayed
37486              to a pointer type, e.g. by being passed to another function.
37487              In that case, unwrap both types so that we can compare the
37488              underlying records.  */
37489           if (TREE_CODE (htype) == ARRAY_TYPE
37490               || POINTER_TYPE_P (htype))
37491             {
37492               wtype = TREE_TYPE (wtype);
37493               htype = TREE_TYPE (htype);
37494             }
37495         }
37496       if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
37497         return ms_va_list_type_node;
37498       return NULL_TREE;
37499     }
37500   return std_canonical_va_list_type (type);
37501 }
37502
37503 /* Iterate through the target-specific builtin types for va_list.
37504    IDX denotes the iterator, *PTREE is set to the result type of
37505    the va_list builtin, and *PNAME to its internal type.
37506    Returns zero if there is no element for this index, otherwise
37507    IDX should be increased upon the next call.
37508    Note, do not iterate a base builtin's name like __builtin_va_list.
37509    Used from c_common_nodes_and_builtins.  */
37510
37511 static int
37512 ix86_enum_va_list (int idx, const char **pname, tree *ptree)
37513 {
37514   if (TARGET_64BIT)
37515     {
37516       switch (idx)
37517         {
37518         default:
37519           break;
37520
37521         case 0:
37522           *ptree = ms_va_list_type_node;
37523           *pname = "__builtin_ms_va_list";
37524           return 1;
37525
37526         case 1:
37527           *ptree = sysv_va_list_type_node;
37528           *pname = "__builtin_sysv_va_list";
37529           return 1;
37530         }
37531     }
37532
37533   return 0;
37534 }
37535
37536 #undef TARGET_SCHED_DISPATCH
37537 #define TARGET_SCHED_DISPATCH has_dispatch
37538 #undef TARGET_SCHED_DISPATCH_DO
37539 #define TARGET_SCHED_DISPATCH_DO do_dispatch
37540 #undef TARGET_SCHED_REASSOCIATION_WIDTH
37541 #define TARGET_SCHED_REASSOCIATION_WIDTH ix86_reassociation_width
37542
37543 /* The size of the dispatch window is the total number of bytes of
37544    object code allowed in a window.  */
37545 #define DISPATCH_WINDOW_SIZE 16
37546
37547 /* Number of dispatch windows considered for scheduling.  */
37548 #define MAX_DISPATCH_WINDOWS 3
37549
37550 /* Maximum number of instructions in a window.  */
37551 #define MAX_INSN 4
37552
37553 /* Maximum number of immediate operands in a window.  */
37554 #define MAX_IMM 4
37555
37556 /* Maximum number of immediate bits allowed in a window.  */
37557 #define MAX_IMM_SIZE 128
37558
37559 /* Maximum number of 32 bit immediates allowed in a window.  */
37560 #define MAX_IMM_32 4
37561
37562 /* Maximum number of 64 bit immediates allowed in a window.  */
37563 #define MAX_IMM_64 2
37564
37565 /* Maximum total of loads or prefetches allowed in a window.  */
37566 #define MAX_LOAD 2
37567
37568 /* Maximum total of stores allowed in a window.  */
37569 #define MAX_STORE 1
37570
37571 #undef BIG
37572 #define BIG 100
37573
37574
37575 /* Dispatch groups.  Istructions that affect the mix in a dispatch window.  */
37576 enum dispatch_group {
37577   disp_no_group = 0,
37578   disp_load,
37579   disp_store,
37580   disp_load_store,
37581   disp_prefetch,
37582   disp_imm,
37583   disp_imm_32,
37584   disp_imm_64,
37585   disp_branch,
37586   disp_cmp,
37587   disp_jcc,
37588   disp_last
37589 };
37590
37591 /* Number of allowable groups in a dispatch window.  It is an array
37592    indexed by dispatch_group enum.  100 is used as a big number,
37593    because the number of these kind of operations does not have any
37594    effect in dispatch window, but we need them for other reasons in
37595    the table.  */
37596 static unsigned int num_allowable_groups[disp_last] = {
37597   0, 2, 1, 1, 2, 4, 4, 2, 1, BIG, BIG
37598 };
37599
37600 char group_name[disp_last + 1][16] = {
37601   "disp_no_group", "disp_load", "disp_store", "disp_load_store",
37602   "disp_prefetch", "disp_imm", "disp_imm_32", "disp_imm_64",
37603   "disp_branch", "disp_cmp", "disp_jcc", "disp_last"
37604 };
37605
37606 /* Instruction path.  */
37607 enum insn_path {
37608   no_path = 0,
37609   path_single, /* Single micro op.  */
37610   path_double, /* Double micro op.  */
37611   path_multi,  /* Instructions with more than 2 micro op..  */
37612   last_path
37613 };
37614
37615 /* sched_insn_info defines a window to the instructions scheduled in
37616    the basic block.  It contains a pointer to the insn_info table and
37617    the instruction scheduled.
37618
37619    Windows are allocated for each basic block and are linked
37620    together.  */
37621 typedef struct sched_insn_info_s {
37622   rtx insn;
37623   enum dispatch_group group;
37624   enum insn_path path;
37625   int byte_len;
37626   int imm_bytes;
37627 } sched_insn_info;
37628
37629 /* Linked list of dispatch windows.  This is a two way list of
37630    dispatch windows of a basic block.  It contains information about
37631    the number of uops in the window and the total number of
37632    instructions and of bytes in the object code for this dispatch
37633    window.  */
37634 typedef struct dispatch_windows_s {
37635   int num_insn;            /* Number of insn in the window.  */
37636   int num_uops;            /* Number of uops in the window.  */
37637   int window_size;         /* Number of bytes in the window.  */
37638   int window_num;          /* Window number between 0 or 1.  */
37639   int num_imm;             /* Number of immediates in an insn.  */
37640   int num_imm_32;          /* Number of 32 bit immediates in an insn.  */
37641   int num_imm_64;          /* Number of 64 bit immediates in an insn.  */
37642   int imm_size;            /* Total immediates in the window.  */
37643   int num_loads;           /* Total memory loads in the window.  */
37644   int num_stores;          /* Total memory stores in the window.  */
37645   int violation;          /* Violation exists in window.  */
37646   sched_insn_info *window; /* Pointer to the window.  */
37647   struct dispatch_windows_s *next;
37648   struct dispatch_windows_s *prev;
37649 } dispatch_windows;
37650
37651 /* Immediate valuse used in an insn.  */
37652 typedef struct imm_info_s
37653   {
37654     int imm;
37655     int imm32;
37656     int imm64;
37657   } imm_info;
37658
37659 static dispatch_windows *dispatch_window_list;
37660 static dispatch_windows *dispatch_window_list1;
37661
37662 /* Get dispatch group of insn.  */
37663
37664 static enum dispatch_group
37665 get_mem_group (rtx insn)
37666 {
37667   enum attr_memory memory;
37668
37669   if (INSN_CODE (insn) < 0)
37670     return disp_no_group;
37671   memory = get_attr_memory (insn);
37672   if (memory == MEMORY_STORE)
37673     return disp_store;
37674
37675   if (memory == MEMORY_LOAD)
37676     return disp_load;
37677
37678   if (memory == MEMORY_BOTH)
37679     return disp_load_store;
37680
37681   return disp_no_group;
37682 }
37683
37684 /* Return true if insn is a compare instruction.  */
37685
37686 static bool
37687 is_cmp (rtx insn)
37688 {
37689   enum attr_type type;
37690
37691   type = get_attr_type (insn);
37692   return (type == TYPE_TEST
37693           || type == TYPE_ICMP
37694           || type == TYPE_FCMP
37695           || GET_CODE (PATTERN (insn)) == COMPARE);
37696 }
37697
37698 /* Return true if a dispatch violation encountered.  */
37699
37700 static bool
37701 dispatch_violation (void)
37702 {
37703   if (dispatch_window_list->next)
37704     return dispatch_window_list->next->violation;
37705   return dispatch_window_list->violation;
37706 }
37707
37708 /* Return true if insn is a branch instruction.  */
37709
37710 static bool
37711 is_branch (rtx insn)
37712 {
37713   return (CALL_P (insn) || JUMP_P (insn));
37714 }
37715
37716 /* Return true if insn is a prefetch instruction.  */
37717
37718 static bool
37719 is_prefetch (rtx insn)
37720 {
37721   return NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == PREFETCH;
37722 }
37723
37724 /* This function initializes a dispatch window and the list container holding a
37725    pointer to the window.  */
37726
37727 static void
37728 init_window (int window_num)
37729 {
37730   int i;
37731   dispatch_windows *new_list;
37732
37733   if (window_num == 0)
37734     new_list = dispatch_window_list;
37735   else
37736     new_list = dispatch_window_list1;
37737
37738   new_list->num_insn = 0;
37739   new_list->num_uops = 0;
37740   new_list->window_size = 0;
37741   new_list->next = NULL;
37742   new_list->prev = NULL;
37743   new_list->window_num = window_num;
37744   new_list->num_imm = 0;
37745   new_list->num_imm_32 = 0;
37746   new_list->num_imm_64 = 0;
37747   new_list->imm_size = 0;
37748   new_list->num_loads = 0;
37749   new_list->num_stores = 0;
37750   new_list->violation = false;
37751
37752   for (i = 0; i < MAX_INSN; i++)
37753     {
37754       new_list->window[i].insn = NULL;
37755       new_list->window[i].group = disp_no_group;
37756       new_list->window[i].path = no_path;
37757       new_list->window[i].byte_len = 0;
37758       new_list->window[i].imm_bytes = 0;
37759     }
37760   return;
37761 }
37762
37763 /* This function allocates and initializes a dispatch window and the
37764    list container holding a pointer to the window.  */
37765
37766 static dispatch_windows *
37767 allocate_window (void)
37768 {
37769   dispatch_windows *new_list = XNEW (struct dispatch_windows_s);
37770   new_list->window = XNEWVEC (struct sched_insn_info_s, MAX_INSN + 1);
37771
37772   return new_list;
37773 }
37774
37775 /* This routine initializes the dispatch scheduling information.  It
37776    initiates building dispatch scheduler tables and constructs the
37777    first dispatch window.  */
37778
37779 static void
37780 init_dispatch_sched (void)
37781 {
37782   /* Allocate a dispatch list and a window.  */
37783   dispatch_window_list = allocate_window ();
37784   dispatch_window_list1 = allocate_window ();
37785   init_window (0);
37786   init_window (1);
37787 }
37788
37789 /* This function returns true if a branch is detected.  End of a basic block
37790    does not have to be a branch, but here we assume only branches end a
37791    window.  */
37792
37793 static bool
37794 is_end_basic_block (enum dispatch_group group)
37795 {
37796   return group == disp_branch;
37797 }
37798
37799 /* This function is called when the end of a window processing is reached.  */
37800
37801 static void
37802 process_end_window (void)
37803 {
37804   gcc_assert (dispatch_window_list->num_insn <= MAX_INSN);
37805   if (dispatch_window_list->next)
37806     {
37807       gcc_assert (dispatch_window_list1->num_insn <= MAX_INSN);
37808       gcc_assert (dispatch_window_list->window_size
37809                   + dispatch_window_list1->window_size <= 48);
37810       init_window (1);
37811     }
37812   init_window (0);
37813 }
37814
37815 /* Allocates a new dispatch window and adds it to WINDOW_LIST.
37816    WINDOW_NUM is either 0 or 1.  A maximum of two windows are generated
37817    for 48 bytes of instructions.  Note that these windows are not dispatch
37818    windows that their sizes are DISPATCH_WINDOW_SIZE.  */
37819
37820 static dispatch_windows *
37821 allocate_next_window (int window_num)
37822 {
37823   if (window_num == 0)
37824     {
37825       if (dispatch_window_list->next)
37826           init_window (1);
37827       init_window (0);
37828       return dispatch_window_list;
37829     }
37830
37831   dispatch_window_list->next = dispatch_window_list1;
37832   dispatch_window_list1->prev = dispatch_window_list;
37833
37834   return dispatch_window_list1;
37835 }
37836
37837 /* Increment the number of immediate operands of an instruction.  */
37838
37839 static int
37840 find_constant_1 (rtx *in_rtx, imm_info *imm_values)
37841 {
37842   if (*in_rtx == 0)
37843     return 0;
37844
37845     switch ( GET_CODE (*in_rtx))
37846     {
37847     case CONST:
37848     case SYMBOL_REF:
37849     case CONST_INT:
37850       (imm_values->imm)++;
37851       if (x86_64_immediate_operand (*in_rtx, SImode))
37852         (imm_values->imm32)++;
37853       else
37854         (imm_values->imm64)++;
37855       break;
37856
37857     case CONST_DOUBLE:
37858       (imm_values->imm)++;
37859       (imm_values->imm64)++;
37860       break;
37861
37862     case CODE_LABEL:
37863       if (LABEL_KIND (*in_rtx) == LABEL_NORMAL)
37864         {
37865           (imm_values->imm)++;
37866           (imm_values->imm32)++;
37867         }
37868       break;
37869
37870     default:
37871       break;
37872     }
37873
37874   return 0;
37875 }
37876
37877 /* Compute number of immediate operands of an instruction.  */
37878
37879 static void
37880 find_constant (rtx in_rtx, imm_info *imm_values)
37881 {
37882   for_each_rtx (INSN_P (in_rtx) ? &PATTERN (in_rtx) : &in_rtx,
37883                 (rtx_function) find_constant_1, (void *) imm_values);
37884 }
37885
37886 /* Return total size of immediate operands of an instruction along with number
37887    of corresponding immediate-operands.  It initializes its parameters to zero
37888    befor calling FIND_CONSTANT.
37889    INSN is the input instruction.  IMM is the total of immediates.
37890    IMM32 is the number of 32 bit immediates.  IMM64 is the number of 64
37891    bit immediates.  */
37892
37893 static int
37894 get_num_immediates (rtx insn, int *imm, int *imm32, int *imm64)
37895 {
37896   imm_info imm_values = {0, 0, 0};
37897
37898   find_constant (insn, &imm_values);
37899   *imm = imm_values.imm;
37900   *imm32 = imm_values.imm32;
37901   *imm64 = imm_values.imm64;
37902   return imm_values.imm32 * 4 + imm_values.imm64 * 8;
37903 }
37904
37905 /* This function indicates if an operand of an instruction is an
37906    immediate.  */
37907
37908 static bool
37909 has_immediate (rtx insn)
37910 {
37911   int num_imm_operand;
37912   int num_imm32_operand;
37913   int num_imm64_operand;
37914
37915   if (insn)
37916     return get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
37917                                &num_imm64_operand);
37918   return false;
37919 }
37920
37921 /* Return single or double path for instructions.  */
37922
37923 static enum insn_path
37924 get_insn_path (rtx insn)
37925 {
37926   enum attr_amdfam10_decode path = get_attr_amdfam10_decode (insn);
37927
37928   if ((int)path == 0)
37929     return path_single;
37930
37931   if ((int)path == 1)
37932     return path_double;
37933
37934   return path_multi;
37935 }
37936
37937 /* Return insn dispatch group.  */
37938
37939 static enum dispatch_group
37940 get_insn_group (rtx insn)
37941 {
37942   enum dispatch_group group = get_mem_group (insn);
37943   if (group)
37944     return group;
37945
37946   if (is_branch (insn))
37947     return disp_branch;
37948
37949   if (is_cmp (insn))
37950     return disp_cmp;
37951
37952   if (has_immediate (insn))
37953     return disp_imm;
37954
37955   if (is_prefetch (insn))
37956     return disp_prefetch;
37957
37958   return disp_no_group;
37959 }
37960
37961 /* Count number of GROUP restricted instructions in a dispatch
37962    window WINDOW_LIST.  */
37963
37964 static int
37965 count_num_restricted (rtx insn, dispatch_windows *window_list)
37966 {
37967   enum dispatch_group group = get_insn_group (insn);
37968   int imm_size;
37969   int num_imm_operand;
37970   int num_imm32_operand;
37971   int num_imm64_operand;
37972
37973   if (group == disp_no_group)
37974     return 0;
37975
37976   if (group == disp_imm)
37977     {
37978       imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
37979                               &num_imm64_operand);
37980       if (window_list->imm_size + imm_size > MAX_IMM_SIZE
37981           || num_imm_operand + window_list->num_imm > MAX_IMM
37982           || (num_imm32_operand > 0
37983               && (window_list->num_imm_32 + num_imm32_operand > MAX_IMM_32
37984                   || window_list->num_imm_64 * 2 + num_imm32_operand > MAX_IMM_32))
37985           || (num_imm64_operand > 0
37986               && (window_list->num_imm_64 + num_imm64_operand > MAX_IMM_64
37987                   || window_list->num_imm_32 + num_imm64_operand * 2 > MAX_IMM_32))
37988           || (window_list->imm_size + imm_size == MAX_IMM_SIZE
37989               && num_imm64_operand > 0
37990               && ((window_list->num_imm_64 > 0
37991                    && window_list->num_insn >= 2)
37992                   || window_list->num_insn >= 3)))
37993         return BIG;
37994
37995       return 1;
37996     }
37997
37998   if ((group == disp_load_store
37999        && (window_list->num_loads >= MAX_LOAD
38000            || window_list->num_stores >= MAX_STORE))
38001       || ((group == disp_load
38002            || group == disp_prefetch)
38003           && window_list->num_loads >= MAX_LOAD)
38004       || (group == disp_store
38005           && window_list->num_stores >= MAX_STORE))
38006     return BIG;
38007
38008   return 1;
38009 }
38010
38011 /* This function returns true if insn satisfies dispatch rules on the
38012    last window scheduled.  */
38013
38014 static bool
38015 fits_dispatch_window (rtx insn)
38016 {
38017   dispatch_windows *window_list = dispatch_window_list;
38018   dispatch_windows *window_list_next = dispatch_window_list->next;
38019   unsigned int num_restrict;
38020   enum dispatch_group group = get_insn_group (insn);
38021   enum insn_path path = get_insn_path (insn);
38022   int sum;
38023
38024   /* Make disp_cmp and disp_jcc get scheduled at the latest.  These
38025      instructions should be given the lowest priority in the
38026      scheduling process in Haifa scheduler to make sure they will be
38027      scheduled in the same dispatch window as the refrence to them.  */
38028   if (group == disp_jcc || group == disp_cmp)
38029     return false;
38030
38031   /* Check nonrestricted.  */
38032   if (group == disp_no_group || group == disp_branch)
38033     return true;
38034
38035   /* Get last dispatch window.  */
38036   if (window_list_next)
38037     window_list = window_list_next;
38038
38039   if (window_list->window_num == 1)
38040     {
38041       sum = window_list->prev->window_size + window_list->window_size;
38042
38043       if (sum == 32
38044           || (min_insn_size (insn) + sum) >= 48)
38045         /* Window 1 is full.  Go for next window.  */
38046         return true;
38047     }
38048
38049   num_restrict = count_num_restricted (insn, window_list);
38050
38051   if (num_restrict > num_allowable_groups[group])
38052     return false;
38053
38054   /* See if it fits in the first window.  */
38055   if (window_list->window_num == 0)
38056     {
38057       /* The first widow should have only single and double path
38058          uops.  */
38059       if (path == path_double
38060           && (window_list->num_uops + 2) > MAX_INSN)
38061         return false;
38062       else if (path != path_single)
38063         return false;
38064     }
38065   return true;
38066 }
38067
38068 /* Add an instruction INSN with NUM_UOPS micro-operations to the
38069    dispatch window WINDOW_LIST.  */
38070
38071 static void
38072 add_insn_window (rtx insn, dispatch_windows *window_list, int num_uops)
38073 {
38074   int byte_len = min_insn_size (insn);
38075   int num_insn = window_list->num_insn;
38076   int imm_size;
38077   sched_insn_info *window = window_list->window;
38078   enum dispatch_group group = get_insn_group (insn);
38079   enum insn_path path = get_insn_path (insn);
38080   int num_imm_operand;
38081   int num_imm32_operand;
38082   int num_imm64_operand;
38083
38084   if (!window_list->violation && group != disp_cmp
38085       && !fits_dispatch_window (insn))
38086     window_list->violation = true;
38087
38088   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
38089                                  &num_imm64_operand);
38090
38091   /* Initialize window with new instruction.  */
38092   window[num_insn].insn = insn;
38093   window[num_insn].byte_len = byte_len;
38094   window[num_insn].group = group;
38095   window[num_insn].path = path;
38096   window[num_insn].imm_bytes = imm_size;
38097
38098   window_list->window_size += byte_len;
38099   window_list->num_insn = num_insn + 1;
38100   window_list->num_uops = window_list->num_uops + num_uops;
38101   window_list->imm_size += imm_size;
38102   window_list->num_imm += num_imm_operand;
38103   window_list->num_imm_32 += num_imm32_operand;
38104   window_list->num_imm_64 += num_imm64_operand;
38105
38106   if (group == disp_store)
38107     window_list->num_stores += 1;
38108   else if (group == disp_load
38109            || group == disp_prefetch)
38110     window_list->num_loads += 1;
38111   else if (group == disp_load_store)
38112     {
38113       window_list->num_stores += 1;
38114       window_list->num_loads += 1;
38115     }
38116 }
38117
38118 /* Adds a scheduled instruction, INSN, to the current dispatch window.
38119    If the total bytes of instructions or the number of instructions in
38120    the window exceed allowable, it allocates a new window.  */
38121
38122 static void
38123 add_to_dispatch_window (rtx insn)
38124 {
38125   int byte_len;
38126   dispatch_windows *window_list;
38127   dispatch_windows *next_list;
38128   dispatch_windows *window0_list;
38129   enum insn_path path;
38130   enum dispatch_group insn_group;
38131   bool insn_fits;
38132   int num_insn;
38133   int num_uops;
38134   int window_num;
38135   int insn_num_uops;
38136   int sum;
38137
38138   if (INSN_CODE (insn) < 0)
38139     return;
38140
38141   byte_len = min_insn_size (insn);
38142   window_list = dispatch_window_list;
38143   next_list = window_list->next;
38144   path = get_insn_path (insn);
38145   insn_group = get_insn_group (insn);
38146
38147   /* Get the last dispatch window.  */
38148   if (next_list)
38149       window_list = dispatch_window_list->next;
38150
38151   if (path == path_single)
38152     insn_num_uops = 1;
38153   else if (path == path_double)
38154     insn_num_uops = 2;
38155   else
38156     insn_num_uops = (int) path;
38157
38158   /* If current window is full, get a new window.
38159      Window number zero is full, if MAX_INSN uops are scheduled in it.
38160      Window number one is full, if window zero's bytes plus window
38161      one's bytes is 32, or if the bytes of the new instruction added
38162      to the total makes it greater than 48, or it has already MAX_INSN
38163      instructions in it.  */
38164   num_insn = window_list->num_insn;
38165   num_uops = window_list->num_uops;
38166   window_num = window_list->window_num;
38167   insn_fits = fits_dispatch_window (insn);
38168
38169   if (num_insn >= MAX_INSN
38170       || num_uops + insn_num_uops > MAX_INSN
38171       || !(insn_fits))
38172     {
38173       window_num = ~window_num & 1;
38174       window_list = allocate_next_window (window_num);
38175     }
38176
38177   if (window_num == 0)
38178     {
38179       add_insn_window (insn, window_list, insn_num_uops);
38180       if (window_list->num_insn >= MAX_INSN
38181           && insn_group == disp_branch)
38182         {
38183           process_end_window ();
38184           return;
38185         }
38186     }
38187   else if (window_num == 1)
38188     {
38189       window0_list = window_list->prev;
38190       sum = window0_list->window_size + window_list->window_size;
38191       if (sum == 32
38192           || (byte_len + sum) >= 48)
38193         {
38194           process_end_window ();
38195           window_list = dispatch_window_list;
38196         }
38197
38198       add_insn_window (insn, window_list, insn_num_uops);
38199     }
38200   else
38201     gcc_unreachable ();
38202
38203   if (is_end_basic_block (insn_group))
38204     {
38205       /* End of basic block is reached do end-basic-block process.  */
38206       process_end_window ();
38207       return;
38208     }
38209 }
38210
38211 /* Print the dispatch window, WINDOW_NUM, to FILE.  */
38212
38213 DEBUG_FUNCTION static void
38214 debug_dispatch_window_file (FILE *file, int window_num)
38215 {
38216   dispatch_windows *list;
38217   int i;
38218
38219   if (window_num == 0)
38220     list = dispatch_window_list;
38221   else
38222     list = dispatch_window_list1;
38223
38224   fprintf (file, "Window #%d:\n", list->window_num);
38225   fprintf (file, "  num_insn = %d, num_uops = %d, window_size = %d\n",
38226           list->num_insn, list->num_uops, list->window_size);
38227   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
38228            list->num_imm, list->num_imm_32, list->num_imm_64, list->imm_size);
38229
38230   fprintf (file, "  num_loads = %d, num_stores = %d\n", list->num_loads,
38231           list->num_stores);
38232   fprintf (file, " insn info:\n");
38233
38234   for (i = 0; i < MAX_INSN; i++)
38235     {
38236       if (!list->window[i].insn)
38237         break;
38238       fprintf (file, "    group[%d] = %s, insn[%d] = %p, path[%d] = %d byte_len[%d] = %d, imm_bytes[%d] = %d\n",
38239               i, group_name[list->window[i].group],
38240               i, (void *)list->window[i].insn,
38241               i, list->window[i].path,
38242               i, list->window[i].byte_len,
38243               i, list->window[i].imm_bytes);
38244     }
38245 }
38246
38247 /* Print to stdout a dispatch window.  */
38248
38249 DEBUG_FUNCTION void
38250 debug_dispatch_window (int window_num)
38251 {
38252   debug_dispatch_window_file (stdout, window_num);
38253 }
38254
38255 /* Print INSN dispatch information to FILE.  */
38256
38257 DEBUG_FUNCTION static void
38258 debug_insn_dispatch_info_file (FILE *file, rtx insn)
38259 {
38260   int byte_len;
38261   enum insn_path path;
38262   enum dispatch_group group;
38263   int imm_size;
38264   int num_imm_operand;
38265   int num_imm32_operand;
38266   int num_imm64_operand;
38267
38268   if (INSN_CODE (insn) < 0)
38269     return;
38270
38271   byte_len = min_insn_size (insn);
38272   path = get_insn_path (insn);
38273   group = get_insn_group (insn);
38274   imm_size = get_num_immediates (insn, &num_imm_operand, &num_imm32_operand,
38275                                  &num_imm64_operand);
38276
38277   fprintf (file, " insn info:\n");
38278   fprintf (file, "  group = %s, path = %d, byte_len = %d\n",
38279            group_name[group], path, byte_len);
38280   fprintf (file, "  num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\n",
38281            num_imm_operand, num_imm32_operand, num_imm64_operand, imm_size);
38282 }
38283
38284 /* Print to STDERR the status of the ready list with respect to
38285    dispatch windows.  */
38286
38287 DEBUG_FUNCTION void
38288 debug_ready_dispatch (void)
38289 {
38290   int i;
38291   int no_ready = number_in_ready ();
38292
38293   fprintf (stdout, "Number of ready: %d\n", no_ready);
38294
38295   for (i = 0; i < no_ready; i++)
38296     debug_insn_dispatch_info_file (stdout, get_ready_element (i));
38297 }
38298
38299 /* This routine is the driver of the dispatch scheduler.  */
38300
38301 static void
38302 do_dispatch (rtx insn, int mode)
38303 {
38304   if (mode == DISPATCH_INIT)
38305     init_dispatch_sched ();
38306   else if (mode == ADD_TO_DISPATCH_WINDOW)
38307     add_to_dispatch_window (insn);
38308 }
38309
38310 /* Return TRUE if Dispatch Scheduling is supported.  */
38311
38312 static bool
38313 has_dispatch (rtx insn, int action)
38314 {
38315   if ((ix86_tune == PROCESSOR_BDVER1 || ix86_tune == PROCESSOR_BDVER2)
38316       && flag_dispatch_scheduler)
38317     switch (action)
38318       {
38319       default:
38320         return false;
38321
38322       case IS_DISPATCH_ON:
38323         return true;
38324         break;
38325
38326       case IS_CMP:
38327         return is_cmp (insn);
38328
38329       case DISPATCH_VIOLATION:
38330         return dispatch_violation ();
38331
38332       case FITS_DISPATCH_WINDOW:
38333         return fits_dispatch_window (insn);
38334       }
38335
38336   return false;
38337 }
38338
38339 /* Implementation of reassociation_width target hook used by
38340    reassoc phase to identify parallelism level in reassociated
38341    tree.  Statements tree_code is passed in OPC.  Arguments type
38342    is passed in MODE.
38343
38344    Currently parallel reassociation is enabled for Atom
38345    processors only and we set reassociation width to be 2
38346    because Atom may issue up to 2 instructions per cycle.
38347
38348    Return value should be fixed if parallel reassociation is
38349    enabled for other processors.  */
38350
38351 static int
38352 ix86_reassociation_width (unsigned int opc ATTRIBUTE_UNUSED,
38353                           enum machine_mode mode)
38354 {
38355   int res = 1;
38356
38357   if (INTEGRAL_MODE_P (mode) && TARGET_REASSOC_INT_TO_PARALLEL)
38358     res = 2;
38359   else if (FLOAT_MODE_P (mode) && TARGET_REASSOC_FP_TO_PARALLEL)
38360     res = 2;
38361
38362   return res;
38363 }
38364
38365 /* ??? No autovectorization into MMX or 3DNOW until we can reliably
38366    place emms and femms instructions.  */
38367
38368 static enum machine_mode
38369 ix86_preferred_simd_mode (enum machine_mode mode)
38370 {
38371   if (!TARGET_SSE)
38372     return word_mode;
38373
38374   switch (mode)
38375     {
38376     case QImode:
38377       return (TARGET_AVX && !TARGET_PREFER_AVX128) ? V32QImode : V16QImode;
38378     case HImode:
38379       return (TARGET_AVX && !TARGET_PREFER_AVX128) ? V16HImode : V8HImode;
38380     case SImode:
38381       return (TARGET_AVX && !TARGET_PREFER_AVX128) ? V8SImode : V4SImode;
38382     case DImode:
38383       return (TARGET_AVX && !TARGET_PREFER_AVX128) ? V4DImode : V2DImode;
38384
38385     case SFmode:
38386       if (TARGET_AVX && !TARGET_PREFER_AVX128)
38387         return V8SFmode;
38388       else
38389         return V4SFmode;
38390
38391     case DFmode:
38392       if (!TARGET_VECTORIZE_DOUBLE)
38393         return word_mode;
38394       else if (TARGET_AVX && !TARGET_PREFER_AVX128)
38395         return V4DFmode;
38396       else if (TARGET_SSE2)
38397         return V2DFmode;
38398       /* FALLTHRU */
38399
38400     default:
38401       return word_mode;
38402     }
38403 }
38404
38405 /* If AVX is enabled then try vectorizing with both 256bit and 128bit
38406    vectors.  */
38407
38408 static unsigned int
38409 ix86_autovectorize_vector_sizes (void)
38410 {
38411   return (TARGET_AVX && !TARGET_PREFER_AVX128) ? 32 | 16 : 0;
38412 }
38413
38414 /* Initialize the GCC target structure.  */
38415 #undef TARGET_RETURN_IN_MEMORY
38416 #define TARGET_RETURN_IN_MEMORY ix86_return_in_memory
38417
38418 #undef TARGET_LEGITIMIZE_ADDRESS
38419 #define TARGET_LEGITIMIZE_ADDRESS ix86_legitimize_address
38420
38421 #undef TARGET_ATTRIBUTE_TABLE
38422 #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table
38423 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
38424 #  undef TARGET_MERGE_DECL_ATTRIBUTES
38425 #  define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
38426 #endif
38427
38428 #undef TARGET_COMP_TYPE_ATTRIBUTES
38429 #define TARGET_COMP_TYPE_ATTRIBUTES ix86_comp_type_attributes
38430
38431 #undef TARGET_INIT_BUILTINS
38432 #define TARGET_INIT_BUILTINS ix86_init_builtins
38433 #undef TARGET_BUILTIN_DECL
38434 #define TARGET_BUILTIN_DECL ix86_builtin_decl
38435 #undef TARGET_EXPAND_BUILTIN
38436 #define TARGET_EXPAND_BUILTIN ix86_expand_builtin
38437
38438 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
38439 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
38440   ix86_builtin_vectorized_function
38441
38442 #undef TARGET_VECTORIZE_BUILTIN_TM_LOAD
38443 #define TARGET_VECTORIZE_BUILTIN_TM_LOAD ix86_builtin_tm_load
38444
38445 #undef TARGET_VECTORIZE_BUILTIN_TM_STORE
38446 #define TARGET_VECTORIZE_BUILTIN_TM_STORE ix86_builtin_tm_store
38447
38448 #undef TARGET_VECTORIZE_BUILTIN_GATHER
38449 #define TARGET_VECTORIZE_BUILTIN_GATHER ix86_vectorize_builtin_gather
38450
38451 #undef TARGET_BUILTIN_RECIPROCAL
38452 #define TARGET_BUILTIN_RECIPROCAL ix86_builtin_reciprocal
38453
38454 #undef TARGET_ASM_FUNCTION_EPILOGUE
38455 #define TARGET_ASM_FUNCTION_EPILOGUE ix86_output_function_epilogue
38456
38457 #undef TARGET_ENCODE_SECTION_INFO
38458 #ifndef SUBTARGET_ENCODE_SECTION_INFO
38459 #define TARGET_ENCODE_SECTION_INFO ix86_encode_section_info
38460 #else
38461 #define TARGET_ENCODE_SECTION_INFO SUBTARGET_ENCODE_SECTION_INFO
38462 #endif
38463
38464 #undef TARGET_ASM_OPEN_PAREN
38465 #define TARGET_ASM_OPEN_PAREN ""
38466 #undef TARGET_ASM_CLOSE_PAREN
38467 #define TARGET_ASM_CLOSE_PAREN ""
38468
38469 #undef TARGET_ASM_BYTE_OP
38470 #define TARGET_ASM_BYTE_OP ASM_BYTE
38471
38472 #undef TARGET_ASM_ALIGNED_HI_OP
38473 #define TARGET_ASM_ALIGNED_HI_OP ASM_SHORT
38474 #undef TARGET_ASM_ALIGNED_SI_OP
38475 #define TARGET_ASM_ALIGNED_SI_OP ASM_LONG
38476 #ifdef ASM_QUAD
38477 #undef TARGET_ASM_ALIGNED_DI_OP
38478 #define TARGET_ASM_ALIGNED_DI_OP ASM_QUAD
38479 #endif
38480
38481 #undef TARGET_PROFILE_BEFORE_PROLOGUE
38482 #define TARGET_PROFILE_BEFORE_PROLOGUE ix86_profile_before_prologue
38483
38484 #undef TARGET_ASM_UNALIGNED_HI_OP
38485 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
38486 #undef TARGET_ASM_UNALIGNED_SI_OP
38487 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
38488 #undef TARGET_ASM_UNALIGNED_DI_OP
38489 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
38490
38491 #undef TARGET_PRINT_OPERAND
38492 #define TARGET_PRINT_OPERAND ix86_print_operand
38493 #undef TARGET_PRINT_OPERAND_ADDRESS
38494 #define TARGET_PRINT_OPERAND_ADDRESS ix86_print_operand_address
38495 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
38496 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P ix86_print_operand_punct_valid_p
38497 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
38498 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA i386_asm_output_addr_const_extra
38499
38500 #undef TARGET_SCHED_INIT_GLOBAL
38501 #define TARGET_SCHED_INIT_GLOBAL ix86_sched_init_global
38502 #undef TARGET_SCHED_ADJUST_COST
38503 #define TARGET_SCHED_ADJUST_COST ix86_adjust_cost
38504 #undef TARGET_SCHED_ISSUE_RATE
38505 #define TARGET_SCHED_ISSUE_RATE ix86_issue_rate
38506 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
38507 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
38508   ia32_multipass_dfa_lookahead
38509
38510 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
38511 #define TARGET_FUNCTION_OK_FOR_SIBCALL ix86_function_ok_for_sibcall
38512
38513 #ifdef HAVE_AS_TLS
38514 #undef TARGET_HAVE_TLS
38515 #define TARGET_HAVE_TLS true
38516 #endif
38517 #undef TARGET_CANNOT_FORCE_CONST_MEM
38518 #define TARGET_CANNOT_FORCE_CONST_MEM ix86_cannot_force_const_mem
38519 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
38520 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_const_rtx_true
38521
38522 #undef TARGET_DELEGITIMIZE_ADDRESS
38523 #define TARGET_DELEGITIMIZE_ADDRESS ix86_delegitimize_address
38524
38525 #undef TARGET_MS_BITFIELD_LAYOUT_P
38526 #define TARGET_MS_BITFIELD_LAYOUT_P ix86_ms_bitfield_layout_p
38527
38528 #if TARGET_MACHO
38529 #undef TARGET_BINDS_LOCAL_P
38530 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
38531 #endif
38532 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
38533 #undef TARGET_BINDS_LOCAL_P
38534 #define TARGET_BINDS_LOCAL_P i386_pe_binds_local_p
38535 #endif
38536
38537 #undef TARGET_ASM_OUTPUT_MI_THUNK
38538 #define TARGET_ASM_OUTPUT_MI_THUNK x86_output_mi_thunk
38539 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
38540 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK x86_can_output_mi_thunk
38541
38542 #undef TARGET_ASM_FILE_START
38543 #define TARGET_ASM_FILE_START x86_file_start
38544
38545 #undef TARGET_OPTION_OVERRIDE
38546 #define TARGET_OPTION_OVERRIDE ix86_option_override
38547
38548 #undef TARGET_REGISTER_MOVE_COST
38549 #define TARGET_REGISTER_MOVE_COST ix86_register_move_cost
38550 #undef TARGET_MEMORY_MOVE_COST
38551 #define TARGET_MEMORY_MOVE_COST ix86_memory_move_cost
38552 #undef TARGET_RTX_COSTS
38553 #define TARGET_RTX_COSTS ix86_rtx_costs
38554 #undef TARGET_ADDRESS_COST
38555 #define TARGET_ADDRESS_COST ix86_address_cost
38556
38557 #undef TARGET_FIXED_CONDITION_CODE_REGS
38558 #define TARGET_FIXED_CONDITION_CODE_REGS ix86_fixed_condition_code_regs
38559 #undef TARGET_CC_MODES_COMPATIBLE
38560 #define TARGET_CC_MODES_COMPATIBLE ix86_cc_modes_compatible
38561
38562 #undef TARGET_MACHINE_DEPENDENT_REORG
38563 #define TARGET_MACHINE_DEPENDENT_REORG ix86_reorg
38564
38565 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
38566 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE ix86_builtin_setjmp_frame_value
38567
38568 #undef TARGET_BUILD_BUILTIN_VA_LIST
38569 #define TARGET_BUILD_BUILTIN_VA_LIST ix86_build_builtin_va_list
38570
38571 #undef TARGET_ENUM_VA_LIST_P
38572 #define TARGET_ENUM_VA_LIST_P ix86_enum_va_list
38573
38574 #undef TARGET_FN_ABI_VA_LIST
38575 #define TARGET_FN_ABI_VA_LIST ix86_fn_abi_va_list
38576
38577 #undef TARGET_CANONICAL_VA_LIST_TYPE
38578 #define TARGET_CANONICAL_VA_LIST_TYPE ix86_canonical_va_list_type
38579
38580 #undef TARGET_EXPAND_BUILTIN_VA_START
38581 #define TARGET_EXPAND_BUILTIN_VA_START ix86_va_start
38582
38583 #undef TARGET_MD_ASM_CLOBBERS
38584 #define TARGET_MD_ASM_CLOBBERS ix86_md_asm_clobbers
38585
38586 #undef TARGET_PROMOTE_PROTOTYPES
38587 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
38588 #undef TARGET_STRUCT_VALUE_RTX
38589 #define TARGET_STRUCT_VALUE_RTX ix86_struct_value_rtx
38590 #undef TARGET_SETUP_INCOMING_VARARGS
38591 #define TARGET_SETUP_INCOMING_VARARGS ix86_setup_incoming_varargs
38592 #undef TARGET_MUST_PASS_IN_STACK
38593 #define TARGET_MUST_PASS_IN_STACK ix86_must_pass_in_stack
38594 #undef TARGET_FUNCTION_ARG_ADVANCE
38595 #define TARGET_FUNCTION_ARG_ADVANCE ix86_function_arg_advance
38596 #undef TARGET_FUNCTION_ARG
38597 #define TARGET_FUNCTION_ARG ix86_function_arg
38598 #undef TARGET_FUNCTION_ARG_BOUNDARY
38599 #define TARGET_FUNCTION_ARG_BOUNDARY ix86_function_arg_boundary
38600 #undef TARGET_PASS_BY_REFERENCE
38601 #define TARGET_PASS_BY_REFERENCE ix86_pass_by_reference
38602 #undef TARGET_INTERNAL_ARG_POINTER
38603 #define TARGET_INTERNAL_ARG_POINTER ix86_internal_arg_pointer
38604 #undef TARGET_UPDATE_STACK_BOUNDARY
38605 #define TARGET_UPDATE_STACK_BOUNDARY ix86_update_stack_boundary
38606 #undef TARGET_GET_DRAP_RTX
38607 #define TARGET_GET_DRAP_RTX ix86_get_drap_rtx
38608 #undef TARGET_STRICT_ARGUMENT_NAMING
38609 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
38610 #undef TARGET_STATIC_CHAIN
38611 #define TARGET_STATIC_CHAIN ix86_static_chain
38612 #undef TARGET_TRAMPOLINE_INIT
38613 #define TARGET_TRAMPOLINE_INIT ix86_trampoline_init
38614 #undef TARGET_RETURN_POPS_ARGS
38615 #define TARGET_RETURN_POPS_ARGS ix86_return_pops_args
38616
38617 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
38618 #define TARGET_GIMPLIFY_VA_ARG_EXPR ix86_gimplify_va_arg
38619
38620 #undef TARGET_SCALAR_MODE_SUPPORTED_P
38621 #define TARGET_SCALAR_MODE_SUPPORTED_P ix86_scalar_mode_supported_p
38622
38623 #undef TARGET_VECTOR_MODE_SUPPORTED_P
38624 #define TARGET_VECTOR_MODE_SUPPORTED_P ix86_vector_mode_supported_p
38625
38626 #undef TARGET_C_MODE_FOR_SUFFIX
38627 #define TARGET_C_MODE_FOR_SUFFIX ix86_c_mode_for_suffix
38628
38629 #ifdef HAVE_AS_TLS
38630 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
38631 #define TARGET_ASM_OUTPUT_DWARF_DTPREL i386_output_dwarf_dtprel
38632 #endif
38633
38634 #ifdef SUBTARGET_INSERT_ATTRIBUTES
38635 #undef TARGET_INSERT_ATTRIBUTES
38636 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
38637 #endif
38638
38639 #undef TARGET_MANGLE_TYPE
38640 #define TARGET_MANGLE_TYPE ix86_mangle_type
38641
38642 #if !TARGET_MACHO
38643 #undef TARGET_STACK_PROTECT_FAIL
38644 #define TARGET_STACK_PROTECT_FAIL ix86_stack_protect_fail
38645 #endif
38646
38647 #undef TARGET_FUNCTION_VALUE
38648 #define TARGET_FUNCTION_VALUE ix86_function_value
38649
38650 #undef TARGET_FUNCTION_VALUE_REGNO_P
38651 #define TARGET_FUNCTION_VALUE_REGNO_P ix86_function_value_regno_p
38652
38653 #undef TARGET_PROMOTE_FUNCTION_MODE
38654 #define TARGET_PROMOTE_FUNCTION_MODE ix86_promote_function_mode
38655
38656 #undef TARGET_SECONDARY_RELOAD
38657 #define TARGET_SECONDARY_RELOAD ix86_secondary_reload
38658
38659 #undef TARGET_CLASS_MAX_NREGS
38660 #define TARGET_CLASS_MAX_NREGS ix86_class_max_nregs
38661
38662 #undef TARGET_PREFERRED_RELOAD_CLASS
38663 #define TARGET_PREFERRED_RELOAD_CLASS ix86_preferred_reload_class
38664 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
38665 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS ix86_preferred_output_reload_class
38666 #undef TARGET_CLASS_LIKELY_SPILLED_P
38667 #define TARGET_CLASS_LIKELY_SPILLED_P ix86_class_likely_spilled_p
38668
38669 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
38670 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
38671   ix86_builtin_vectorization_cost
38672 #undef TARGET_VECTORIZE_VEC_PERM_CONST_OK
38673 #define TARGET_VECTORIZE_VEC_PERM_CONST_OK \
38674   ix86_vectorize_vec_perm_const_ok
38675 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
38676 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
38677   ix86_preferred_simd_mode
38678 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
38679 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
38680   ix86_autovectorize_vector_sizes
38681
38682 #undef TARGET_SET_CURRENT_FUNCTION
38683 #define TARGET_SET_CURRENT_FUNCTION ix86_set_current_function
38684
38685 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
38686 #define TARGET_OPTION_VALID_ATTRIBUTE_P ix86_valid_target_attribute_p
38687
38688 #undef TARGET_OPTION_SAVE
38689 #define TARGET_OPTION_SAVE ix86_function_specific_save
38690
38691 #undef TARGET_OPTION_RESTORE
38692 #define TARGET_OPTION_RESTORE ix86_function_specific_restore
38693
38694 #undef TARGET_OPTION_PRINT
38695 #define TARGET_OPTION_PRINT ix86_function_specific_print
38696
38697 #undef TARGET_CAN_INLINE_P
38698 #define TARGET_CAN_INLINE_P ix86_can_inline_p
38699
38700 #undef TARGET_EXPAND_TO_RTL_HOOK
38701 #define TARGET_EXPAND_TO_RTL_HOOK ix86_maybe_switch_abi
38702
38703 #undef TARGET_LEGITIMATE_ADDRESS_P
38704 #define TARGET_LEGITIMATE_ADDRESS_P ix86_legitimate_address_p
38705
38706 #undef TARGET_LEGITIMATE_CONSTANT_P
38707 #define TARGET_LEGITIMATE_CONSTANT_P ix86_legitimate_constant_p
38708
38709 #undef TARGET_FRAME_POINTER_REQUIRED
38710 #define TARGET_FRAME_POINTER_REQUIRED ix86_frame_pointer_required
38711
38712 #undef TARGET_CAN_ELIMINATE
38713 #define TARGET_CAN_ELIMINATE ix86_can_eliminate
38714
38715 #undef TARGET_EXTRA_LIVE_ON_ENTRY
38716 #define TARGET_EXTRA_LIVE_ON_ENTRY ix86_live_on_entry
38717
38718 #undef TARGET_ASM_CODE_END
38719 #define TARGET_ASM_CODE_END ix86_code_end
38720
38721 #undef TARGET_CONDITIONAL_REGISTER_USAGE
38722 #define TARGET_CONDITIONAL_REGISTER_USAGE ix86_conditional_register_usage
38723
38724 #if TARGET_MACHO
38725 #undef TARGET_INIT_LIBFUNCS
38726 #define TARGET_INIT_LIBFUNCS darwin_rename_builtins
38727 #endif
38728
38729 struct gcc_target targetm = TARGET_INITIALIZER;
38730 \f
38731 #include "gt-i386.h"